From cb399162abca7bc600984ec4e2b1341f3d4331c4 Mon Sep 17 00:00:00 2001 From: Dzming Li Date: Fri, 12 Sep 2025 10:31:58 +0800 Subject: [PATCH] Merge upstream changes with comprehensive conflict resolution Resolved 50+ merge conflicts systematically, preserving all PLCTLab functionality while adopting upstream enhancements. ## Key Conflict Resolutions: **Type System** - Extended support for T_int16, T_uint16, T_raw_func, T_local types - Integrated trait alias support with PLCTLab's object safety analysis **Compilation Architecture** - Hybrid RISC-V (PLCTLab) + modern WASM (upstream) pipeline support - Combined clam_callback and dwarfsm_callback systems - Target support: wasm-gc, wasm, js, riscv, native, llvm **Performance Optimizations** - Adopted upstream's optimized list operations (special cases for small lists) - Upgraded topological sorting to comprehensive set-based dependency analysis - Enhanced pattern matching with async and guard expression support **Code Quality** - Preserved PLCTLab's clean manual implementations over auto-generated code - Maintained robust error handling patterns - Ensured backward compatibility for CLI interfaces ## Critical Integrations: - Foreign trait compile-time processing (placeholder_env.ml + toplevel_typer.ml) - Pattern matching architectural rewrite (check_match.ml) - Function desugaring with async support (parsing_ast_lint.ml) --- .gitattributes | 1 + README.md | 36 + README.zh.md | 38 +- src/addr_table.ml | 47 - src/alerts.ml | 137 +- src/ast_builder.ml | 397 + src/ast_derive.ml | 2952 +- src/attribute.ml | 74 + src/attribute_parser.ml | 621 + src/basic_arr.ml | 13 +- src/basic_binary_search.ml | 49 +- src/basic_case_set_intf.ml | 4 +- src/basic_compress_stamp.ml | 78 +- src/basic_config.ml | 28 +- src/basic_constr_info.ml | 12 +- src/basic_core_ident.ml | 605 +- src/basic_diet.ml | 55 +- src/basic_duplicate_check.ml | 71 + src/basic_encoders.ml | 113 +- src/basic_fn_address.ml | 89 +- src/basic_hash_gen.ml | 111 +- src/basic_hash_int.ml | 85 +- src/basic_hash_intf.ml | 1 + src/basic_hash_string.ml | 85 +- src/basic_hashf.ml | 84 +- src/basic_hashset_gen.ml | 2 +- src/basic_hashset_int.ml | 48 +- src/basic_hashset_string.ml | 48 +- src/basic_hashsetf.ml | 46 +- src/basic_ident.ml | 809 +- src/basic_int.ml | 45 + src/basic_io.ml | 10 +- src/basic_iter.ml | 29 +- src/basic_longident.ml | 34 +- src/basic_lst.ml | 524 +- src/basic_map_gen.ml | 88 +- src/basic_map_int.ml | 198 +- src/basic_map_string.ml | 198 +- src/basic_mapf.ml | 196 +- src/basic_ordered_hash_map_gen.ml | 6 +- src/basic_qual_ident.ml | 69 +- src/basic_ref.ml | 6 +- src/basic_scc.ml | 3 +- src/basic_set_gen.ml | 85 +- src/basic_set_intf.ml | 1 + src/basic_set_string.ml | 240 +- src/basic_setf.ml | 237 +- src/basic_strutil.ml | 28 +- src/basic_ty_ident.ml | 30 +- src/basic_type_path.ml | 572 +- src/basic_uchar_utils.ml | 9 +- src/basic_uint32.ml | 2 +- src/basic_uint64.ml | 2 +- src/basic_utf8.ml | 174 +- src/basic_vec.ml | 20 +- src/basic_vec_int.ml | 51 +- src/basic_vec_string.ml | 101 + src/builtin.ml | 242 +- src/check_match.ml | 358 +- src/check_purity.ml | 51 +- src/check_purity1.ml | 40 - src/checked_attributes.ml | 143 + src/clam.ml | 4722 +- src/clam1.ml | 3212 - src/clam1_ident.ml | 657 +- src/clam1_of_core.ml | 1356 - src/clam1_util.ml | 45 - src/clam_ident.ml | 655 +- src/clam_of_core.ml | 2289 +- src/clam_util.ml | 8 +- src/const_table.ml | 116 +- src/const_util.ml | 262 + src/constant.ml | 299 +- src/constraint_cache.ml | 24 +- src/control_ctx.ml | 382 +- src/core.ml | 7110 +- src/core_dce.ml | 36 +- src/core_format.ml | 125 +- src/core_link.ml | 52 +- src/core_of_tast.ml | 3185 +- src/core_util.ml | 1778 +- src/ctype.ml | 154 +- src/dead_code.ml | 1047 +- src/derive.ml | 212 +- src/derive_args.ml | 334 +- src/diagnostics.ml | 101 +- src/docstring.ml | 74 +- src/driver_compenv.ml | 41 +- src/driver_config.ml | 119 +- src/driver_util.ml | 416 +- src/dune | 9 +- src/dwarf_basic.ml | 63 - src/dwarf_consts.ml | 55 - src/dwarfsm_ast.ml | 3235 +- src/{basic_int_util.ml => dwarfsm_basic.ml} | 7 +- src/dwarfsm_elim_equivdefn.ml | 413 + src/dwarfsm_encode.ml | 9 +- src/dwarfsm_encode_context.ml | 6 +- src/dwarfsm_encode_resolve.ml | 44 +- src/dwarfsm_encode_wasm.ml | 206 +- src/dwarfsm_instr_utils.ml | 76 + src/dwarfsm_itype.ml | 50 +- src/dwarfsm_local_resolve.ml | 105 + src/dwarfsm_parse.ml | 562 +- src/dwarfsm_sexp_parse.ml | 17 +- src/dwarfsm_sexp_parser.ml | 84 +- src/eliminate_async.ml | 1032 + src/error_code.ml | 35 +- src/error_code_utils.ml | 29 + src/errors.ml | 3682 +- src/exported_functions.ml | 49 +- src/ext_method_env.ml | 68 +- src/fn_arity.ml | 439 +- src/foreach_util.ml | 232 +- src/gen_test_info.ml | 80 +- src/git_commit.ml | 4 +- src/global_ctx2.ml | 567 +- src/global_env.ml | 1133 +- src/grouped_typedefs.ml | 132 +- src/hash.c | 64 +- src/hashed_type.ml | 187 +- src/ice_catcher.ml | 4 +- src/join.ml | 9 +- src/json.ml | 6 +- src/json_lexer.ml | 63 +- src/json_literal.ml | 159 +- src/json_parse.ml | 110 +- src/label.ml | 3 + src/lambda_lift.ml | 131 +- src/lex_keyword_tbl.ml | 5 +- src/lex_literal.ml | 9 +- src/lex_menhir_token.ml | 290 +- src/lex_menhir_token_util.ml | 204 + src/lex_moon_rt.ml | 19 +- src/lex_semi_insertion.ml | 28 +- src/lex_token_triple.ml | 21 +- src/lex_unicode_lex.ml | 2425 +- src/lex_vec_comment.ml | 52 +- src/lexing.ml | 37 + src/loc.ml | 206 +- src/local_diagnostics.ml | 151 +- src/local_env.ml | 14 +- src/local_type.ml | 317 + src/local_typing_worklist.ml | 90 + src/ltype.ml | 554 +- src/ltype_gc.ml | 439 +- src/ltype_gc_util.ml | 25 +- src/ltype_util.ml | 73 - src/mcore.ml | 7262 +- src/mcore_util.ml | 234 +- src/method_env.ml | 438 +- src/mi_format.ml | 203 +- src/monofy.ml | 377 +- src/monofy_analyze.ml | 389 +- src/monofy_env.ml | 4 +- src/monofy_instances.ml | 14 +- src/monofy_worklist.ml | 415 +- src/moon0_main.ml | 373 +- src/moon_intrinsic.ml | 76 +- src/moon_sexp_conv.ml | 36 +- src/mtype.ml | 1014 +- src/name_mangle.ml | 132 +- src/object_util.ml | 10 - src/parsing_ast_lint.ml | 775 +- src/parsing_compact.ml | 59 +- src/parsing_core.ml | 532 + src/parsing_header_parser.ml | 63 +- src/parsing_import_path.ml | 9 +- src/parsing_interp.ml | 20 +- src/parsing_main.ml | 3780 + src/parsing_parse.ml | 304 +- src/parsing_parser.ml | 278319 +++++------------ src/parsing_parser.mly | 1301 - src/parsing_partial_info.ml | 14 +- src/parsing_segment.ml | 124 +- src/parsing_syntax.ml | 18180 +- src/parsing_util.ml | 485 +- src/pass_contification.ml | 364 +- src/pass_inline_single_use_join.ml | 8 +- src/pass_layout.ml | 108 +- src/pass_let_alias.ml | 48 +- src/pass_propagate_constr.ml | 151 + src/pass_shrink_wasm.ml | 130 - src/pass_stackalloc.ml | 90 +- src/pass_unbox_loop_params.ml | 235 + src/pass_unused_let.ml | 231 +- src/pass_unused_let1.ml | 144 - src/pat_path.ml | 264 +- src/patch.ml | 124 + src/patmatch_db.ml | 232 +- src/patmatch_static_info.ml | 1505 +- src/pattern_id.ml | 21 +- src/pattern_typer.ml | 1554 +- src/pkg.ml | 408 +- src/pkg_config_util.ml | 244 +- src/pkg_info.ml | 283 +- src/pkg_path_tbl.ml | 4 +- src/placeholder_env.ml | 147 +- src/poly_type.ml | 132 +- src/ppx_base.ml | 2 +- src/primitive.ml | 599 +- src/printer.ml | 72 +- src/riscv.ml | 2 +- src/riscv_generate.ml | 71 +- src/riscv_ssa.ml | 4 +- src/rloc.ml | 143 +- src/runtime_gc.ml | 4903 +- src/runtime_gc_js_string_api.ml | 2765 +- src/s.ml | 2 +- src/sexp_visitors.ml | 72 +- src/shrink_wasmir.ml | 300 + src/specialize_operator.ml | 22 +- src/stub_type.ml | 302 +- src/stype.ml | 138 +- src/tag.ml | 55 +- src/text_segment.ml | 93 + src/toplevel_segments.ml | 71 + src/toplevel_typer.ml | 3957 +- src/topo_sort.ml | 122 +- src/trait_closure.ml | 19 +- src/trait_decl.ml | 126 +- src/trait_impl.ml | 51 +- src/transl_match.ml | 957 +- src/transl_mtype.ml | 161 - src/transl_mtype_gc.ml | 251 +- src/transl_type.ml | 598 +- src/tvar_env.ml | 93 +- src/type.ml | 463 +- src/type_alias.ml | 106 + src/type_args.ml | 41 +- src/type_constraint.ml | 267 +- src/type_lint.ml | 21 +- src/type_subst.ml | 67 +- src/typecheck_driver_util.ml | 42 + src/typedecl_info.ml | 732 +- src/typedtree.ml | 16257 +- src/typedtree_util.ml | 62 +- src/typer.ml | 8892 +- src/typeutil.ml | 2383 +- src/typing_info.ml | 80 +- src/value_info.ml | 106 +- src/value_tracing.ml | 256 + src/w.ml | 66 +- src/warnings.ml | 1770 +- src/wasm_lex.ml | 3343 +- src/wasm_of_clam_gc.ml | 3320 +- src/wasm_util.ml | 908 - src/wasmgc_constr.ml | 310 + src/wasmir_util.ml | 419 + src/wasmlinear_constr.ml | 438 + 250 files changed, 155844 insertions(+), 279285 deletions(-) create mode 100644 .gitattributes delete mode 100644 src/addr_table.ml create mode 100644 src/ast_builder.ml create mode 100644 src/attribute.ml create mode 100644 src/attribute_parser.ml create mode 100644 src/basic_duplicate_check.ml create mode 100644 src/basic_int.ml create mode 100644 src/basic_vec_string.ml delete mode 100644 src/check_purity1.ml create mode 100644 src/checked_attributes.ml delete mode 100644 src/clam1.ml delete mode 100644 src/clam1_of_core.ml delete mode 100644 src/clam1_util.ml create mode 100644 src/const_util.ml delete mode 100644 src/dwarf_basic.ml delete mode 100644 src/dwarf_consts.ml rename src/{basic_int_util.ml => dwarfsm_basic.ml} (85%) create mode 100644 src/dwarfsm_elim_equivdefn.ml create mode 100644 src/dwarfsm_instr_utils.ml create mode 100644 src/dwarfsm_local_resolve.ml create mode 100644 src/eliminate_async.ml create mode 100644 src/error_code_utils.ml create mode 100644 src/lex_menhir_token_util.ml create mode 100644 src/lexing.ml create mode 100644 src/local_type.ml create mode 100644 src/local_typing_worklist.ml delete mode 100644 src/ltype_util.ml create mode 100644 src/parsing_core.ml create mode 100644 src/parsing_main.ml delete mode 100644 src/parsing_parser.mly create mode 100644 src/pass_propagate_constr.ml delete mode 100644 src/pass_shrink_wasm.ml create mode 100644 src/pass_unbox_loop_params.ml delete mode 100644 src/pass_unused_let1.ml create mode 100644 src/patch.ml create mode 100644 src/shrink_wasmir.ml create mode 100644 src/text_segment.ml create mode 100644 src/toplevel_segments.ml delete mode 100644 src/transl_mtype.ml create mode 100644 src/type_alias.ml create mode 100644 src/typecheck_driver_util.ml create mode 100644 src/value_tracing.ml delete mode 100644 src/wasm_util.ml create mode 100644 src/wasmgc_constr.ml create mode 100644 src/wasmir_util.ml create mode 100644 src/wasmlinear_constr.ml diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..ce1270e --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.wasm binary \ No newline at end of file diff --git a/README.md b/README.md index aaa88d0..21c778b 100644 --- a/README.md +++ b/README.md @@ -88,6 +88,42 @@ Then `$dest` would be available for use. In case you are still in doubt, refer to the output of `moon run --dry-run`. +## Use Wasm-based MoonBit Compiler + +First, you need to install Node.js and curl. Then, run the following commands in a temp directory: + +```shell +curl -fSL -O https://github.com/moonbitlang/moonbit-compiler/releases/latest/download/moonbit-wasm.tar.gz +tar -zxvf moonbit-wasm.tar.gz +mkdir -p $HOME/.moon +MOON_VERSION=$(cat ./moon_version) +MOON_HOME="$HOME/.moon" +BIN_DIR="$MOON_HOME/bin" +mkdir -p "$BIN_DIR" +git clone https://github.com/moonbitlang/moon +cd moon +git reset --hard "$MOON_VERSION" +cargo build --release +cp target/release/moon "$BIN_DIR" +cp target/release/moonrun "$BIN_DIR" +cd .. +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' moonc.js +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' moonfmt.js +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' mooninfo.js +cp moonc.js moonfmt.js mooninfo.js moonc.assets moonfmt.assets mooninfo.assets "$BIN_DIR" -r +mv "$BIN_DIR/moonc.js" "$BIN_DIR/moonc" +mv "$BIN_DIR/moonfmt.js" "$BIN_DIR/moonfmt" +mv "$BIN_DIR/mooninfo.js" "$BIN_DIR/mooninfo" +chmod +x "$BIN_DIR/moonc" +chmod +x "$BIN_DIR/moonfmt" +chmod +x "$BIN_DIR/mooninfo" +cp lib include "$MOON_HOME" +CORE_VERSION=$(cat ./core_version) +git clone https://github.com/moonbitlang/core "$MOON_HOME/lib/core" +cd "$MOON_HOME/lib/core" +git reset --hard "$CORE_VERSION" +moon bundle --target all +``` ## Contributing The project is evolving extremely fast that it is not yet ready for massive community contributions. diff --git a/README.zh.md b/README.zh.md index 3d4c37d..85bbf7e 100644 --- a/README.zh.md +++ b/README.zh.md @@ -75,7 +75,7 @@ moon bundle --source-dir $core bundled=$core/target/wasm-gc/release/bundle # 这里 main.mbt 是一个含有 `fn main` 的文件。 -moonc build-package $src/main.mbt -is-main -std-path $core/target/$bundled -o $obj -target $target +moonc build-package $src/main.mbt -is-main -std-path $bundled -o $obj # 如果有不止一个包，别忘了在 -pkg-sources 里指定所有包的路径。 moonc link-core $bundled/core.core $obj -o $dest -pkg-config-path $src/moon.pkg.json -pkg-sources $core:$src -target $target @@ -85,6 +85,42 @@ moonc link-core $bundled/core.core $obj -o $dest -pkg-config-path $src/moon.pkg. 如果你仍有疑问，可以参考 `moon run --dry-run` 的输出。 +## 使用wasm版的MoonBit编译器 + +首先需要安装nodejs和curl, 然后在任意的临时目录下执行以下命令 + +```shell +curl -fSL -O https://github.com/moonbitlang/moonbit-compiler/releases/latest/download/moonbit-wasm.tar.gz +tar -zxvf moonbit-wasm.tar.gz +mkdir -p $HOME/.moon +MOON_VERSION=$(cat ./moon_version) +MOON_HOME="$HOME/.moon" +BIN_DIR="$MOON_HOME/bin" +mkdir -p "$BIN_DIR" +git clone https://github.com/moonbitlang/moon +cd moon +git reset --hard "$MOON_VERSION" +cargo build --release +cp target/release/moon "$BIN_DIR" +cp target/release/moonrun "$BIN_DIR" +cd .. +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' moonc.js +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' moonfmt.js +sed -i '1 i #!/usr/bin/env -S node --stack-size=4096' mooninfo.js +cp moonc.js moonfmt.js mooninfo.js moonc.assets moonfmt.assets mooninfo.assets "$BIN_DIR" -r +mv "$BIN_DIR/moonc.js" "$BIN_DIR/moonc" +mv "$BIN_DIR/moonfmt.js" "$BIN_DIR/moonfmt" +mv "$BIN_DIR/mooninfo.js" "$BIN_DIR/mooninfo" +chmod +x "$BIN_DIR/moonc" +chmod +x "$BIN_DIR/moonfmt" +chmod +x "$BIN_DIR/mooninfo" +cp lib include "$MOON_HOME" +CORE_VERSION=$(cat ./core_version) +git clone https://github.com/moonbitlang/core "$MOON_HOME/lib/core" +cd "$MOON_HOME/lib/core" +git reset --hard "$CORE_VERSION" +moon bundle --target all +``` ## 贡献 这个项目正在快速演进，因此还没有准备好接受大量社区贡献。 diff --git a/src/addr_table.ml b/src/addr_table.ml deleted file mode 100644 index c6c9488..0000000 --- a/src/addr_table.ml +++ /dev/null @@ -1,47 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Fn_address = Basic_fn_address -module Ident_hash = Basic_core_ident.Hash -module Ident = Clam1_ident -module Core_ident = Basic_core_ident - -type fn_info = - | Toplevel of { - addr : Fn_address.t; - params : Ident.t list; - return : Ltype.return_type; - mutable name_as_closure : Ident.t option; - } - | Local of Fn_address.t * Ltype.t - -type t = fn_info Ident_hash.t - -let add_toplevel_fn (t : t) (name : Core_ident.t) ~params ~return = - match[@warning "-fragile-match"] name with - | Pdot qual_name -> - let addr = Fn_address.of_qual_ident qual_name in - Ident_hash.add t name - (Toplevel { addr; params; return; name_as_closure = None }) - | _ -> assert false - -let add_local_fn_addr_and_type (t : t) (name : Core_ident.t) - (addr : Fn_address.t) ty = - Ident_hash.add t name (Local (addr, ty)) - -let find_exn = Ident_hash.find_exn -let find_opt = Ident_hash.find_opt -let create = Ident_hash.create -let fold = Ident_hash.fold diff --git a/src/alerts.ml b/src/alerts.ml index 158f1a7..fde61b6 100644 --- a/src/alerts.ml +++ b/src/alerts.ml @@ -21,13 +21,13 @@ include struct let _ = sexp_of_alert_id let compare_alert_id = - (fun a__001_ b__002_ -> Stdlib.compare (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.compare (a__001_ : string) b__002_ : alert_id -> alert_id -> int) let _ = compare_alert_id let equal_alert_id = - (fun a__003_ b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ : alert_id -> alert_id -> bool) let _ = equal_alert_id @@ -58,7 +58,8 @@ include struct let _ = fun (_ : t) -> () let sexp_of_t = - (fun { loc = loc__010_; category = category__012_; message = message__014_ } -> + (fun { loc = loc__010_; category = category__012_; message = message__014_ } + -> let bnds__009_ = ([] : _ Stdlib.List.t) in let bnds__009_ = let arg__015_ = Moon_sexp_conv.sexp_of_string message__014_ in @@ -80,41 +81,46 @@ include struct let _ = sexp_of_t let compare = - (fun a__016_ b__017_ -> - if Stdlib.( == ) a__016_ b__017_ then 0 - else - match Loc.compare a__016_.loc b__017_.loc with - | 0 -> ( - match compare_alert_id a__016_.category b__017_.category with - | 0 -> Stdlib.compare (a__016_.message : string) b__017_.message - | n -> n) - | n -> n + (fun a__016_ -> + fun b__017_ -> + if Stdlib.( == ) a__016_ b__017_ then 0 + else + match Loc.compare a__016_.loc b__017_.loc with + | 0 -> ( + match compare_alert_id a__016_.category b__017_.category with + | 0 -> Stdlib.compare (a__016_.message : string) b__017_.message + | n -> n) + | n -> n : t -> t -> int) let _ = compare let equal = - (fun a__018_ b__019_ -> - if Stdlib.( == ) a__018_ b__019_ then true - else - Stdlib.( && ) - (Loc.equal a__018_.loc b__019_.loc) - (Stdlib.( && ) - (equal_alert_id a__018_.category b__019_.category) - (Stdlib.( = ) (a__018_.message : string) b__019_.message)) + (fun a__018_ -> + fun b__019_ -> + if Stdlib.( == ) a__018_ b__019_ then true + else + Stdlib.( && ) + (Loc.equal a__018_.loc b__019_.loc) + (Stdlib.( && ) + (equal_alert_id a__018_.category b__019_.category) + (Stdlib.( = ) (a__018_.message : string) b__019_.message)) : t -> t -> bool) let _ = equal end -let message ~as_error t : string = - let padding len m = String.make (Int.max 0 (len - String.length m)) '0' ^ m in - let id = t.category in - let leading = - if as_error then "Error (Alert " ^ padding 3 id ^ "): " - else "Warning (Alert " ^ padding 3 id ^ "): " - in - leading ^ t.message +let message ~as_error t = + (let padding len m = + String.make (Int.max 0 (len - String.length m)) '0' ^ m + in + let id = t.category in + let leading = + if as_error then "Error (Alert " ^ padding 3 id ^ "): " + else "Warning (Alert " ^ padding 3 id ^ "): " + in + leading ^ t.message + : string) let alerts = Hashtbl.create 10 let post_process = ref None @@ -134,43 +140,44 @@ let register_alert id = Hashtbl.add alerts id Warning; match !post_process with Some f -> f id | None -> ()) -let parse_options s : unit = - let enable id = - match Hashtbl.find_opt alerts id with - | Some Disabled | None -> Hashtbl.replace alerts id Warning - | _ -> () - in - let disable id = Hashtbl.replace alerts id Disabled in - let enable_as_error id = Hashtbl.replace alerts id Error in - let error msg = raise (Arg.Bad ("Ill-formed list of alerts: " ^ msg)) in - let unknown_token c = error ("Unexpected token '" ^ String.make 1 c ^ "'") in - let rec ident i acc = - if i < String.length s then - let c = s.[i] in - match c with - | '0' .. '9' | 'a' .. 'z' | 'A' .. 'Z' | '_' -> - ident (i + 1) (acc ^ String.make 1 c) - | _ -> (i, acc) - else (i, acc) - in - let rec loop i = - if i < String.length s then ( - let f = - match s.[i] with - | '+' -> enable - | '-' -> disable - | '@' -> enable_as_error - | _ -> unknown_token s.[i] - in - let i, id = ident (i + 1) "" in - (match id with - | "all" | "All" -> - Hashtbl.iter (fun k _ -> f k) alerts; - post_process := Some f - | _ -> f id); - loop i) - in - loop 0 +let parse_options s = + (let enable id = + match Hashtbl.find_opt alerts id with + | Some Disabled | None -> Hashtbl.replace alerts id Warning + | _ -> () + in + let disable id = Hashtbl.replace alerts id Disabled in + let enable_as_error id = Hashtbl.replace alerts id Error in + let error msg = raise (Arg.Bad ("Ill-formed list of alerts: " ^ msg)) in + let unknown_token c = error ("Unexpected token '" ^ String.make 1 c ^ "'") in + let rec ident i acc = + if i < String.length s then + let c = s.[i] in + match c with + | '0' .. '9' | 'a' .. 'z' | 'A' .. 'Z' | '_' -> + ident (i + 1) (acc ^ String.make 1 c) + | _ -> (i, acc) + else (i, acc) + in + let rec loop i = + if i < String.length s then ( + let f = + match s.[i] with + | '+' -> enable + | '-' -> disable + | '@' -> enable_as_error + | _ -> unknown_token s.[i] + in + let i, id = ident (i + 1) "" in + (match id with + | "all" | "All" -> + Hashtbl.iter (fun k -> fun _ -> f k) alerts; + post_process := Some f + | _ -> f id); + loop i) + in + loop 0 + : unit) let default_alerts = "+all-raise-throw-unsafe+deprecated" let () = parse_options default_alerts diff --git a/src/ast_builder.ml b/src/ast_builder.ml new file mode 100644 index 0000000..4b99c63 --- /dev/null +++ b/src/ast_builder.ml @@ -0,0 +1,397 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Syntax = Parsing_syntax +module Lst = Basic_lst +module Vec = Basic_vec + +let ghost_loc_ = Rloc.no_location + +let typ (ty_name : string) (tys : Syntax.typ list) = + (Ptype_name + { + constr_id = { lid = Lident ty_name; loc_ = ghost_loc_ }; + tys; + loc_ = ghost_loc_; + } + : Syntax.typ) + +let typ_any : Syntax.typ = Ptype_any { loc_ = ghost_loc_ } + +let extract_option_inner (ty : Syntax.typ) = + match ty with + | Ptype_option { ty; _ } -> Some ty + | Ptype_name { constr_id = { lid = Lident "Option"; _ }; tys = ty :: []; _ } + -> + Some ty + | _ -> None + +let type_is_option (ty : Syntax.typ) = + match ty with + | Ptype_option _ | Ptype_name { constr_id = { lid = Lident "Option"; _ }; _ } + -> + true + | _ -> false + +let label label_name = ({ label_name; loc_ = ghost_loc_ } : Syntax.label) + +let type_name name = + ({ name; is_object = false; loc_ = ghost_loc_ } : Syntax.type_name) + +let hole : Syntax.expr = Pexpr_hole { loc_ = ghost_loc_; kind = Synthesized } + +let const_uint_pat i = + (Ppat_constant { c = Const_uint i; loc_ = ghost_loc_ } : Syntax.pattern) + +let const_uint i = + (Pexpr_constant { c = Const_uint i; loc_ = ghost_loc_ } : Syntax.expr) + +let const_int i = + (Pexpr_constant { c = Const_int i; loc_ = ghost_loc_ } : Syntax.expr) + +let const_bool b = + (Pexpr_constant { c = Const_bool b; loc_ = ghost_loc_ } : Syntax.expr) + +let const_string s = + (Pexpr_constant + { c = Const_string { string_val = s; string_repr = s }; loc_ = ghost_loc_ } + : Syntax.expr) + +let method_ type_ method_name = + (Pexpr_method + { + type_name = type_name type_; + method_name = label method_name; + loc_ = ghost_loc_; + } + : Syntax.expr) + +let apply func args attr = + (let args = + Lst.map args (fun arg -> + ({ arg_value = arg; arg_kind = Positional } : Syntax.argument)) + in + Pexpr_apply { func; args; attr; loc_ = ghost_loc_ } + : Syntax.expr) + +let annotation ?(loc_ = ghost_loc_) expr ty = + (Pexpr_constraint { expr; ty; loc_ } : Syntax.expr) + +let apply_trait_method ~assertions ~typ ~loc ~msg trait method_name args attr = + (let assertion : Syntax.static_assertion = + { + assert_type = typ; + assert_trait = trait; + assert_loc = loc; + assert_msg = msg; + } + in + Vec.push assertions assertion; + apply (method_ trait method_name) args attr + : Syntax.expr) + +let assign var expr = + Syntax.Pexpr_assign + { + var = { var_name = Basic_longident.Lident var; loc_ = ghost_loc_ }; + expr; + loc_ = ghost_loc_; + augmented_by = None; + } + +let dot_apply self name args = + (let args = + Lst.map args (fun arg -> + ({ arg_value = arg; arg_kind = Positional } : Syntax.argument)) + in + let method_name : Syntax.label = { label_name = name; loc_ = ghost_loc_ } in + Pexpr_dot_apply + { + self; + method_name; + args; + attr = No_attr; + loc_ = ghost_loc_; + return_self = false; + } + : Syntax.expr) + +let dotdot_apply self name args = + (let args = + Lst.map args (fun arg -> + ({ arg_value = arg; arg_kind = Positional } : Syntax.argument)) + in + let method_name : Syntax.label = { label_name = name; loc_ = ghost_loc_ } in + Pexpr_dot_apply + { + self; + method_name; + args; + attr = No_attr; + loc_ = ghost_loc_; + return_self = true; + } + : Syntax.expr) + +let constr ?(extra_info = Syntax.No_extra_info) name args = + (let constr : Syntax.expr = + Pexpr_constr + { + constr = + { + extra_info; + constr_name = { name; loc_ = ghost_loc_ }; + loc_ = ghost_loc_; + }; + loc_ = ghost_loc_; + } + in + match args with [] -> constr | args -> apply constr args No_attr + : Syntax.expr) + +let apply_label func args = + (let args : Syntax.argument list = + Lst.map args (fun (arg : Syntax.expr * Syntax.label option) -> + (let kind : Syntax.argument_kind = + match snd arg with + | None -> Syntax.Positional + | Some label -> Labelled label + in + { arg_value = fst arg; arg_kind = kind } + : Syntax.argument)) + in + Pexpr_apply { func; args; attr = No_attr; loc_ = ghost_loc_ } + : Syntax.expr) + +let constr_label name args = + (let constr : Syntax.expr = + Pexpr_constr + { + constr = + { + extra_info = No_extra_info; + constr_name = { name; loc_ = ghost_loc_ }; + loc_ = ghost_loc_; + }; + loc_ = ghost_loc_; + } + in + match args with [] -> constr | args -> apply_label constr args + : Syntax.expr) + +let record fields = + (Pexpr_record + { + type_name = None; + trailing = Trailing_none; + loc_ = ghost_loc_; + fields = + Lst.map fields (fun (label_name, value) -> + (Field_def + { + label = label label_name; + expr = value; + is_pun = false; + loc_ = ghost_loc_; + } + : Syntax.field_def)); + } + : Syntax.expr) + +let field record label_name = + (Pexpr_field + { + record; + accessor = Label { label_name; loc_ = ghost_loc_ }; + loc_ = ghost_loc_; + } + : Syntax.expr) + +let newtype_field nt = + (Pexpr_field { record = nt; accessor = Newtype; loc_ = ghost_loc_ } + : Syntax.expr) + +let tuple exprs = (Pexpr_tuple { exprs; loc_ = ghost_loc_ } : Syntax.expr) +let unit : Syntax.expr = Pexpr_unit { loc_ = ghost_loc_; faked = false } + +let infix_op op lhs rhs = + (Pexpr_infix + { + op = { var_name = Lident op; loc_ = ghost_loc_ }; + lhs; + rhs; + loc_ = ghost_loc_; + } + : Syntax.expr) + +let array exprs = (Pexpr_array { exprs; loc_ = ghost_loc_ } : Syntax.expr) + +let map_string_expr entries = + (let elems = + Lst.map entries (fun (k, v) -> + (Map_expr_elem + { + key = Const_string { string_val = k; string_repr = k }; + expr = v; + key_loc_ = ghost_loc_; + loc_ = ghost_loc_; + } + : Syntax.map_expr_elem)) + in + Pexpr_map { elems; loc_ = ghost_loc_ } + : Syntax.expr) + +let pany : Syntax.pattern = Ppat_any { loc_ = ghost_loc_ } + +let pvar name = + (Ppat_var { binder_name = name; loc_ = ghost_loc_ } : Syntax.pattern) + +let array_pat p = (Pattern p : Syntax.array_pattern) +let ptuple pats = (Ppat_tuple { pats; loc_ = ghost_loc_ } : Syntax.pattern) + +let pconstr constr args = + (let args = + match args with + | [] -> None + | args -> + Some + (Lst.map args (fun (label_opt, pat) -> + (match label_opt with + | None -> Constr_pat_arg { pat; kind = Positional } + | Some label_name -> + Constr_pat_arg + { + pat; + kind = Labelled { label_name; loc_ = ghost_loc_ }; + } + : Syntax.constr_pat_arg))) + in + Ppat_constr + { + constr = + { + extra_info = No_extra_info; + constr_name = { name = constr; loc_ = ghost_loc_ }; + loc_ = ghost_loc_; + }; + args; + is_open = false; + loc_ = ghost_loc_; + } + : Syntax.pattern) + +let pconstant c = (Ppat_constant { c; loc_ = ghost_loc_ } : Syntax.pattern) + +let por pats = + (match pats with + | [] -> assert false + | pat :: [] -> pat + | pat :: pats -> + Lst.fold_left pats pat (fun acc -> + fun pat -> Ppat_or { pat1 = acc; pat2 = pat; loc_ = ghost_loc_ }) + : Syntax.pattern) + +let var name = + (Pexpr_ident + { id = { var_name = Lident name; loc_ = ghost_loc_ }; loc_ = ghost_loc_ } + : Syntax.expr) + +let let_ pattern expr body = + (Pexpr_let { pattern; expr; body; loc_ = ghost_loc_ } : Syntax.expr) + +let letmut name ty expr body = + (Pexpr_letmut + { + binder = { binder_name = name; loc_ = ghost_loc_ }; + ty; + expr; + body; + loc_ = ghost_loc_; + } + : Syntax.expr) + +let sequence expr1 expr2 = + (match expr2 with + | Syntax.Pexpr_sequence { exprs; last_expr; _ } -> + Pexpr_sequence { exprs = expr1 :: exprs; last_expr; loc_ = ghost_loc_ } + | _ -> + Pexpr_sequence + { exprs = [ expr1 ]; last_expr = expr2; loc_ = ghost_loc_ } + : Syntax.expr) + +let rec seq exprs = + (match exprs with + | [] -> unit + | expr :: [] -> expr + | expr :: exprs -> sequence expr (seq exprs) + : Syntax.expr) + +let if_ cond ifso ifnot = + (Pexpr_if { cond; ifso; ifnot = Some ifnot; loc_ = ghost_loc_ } : Syntax.expr) + +let match_ expr (cases : (Syntax.pattern * Syntax.expr) list) = + (let cases = + Lst.map cases (fun (pattern, expr) -> + ({ pattern; guard = None; body = expr } : Syntax.case)) + in + Pexpr_match { expr; cases; match_loc_ = ghost_loc_; loc_ = ghost_loc_ } + : Syntax.expr) + +let rest_raise_json_decode_error_ (path : Syntax.expr) (msg : Syntax.expr) = + (let err_value = + let t = tuple [ path; msg ] in + constr "JsonDecodeError" [ t ] ~extra_info:(Syntax.Package "json") + in + (pvar "_", Pexpr_raise { err_value; loc_ = ghost_loc_ }) + : Syntax.pattern * Syntax.expr) + +let raise_json_decode_error (path : Syntax.expr) (msg : Syntax.expr) = + (let _, raise_expr = rest_raise_json_decode_error_ path msg in + raise_expr + : Syntax.expr) + +let json_path_add_key path field_name = + (apply + (method_ (Ldot { pkg = "json"; id = "JsonPath" }) "add_key") + [ path; const_string field_name ] + No_attr + : Syntax.expr) + +let json_path_add_key_expr path expr = + (apply + (method_ (Ldot { pkg = "json"; id = "JsonPath" }) "add_key") + [ path; expr ] No_attr + : Syntax.expr) + +let json_path_add_index path index = + (apply + (method_ (Ldot { pkg = "json"; id = "JsonPath" }) "add_index") + [ path; const_int (string_of_int index) ] + No_attr + : Syntax.expr) + +let ident long_ident = + (Pexpr_ident + { id = { var_name = long_ident; loc_ = ghost_loc_ }; loc_ = ghost_loc_ } + : Syntax.expr) + +let map (elems : Syntax.map_expr_elem list) = + (Pexpr_map { elems; loc_ = ghost_loc_ } : Syntax.expr) + +let map_elem key expr = + (Map_expr_elem { key; expr; key_loc_ = ghost_loc_; loc_ = ghost_loc_ } + : Syntax.map_expr_elem) + +let panic : Syntax.expr = apply (var "panic") [] No_attr diff --git a/src/ast_derive.ml b/src/ast_derive.ml index 9520d81..4896ece 100644 --- a/src/ast_derive.ml +++ b/src/ast_derive.ml @@ -19,298 +19,25 @@ module Type_path = Basic_type_path module Syntax = Parsing_syntax module Operators = Parsing_operators -let ghost_loc_ = Rloc.no_location - let fresh_name name = Stdlib.String.concat "" [ "*"; name; "_"; Int.to_string (Basic_uuid.next ()) ] -module S = struct - let typ (ty_name : string) (tys : Syntax.typ list) : Syntax.typ = - Ptype_name - { - constr_id = { lid = Lident ty_name; loc_ = ghost_loc_ }; - tys; - loc_ = ghost_loc_; - } - - let typ_any : Syntax.typ = Ptype_any { loc_ = ghost_loc_ } - - let is_option (field : Syntax.field_decl) = - match field.field_ty with - | Ptype_option _ - | Ptype_name { constr_id = { lid = Lident "Option"; _ }; _ } -> - true - | _ -> false - - let label label_name : Syntax.label = { label_name; loc_ = ghost_loc_ } - let type_name name : Syntax.type_name = { name; loc_ = ghost_loc_ } - let hole : Syntax.expr = Pexpr_hole { loc_ = ghost_loc_; kind = Synthesized } - - let const_uint_pat i : Syntax.pattern = - Ppat_constant { c = Const_uint i; loc_ = ghost_loc_ } - - let const_uint i : Syntax.expr = - Pexpr_constant { c = Const_uint i; loc_ = ghost_loc_ } - - let const_int i : Syntax.expr = - Pexpr_constant { c = Const_int i; loc_ = ghost_loc_ } - - let const_bool b : Syntax.expr = - Pexpr_constant { c = Const_bool b; loc_ = ghost_loc_ } - - let const_string s : Syntax.expr = - Pexpr_constant - { - c = Const_string { string_val = s; string_repr = s }; - loc_ = ghost_loc_; - } - - let method_ type_ method_name : Syntax.expr = - Pexpr_method - { - type_name = type_name type_; - method_name = label method_name; - loc_ = ghost_loc_; - } - - let apply func args attr : Syntax.expr = - let args = - Lst.map args (fun arg : Syntax.argument -> - { arg_value = arg; arg_kind = Positional }) - in - Pexpr_apply { func; args; attr; loc_ = ghost_loc_ } - - let annotation expr ty : Syntax.expr = - Pexpr_constraint { expr; ty; loc_ = ghost_loc_ } - - let apply_trait_method ~assertions ~typ ~loc ~msg trait method_name args attr - : Syntax.expr = - let assertion : Syntax.static_assertion = - { - assert_type = typ; - assert_trait = trait; - assert_loc = loc; - assert_msg = msg; - } - in - Vec.push assertions assertion; - apply (method_ trait method_name) args attr - - let dot_apply self name args : Syntax.expr = - let args = - Lst.map args (fun arg : Syntax.argument -> - { arg_value = arg; arg_kind = Positional }) - in - let method_name : Syntax.label = { label_name = name; loc_ = ghost_loc_ } in - Pexpr_dot_apply - { - self; - method_name; - args; - attr = No_attr; - loc_ = ghost_loc_; - return_self = false; - } - - let dotdot_apply self name args : Syntax.expr = - let args = - Lst.map args (fun arg : Syntax.argument -> - { arg_value = arg; arg_kind = Positional }) - in - let method_name : Syntax.label = { label_name = name; loc_ = ghost_loc_ } in - Pexpr_dot_apply - { - self; - method_name; - args; - attr = No_attr; - loc_ = ghost_loc_; - return_self = true; - } - - let constr ?(extra_info = Syntax.No_extra_info) name args : Syntax.expr = - let constr : Syntax.expr = - Pexpr_constr - { - constr = - { - extra_info; - constr_name = { name; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - }; - loc_ = ghost_loc_; - } - in - match args with [] -> constr | args -> apply constr args No_attr - - let apply_label func args : Syntax.expr = - let args : Syntax.argument list = - Lst.map args - (fun (arg : Syntax.expr * Syntax.label option) : Syntax.argument -> - let kind : Syntax.argument_kind = - match snd arg with - | None -> Syntax.Positional - | Some label -> Labelled label - in - { arg_value = fst arg; arg_kind = kind }) - in - Pexpr_apply { func; args; attr = No_attr; loc_ = ghost_loc_ } - - let constr_label name args : Syntax.expr = - let constr : Syntax.expr = - Pexpr_constr - { - constr = - { - extra_info = No_extra_info; - constr_name = { name; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - }; - loc_ = ghost_loc_; - } - in - match args with [] -> constr | args -> apply_label constr args - - let record fields : Syntax.expr = - Pexpr_record - { - type_name = None; - trailing = Trailing_none; - loc_ = ghost_loc_; - fields = - Lst.map fields (fun (label_name, value) : Syntax.field_def -> - Field_def - { - label = label label_name; - expr = value; - is_pun = false; - loc_ = ghost_loc_; - }); - } - - let field record label_name : Syntax.expr = - Pexpr_field - { - record; - accessor = Label { label_name; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - - let newtype_field nt : Syntax.expr = - Pexpr_field { record = nt; accessor = Newtype; loc_ = ghost_loc_ } - - let tuple exprs : Syntax.expr = Pexpr_tuple { exprs; loc_ = ghost_loc_ } - let unit : Syntax.expr = Pexpr_unit { loc_ = ghost_loc_; faked = false } - - let infix_op op lhs rhs : Syntax.expr = - Pexpr_infix - { - op = { var_name = Lident op; loc_ = ghost_loc_ }; - lhs; - rhs; - loc_ = ghost_loc_; - } - - let array exprs : Syntax.expr = Pexpr_array { exprs; loc_ = ghost_loc_ } - - let map_string_expr entries : Syntax.expr = - let elems = - Lst.map entries (fun (k, v) : Syntax.map_expr_elem -> - Map_expr_elem - { - key = Const_string { string_val = k; string_repr = k }; - expr = v; - key_loc_ = ghost_loc_; - loc_ = ghost_loc_; - }) - in - Pexpr_map { elems; loc_ = ghost_loc_ } - - let pany : Syntax.pattern = Ppat_any { loc_ = ghost_loc_ } - - let pvar name : Syntax.pattern = - Ppat_var { binder_name = name; loc_ = ghost_loc_ } - - let ptuple pats : Syntax.pattern = Ppat_tuple { pats; loc_ = ghost_loc_ } - - let pconstr constr args : Syntax.pattern = - let args = - match args with - | [] -> None - | args -> - Lst.map args (fun (label_opt, pat) : Syntax.constr_pat_arg -> - match label_opt with - | None -> Constr_pat_arg { pat; kind = Positional } - | Some label_name -> - Constr_pat_arg - { pat; kind = Labelled { label_name; loc_ = ghost_loc_ } }) - |> Option.some - in - Ppat_constr - { - constr = - { - extra_info = No_extra_info; - constr_name = { name = constr; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - }; - args; - is_open = false; - loc_ = ghost_loc_; - } - - let pconstant c : Syntax.pattern = Ppat_constant { c; loc_ = ghost_loc_ } - let pmap elems : Syntax.pattern = Ppat_map { elems; loc_ = ghost_loc_ } - - let por pats : Syntax.pattern = - match pats with - | [] -> assert false - | pat :: [] -> pat - | pat :: pats -> - Lst.fold_left pats pat (fun acc pat -> - Ppat_or { pat1 = acc; pat2 = pat; loc_ = ghost_loc_ }) - - let map_pat_elem_lst entries : Syntax.map_pat_elem list = - Lst.map entries (fun (k, v) : Syntax.map_pat_elem -> - Map_pat_elem - { - key = Const_string { string_val = k; string_repr = k }; - pat = v; - match_absent = false; - key_loc_ = ghost_loc_; - loc_ = ghost_loc_; - }) - - let var name : Syntax.expr = - Pexpr_ident - { id = { var_name = Lident name; loc_ = ghost_loc_ }; loc_ = ghost_loc_ } +module S = Ast_builder - let let_ pattern expr body : Syntax.expr = - Pexpr_let { pattern; expr; body; loc_ = ghost_loc_ } - - let sequence expr1 expr2 : Syntax.expr = - Pexpr_sequence { expr1; expr2; loc_ = ghost_loc_ } - - let rec seq exprs : Syntax.expr = - match exprs with - | [] -> unit - | expr :: [] -> expr - | expr :: exprs -> sequence expr (seq exprs) - - let match_ expr cases : Syntax.expr = - Pexpr_match { expr; cases; match_loc_ = ghost_loc_; loc_ = ghost_loc_ } - - let rest_raise_json_decode_error_ (path : Syntax.expr) (msg : Syntax.expr) : - Syntax.pattern * Syntax.expr = - let err_value = - let t = tuple [ path; msg ] in - constr "JsonDecodeError" [ t ] ~extra_info:(Syntax.Package "json") - in - (pvar "_", Pexpr_raise { err_value; loc_ = ghost_loc_ }) - - let map_insert_json key json_val : Syntax.expr = - dot_apply (var "$map") "set" [ const_string key; json_val ] -end +let rec type_has_hole (typ : Syntax.typ) = + match typ with + | Ptype_any _ -> true + | Ptype_arrow { ty_arg; ty_res; ty_err; is_async = _ } -> ( + Lst.exists ty_arg type_has_hole + || type_has_hole ty_res + || + match ty_err with + | Error_typ { ty; _ } -> type_has_hole ty + | Default_error_typ _ | No_error_typ -> false) + | Ptype_tuple { tys } -> Lst.exists tys type_has_hole + | Ptype_name { tys; _ } -> Lst.exists tys type_has_hole + | Ptype_option { ty; _ } -> type_has_hole ty + | Ptype_object _ -> false type deriver = Syntax.deriving_directive -> @@ -324,15 +51,18 @@ let derive_default (trait : Syntax.type_name) (decl : Syntax.type_decl) ~params:(_params : string list) ~(assertions : Syntax.static_assertion Vec.t) ~(diagnostics : Local_diagnostics.t) = - let rec default_of_typ ~msg (typ : Syntax.typ) : Syntax.expr = - match typ with - | Ptype_tuple { tys; _ } -> S.tuple (Lst.map tys (default_of_typ ~msg)) - | typ -> - S.annotation - (S.apply_trait_method ~assertions ~typ ~msg - ~loc:(Syntax.loc_of_type_expression typ) - trait.name "default" [] No_attr) - typ + let rec default_of_typ ~msg (typ : Syntax.typ) = + (if type_has_hole typ then S.hole + else + match typ with + | Ptype_tuple { tys; _ } -> S.tuple (Lst.map tys (default_of_typ ~msg)) + | typ -> + S.annotation + (S.apply_trait_method ~assertions ~typ ~msg + ~loc:(Syntax.loc_of_type_expression typ) + trait.name "default" [] No_attr) + typ + : Syntax.expr) in match decl.components with | Ptd_abstract -> @@ -340,11 +70,19 @@ let derive_default (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> S.constr decl.tycon [ default_of_typ - ~msg:("derive(Default) for newtype " ^ decl.tycon : Stdlib.String.t) + ~msg: + (("derive(Default) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) typ; ] | Ptd_error No_payload -> S.constr decl.tycon [] @@ -353,12 +91,15 @@ let derive_default (trait : Syntax.type_name) (decl : Syntax.type_decl) [ default_of_typ ~msg: - ("derive(Default) for error type " ^ decl.tycon : Stdlib.String.t) + (("derive(Default) for error type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) typ; ] | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> ( match - Lst.filter constrs (fun constr -> Option.is_none constr.constr_args) + Lst.filter constrs (fun constr -> + match constr.constr_args with None -> true | _ -> false) with | [] -> Local_diagnostics.add_error diagnostics @@ -370,32 +111,36 @@ let derive_default (trait : Syntax.type_name) (decl : Syntax.type_decl) | { constr_name = constr1; _ } :: { constr_name = constr2; _ } :: rest -> let candidate_str = match rest with - | [] -> (constr1.name ^ " and " ^ constr2.name : Stdlib.String.t) + | [] -> + (constr1.name ^ " and " ^ constr2.name + : Stdlib.String.t) + [@merlin.hide] | _ -> Stdlib.String.concat "" - [ constr1.name; ", "; constr2.name; ", ..." ] + [ constr1.name; ", "; constr2.name; ", ..." ] [@merlin.hide] in Local_diagnostics.add_error diagnostics (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason: - (candidate_str ^ " are both candidates as default constructor" + ((candidate_str ^ " are both candidates as default constructor" : Stdlib.String.t) + [@merlin.hide]) ~loc:trait.loc_); S.hole) | Ptd_record fields -> - Lst.map fields (fun field -> - ( field.field_name.label, - default_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(Default) for field "; - field.field_name.label; - " of type "; - decl.tycon; - ]) - field.field_ty )) - |> S.record + S.record + (Lst.map fields (fun field -> + ( field.field_name.label, + default_of_typ + ~msg: + (Stdlib.String.concat "" + [ + "derive(Default) for field "; + field.field_name.label; + " of type "; + decl.tycon; + ] [@merlin.hide]) + field.field_ty ))) | Ptd_alias _ -> S.hole let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) @@ -410,29 +155,36 @@ let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) in let rec eq_of_typ ~msg (typ : Syntax.typ) (lhs : Syntax.expr) (rhs : Syntax.expr) = - match typ with - | Ptype_tuple { tys; _ } -> - let names1 = - Lst.mapi tys (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) - in - let names2 = - Lst.mapi tys (fun i _ -> - fresh_name ("y" ^ Int.to_string i : Stdlib.String.t)) - in - S.let_ - (S.ptuple (Lst.map names1 S.pvar)) - lhs - (S.let_ - (S.ptuple (Lst.map names2 S.pvar)) - rhs - (all_eq tys names1 names2 ~eq_for_elem:(fun ty lhs rhs -> - eq_of_typ ~msg ty (S.var lhs) (S.var rhs)))) - | typ -> - S.apply_trait_method ~assertions ~typ - ~loc:(Syntax.loc_of_type_expression typ) - ~msg trait.name Operators.op_equal_info.method_name [ lhs; rhs ] - No_attr + if type_has_hole typ then S.const_bool true + else + match typ with + | Ptype_tuple { tys; _ } -> + let names1 = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i : Stdlib.String.t) [@merlin.hide])) + in + let names2 = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("y" ^ Int.to_string i : Stdlib.String.t) [@merlin.hide])) + in + S.let_ + (S.ptuple (Lst.map names1 S.pvar)) + lhs + (S.let_ + (S.ptuple (Lst.map names2 S.pvar)) + rhs + (all_eq tys names1 names2 ~eq_for_elem:(fun ty -> + fun lhs -> + fun rhs -> eq_of_typ ~msg ty (S.var lhs) (S.var rhs)))) + | typ -> + S.apply_trait_method ~assertions ~typ + ~loc:(Syntax.loc_of_type_expression typ) + ~msg trait.name Operators.op_equal_info.method_name [ lhs; rhs ] + No_attr in match[@warning "-fragile-match"] params with | [ lhs; rhs ] -> ( @@ -444,18 +196,28 @@ let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> let lhs = S.newtype_field lhs in let rhs = S.newtype_field rhs in eq_of_typ - ~msg:("derive(Eq) for newtype " ^ decl.tycon : Stdlib.String.t) + ~msg: + (("derive(Eq) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) typ lhs rhs | Ptd_error No_payload -> S.const_bool true | Ptd_error (Single_payload typ) -> let x = fresh_name "x" in let y = fresh_name "y" in let msg = - ("derive(Eq) for error type " ^ decl.tycon : Stdlib.String.t) + (("derive(Eq) for error type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in S.let_ (S.pconstr decl.tycon [ (None, S.pvar x) ]) @@ -465,7 +227,11 @@ let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) rhs (eq_of_typ ~msg typ (S.var x) (S.var y))) | Ptd_variant constrs | Ptd_error (Enum_payload constrs) -> - let fallback_cases = [ (S.pany, S.const_bool false) ] in + let fallback_cases = + match constrs with + | _ :: _ :: _ -> [ (S.pany, S.const_bool false) ] + | _ -> [] + in let cases = Lst.map_append constrs fallback_cases (fun { constr_name; constr_args; _ } -> @@ -483,39 +249,50 @@ let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) | None -> make_result [] [] (S.const_bool true) | Some args -> let msg = - Stdlib.String.concat "" - [ - "derive(Eq) for constructor "; - constr_name; - " of type "; - decl.tycon; - ] + (Stdlib.String.concat "" + [ + "derive(Eq) for constructor "; + constr_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) in let names1 = - Lst.mapi args (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) + Lst.mapi args (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) in let names2 = - Lst.mapi args (fun i _ -> - fresh_name ("y" ^ Int.to_string i : Stdlib.String.t)) + Lst.mapi args (fun i -> + fun _ -> + fresh_name + (("y" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) in let action = - all_eq args names1 names2 - ~eq_for_elem:(fun cparam lhs rhs -> - eq_of_typ ~msg cparam.cparam_typ (S.var lhs) - (S.var rhs)) + all_eq args names1 names2 ~eq_for_elem:(fun cparam -> + fun lhs -> + fun rhs -> + eq_of_typ ~msg cparam.cparam_typ (S.var lhs) + (S.var rhs)) in let pat_args1 = - Lst.map2 args names1 (fun cparam name -> - match cparam.cparam_label with - | None -> (None, S.pvar name) - | Some label -> (Some label.label_name, S.pvar name)) + Lst.map2 args names1 (fun cparam -> + fun name -> + match cparam.cparam_label with + | None -> (None, S.pvar name) + | Some label -> (Some label.label_name, S.pvar name)) in let pat_args2 = - Lst.map2 args names2 (fun cparam name -> - match cparam.cparam_label with - | None -> (None, S.pvar name) - | Some label -> (Some label.label_name, S.pvar name)) + Lst.map2 args names2 (fun cparam -> + fun name -> + match cparam.cparam_label with + | None -> (None, S.pvar name) + | Some label -> (Some label.label_name, S.pvar name)) in make_result pat_args1 pat_args2 action) in @@ -532,11 +309,11 @@ let derive_eq (trait : Syntax.type_name) (decl : Syntax.type_decl) field_name; " of type "; decl.tycon; - ]) + ] [@merlin.hide]) field.field_ty (S.field lhs field_name) (S.field rhs field_name) in - Lst.fold_left fields (eq_of_field field0) (fun acc field -> - S.infix_op "&&" acc (eq_of_field field)) + Lst.fold_left fields (eq_of_field field0) (fun acc -> + fun field -> S.infix_op "&&" acc (eq_of_field field)) | Ptd_alias _ -> S.hole) | _ -> assert false @@ -558,29 +335,36 @@ let derive_compare (trait : Syntax.type_name) (decl : Syntax.type_decl) in let rec compare_of_typ ~msg (typ : Syntax.typ) (lhs : Syntax.expr) (rhs : Syntax.expr) = - match typ with - | Ptype_tuple { tys; _ } -> - let names1 = - Lst.mapi tys (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) - in - let names2 = - Lst.mapi tys (fun i _ -> - fresh_name ("y" ^ Int.to_string i : Stdlib.String.t)) - in - S.let_ - (S.ptuple (Lst.map names1 S.pvar)) - lhs - (S.let_ - (S.ptuple (Lst.map names2 S.pvar)) - rhs - (compare_all tys names1 names2 - ~cmp_for_elem:(fun typ name1 name2 -> - compare_of_typ ~msg typ (S.var name1) (S.var name2)))) - | typ -> - S.apply_trait_method ~assertions ~typ - ~loc:(Syntax.loc_of_type_expression typ) - ~msg trait.name "compare" [ lhs; rhs ] No_attr + if type_has_hole typ then S.const_int "0" + else + match typ with + | Ptype_tuple { tys; _ } -> + let names1 = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i : Stdlib.String.t) [@merlin.hide])) + in + let names2 = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("y" ^ Int.to_string i : Stdlib.String.t) [@merlin.hide])) + in + S.let_ + (S.ptuple (Lst.map names1 S.pvar)) + lhs + (S.let_ + (S.ptuple (Lst.map names2 S.pvar)) + rhs + (compare_all tys names1 names2 ~cmp_for_elem:(fun typ -> + fun name1 -> + fun name2 -> + compare_of_typ ~msg typ (S.var name1) (S.var name2)))) + | typ -> + S.apply_trait_method ~assertions ~typ + ~loc:(Syntax.loc_of_type_expression typ) + ~msg trait.name "compare" [ lhs; rhs ] No_attr in match[@warning "-fragile-match"] params with | [ lhs; rhs ] -> ( @@ -597,7 +381,9 @@ let derive_compare (trait : Syntax.type_name) (decl : Syntax.type_decl) assert_trait = Lident "Eq"; assert_loc = trait.loc_; assert_msg = - ("derive(Compare) of type " ^ decl.tycon : Stdlib.String.t); + ("derive(Compare) of type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]; }; match decl.components with | Ptd_abstract -> @@ -605,18 +391,28 @@ let derive_compare (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> let lhs = S.newtype_field lhs in let rhs = S.newtype_field rhs in compare_of_typ - ~msg:("derive(Compare) for newtype " ^ decl.tycon : Stdlib.String.t) + ~msg: + (("derive(Compare) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) typ lhs rhs | Ptd_error No_payload -> S.const_int "0" | Ptd_error (Single_payload typ) -> let x = fresh_name "x" in let y = fresh_name "y" in let msg = - ("derive(Compare) for error type " ^ decl.tycon : Stdlib.String.t) + (("derive(Compare) for error type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in S.let_ (S.pconstr decl.tycon [ (None, S.pvar x) ]) @@ -628,63 +424,75 @@ let derive_compare (trait : Syntax.type_name) (decl : Syntax.type_decl) | Ptd_variant constrs | Ptd_error (Enum_payload constrs) -> let constr_count = List.length constrs in let cases = - Lst.mapi constrs - (fun constr_index { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - let constr_args = Option.value constr_args ~default:[] in - let arg_names = - Lst.mapi constr_args (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) - in - let arg_pats = - Lst.map2 arg_names constr_args - (fun name { cparam_label; _ } -> - match cparam_label with - | None -> (None, S.pvar name) - | Some label -> (Some label.label_name, S.pvar name)) - in - let eq_case = - let arg_names' = - Lst.mapi constr_args (fun i _ -> - fresh_name ("y" ^ Int.to_string i : Stdlib.String.t)) - in - let arg_pats' = - Lst.map2 arg_names' constr_args - (fun name { cparam_label; _ } -> + Lst.mapi constrs (fun constr_index -> + fun { constr_name; constr_args; _ } -> + let constr_name = constr_name.name in + let constr_args = Option.value constr_args ~default:[] in + let arg_names = + Lst.mapi constr_args (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) + in + let arg_pats = + Lst.map2 arg_names constr_args (fun name -> + fun { cparam_label; _ } -> match cparam_label with | None -> (None, S.pvar name) | Some label -> (Some label.label_name, S.pvar name)) - in - let msg = - Stdlib.String.concat "" - [ - "derive(Compare) for constructor "; - constr_name; - " of type "; - decl.tycon; - ] - in - ( S.pconstr constr_name arg_pats', - compare_all constr_args arg_names arg_names' - ~cmp_for_elem:(fun { cparam_typ; _ } name1 name2 -> - compare_of_typ ~msg cparam_typ (S.var name1) - (S.var name2)) ) - in - let lt_case = (S.pany, S.const_int "-1") in - let cases = - if constr_index = 0 then [ eq_case; lt_case ] - else - let pat = - Lst.map (Lst.take constr_index constrs) - (fun { constr_name; _ } -> - S.pconstr constr_name.name [ (None, S.pany) ]) - |> S.por - in - let gt_case = (pat, S.const_int "1") in - if constr_index = constr_count - 1 then [ gt_case; eq_case ] - else [ gt_case; eq_case; lt_case ] - in - (S.pconstr constr_name arg_pats, S.match_ rhs cases)) + in + let eq_case = + let arg_names' = + Lst.mapi constr_args (fun i -> + fun _ -> + fresh_name + (("y" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) + in + let arg_pats' = + Lst.map2 arg_names' constr_args (fun name -> + fun { cparam_label; _ } -> + match cparam_label with + | None -> (None, S.pvar name) + | Some label -> (Some label.label_name, S.pvar name)) + in + let msg = + (Stdlib.String.concat "" + [ + "derive(Compare) for constructor "; + constr_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + in + ( S.pconstr constr_name arg_pats', + compare_all constr_args arg_names arg_names' + ~cmp_for_elem:(fun { cparam_typ; _ } -> + fun name1 -> + fun name2 -> + compare_of_typ ~msg cparam_typ (S.var name1) + (S.var name2)) ) + in + let lt_case = (S.pany, S.const_int "-1") in + let cases = + if constr_count = 1 then [ eq_case ] + else if constr_index = 0 then [ eq_case; lt_case ] + else + let pat = + S.por + (Lst.map (Lst.take constrs constr_index) + (fun { constr_name; _ } -> + S.pconstr constr_name.name [ (None, S.pany) ])) + in + let gt_case = (pat, S.const_int "1") in + if constr_index = constr_count - 1 then + [ gt_case; eq_case ] + else [ gt_case; eq_case; lt_case ] + in + (S.pconstr constr_name arg_pats, S.match_ rhs cases)) in S.match_ lhs cases | Ptd_record fields -> @@ -704,7 +512,7 @@ let derive_compare (trait : Syntax.type_name) (decl : Syntax.type_decl) field_name; " of type "; decl.tycon; - ]) + ] [@merlin.hide]) field.field_ty lhs rhs in compare_all fields lhs_fields rhs_fields ~cmp_for_elem:cmp_of_field @@ -726,34 +534,44 @@ let derive_show (trait : Syntax.type_name) (decl : Syntax.type_decl) | [], [] -> self | ty :: [], obj :: [] -> write_elem ty obj self | ty :: tys, obj :: objs -> - self |> write_elem ty obj |> write_string ", " - |> write_list tys objs ~write_elem + write_list tys objs ~write_elem + (write_string ", " (write_elem ty obj self)) | _ -> assert false in let rec write_object ~msg (typ : Syntax.typ) obj self = - match typ with - | Ptype_arrow _ -> self |> write_string "" - | Ptype_tuple { tys; _ } -> - let names = - Lst.mapi tys (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) - in - self |> write_string "(" - |> write_list tys names ~write_elem:(fun typ name self -> - self |> write_object ~msg typ (S.var name)) - |> write_string ")" - |> S.let_ (S.ptuple (Lst.map names S.pvar)) obj - | _ -> - let assertion : Syntax.static_assertion = - { - assert_type = typ; - assert_trait = trait.name; - assert_loc = Syntax.loc_of_type_expression typ; - assert_msg = msg; - } - in - Vec.push assertions assertion; - S.dotdot_apply self "write_object" [ obj ] + if type_has_hole typ then self + else + match typ with + | Ptype_arrow _ -> write_string "" self + | Ptype_tuple { tys; _ } -> + let names = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) + in + S.let_ + (S.ptuple (Lst.map names S.pvar)) + obj + (write_string ")" + (write_list tys names + ~write_elem:(fun typ -> + fun name -> + fun self -> write_object ~msg typ (S.var name) self) + (write_string "(" self))) + | _ -> + let assertion : Syntax.static_assertion = + { + assert_type = typ; + assert_trait = trait.name; + assert_loc = Syntax.loc_of_type_expression typ; + assert_msg = msg; + } + in + Vec.push assertions assertion; + S.dotdot_apply self "write_object" [ obj ] in match decl.components with | Ptd_abstract -> @@ -761,88 +579,98 @@ let derive_show (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> let msg = - ("derive(Show) for newtype " ^ decl.tycon : Stdlib.String.t) + (("derive(Show) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in - logger - |> write_string (decl.tycon ^ "(") - |> write_object ~msg typ (S.newtype_field obj) - |> write_string ~is_last:true ")" - | Ptd_error No_payload -> logger |> write_string ~is_last:true decl.tycon + write_string ~is_last:true ")" + (write_object ~msg typ (S.newtype_field obj) + (write_string (decl.tycon ^ "(") logger)) + | Ptd_error No_payload -> write_string ~is_last:true decl.tycon logger | Ptd_error (Single_payload typ) -> let var = fresh_name "err_payload" in let msg = - ("derive(Show) for error type " ^ decl.tycon : Stdlib.String.t) + (("derive(Show) for error type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in S.let_ (S.pconstr decl.tycon [ (None, S.pvar var) ]) obj - (logger - |> write_string (decl.tycon ^ "(") - |> write_object ~msg typ (S.var var) - |> write_string ~is_last:true ")") + (write_string ~is_last:true ")" + (write_object ~msg typ (S.var var) + (write_string (decl.tycon ^ "(") logger))) | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> - Lst.map constrs (fun { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - match constr_args with - | None -> - ( S.pconstr constr_name [], - logger |> write_string ~is_last:true constr_name ) - | Some args -> - let vars = Lst.map args (fun _ -> fresh_name "arg") in - let action = - let msg = - Stdlib.String.concat "" - [ - "derive(Show) for constructor "; - constr_name; - " of type "; - decl.tycon; - ] - in - logger - |> write_string (constr_name ^ "(") - |> write_list args vars - ~write_elem:(fun constr_param var self -> - match constr_param.cparam_label with - | None -> - self - |> write_object ~msg constr_param.cparam_typ - (S.var var) - | Some label -> - self - |> write_string (label.label_name ^ "=") - |> write_object ~msg constr_param.cparam_typ - (S.var var)) - |> write_string ~is_last:true ")" - in - ( S.pconstr constr_name - (Lst.map2 args vars (fun cparam var -> - let label = - Option.map - (fun (l : Syntax.label) -> l.label_name) - cparam.cparam_label - in - (label, S.pvar var))), - action )) - |> S.match_ obj + S.match_ obj + (Lst.map constrs (fun { constr_name; constr_args; _ } -> + let constr_name = constr_name.name in + match constr_args with + | None -> + ( S.pconstr constr_name [], + write_string ~is_last:true constr_name logger ) + | Some args -> + let vars = Lst.map args (fun _ -> fresh_name "arg") in + let action = + let msg = + (Stdlib.String.concat "" + [ + "derive(Show) for constructor "; + constr_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + in + write_string ~is_last:true ")" + (write_list args vars + ~write_elem:(fun constr_param -> + fun var -> + fun self -> + match constr_param.cparam_label with + | None -> + write_object ~msg constr_param.cparam_typ + (S.var var) self + | Some label -> + write_object ~msg constr_param.cparam_typ + (S.var var) + (write_string (label.label_name ^ "=") + self)) + (write_string (constr_name ^ "(") logger)) + in + ( S.pconstr constr_name + (Lst.map2 args vars (fun cparam -> + fun var -> + let label = + Option.map + (fun (l : Syntax.label) -> l.label_name) + cparam.cparam_label + in + (label, S.pvar var))), + action ))) | Ptd_record fields -> let write_field (field : Syntax.field_decl) _ self = let field_name = field.field_name.label in let msg = - Stdlib.String.concat "" - [ - "derive(Show) for field "; field_name; " of type "; decl.tycon; - ] + (Stdlib.String.concat "" + [ + "derive(Show) for field "; + field_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) in - self - |> write_string (field_name ^ ": ") - |> write_object ~msg field.field_ty (S.field obj field_name) + write_object ~msg field.field_ty (S.field obj field_name) + (write_string (field_name ^ ": ") self) in - logger |> write_string "{" - |> write_list fields fields ~write_elem:write_field - |> write_string ~is_last:true "}" + write_string ~is_last:true "}" + (write_list fields fields ~write_elem:write_field + (write_string "{" logger)) | Ptd_alias _ -> S.hole) | _ -> assert false @@ -853,20 +681,28 @@ let derive_hash (trait : Syntax.type_name) (decl : Syntax.type_decl) let obj = S.var obj in let hasher = S.var hasher in let rec hash_of_typ ~msg (typ : Syntax.typ) (obj : Syntax.expr) = - match typ with - | Ptype_tuple { tys; _ } -> - let names = - Lst.mapi tys (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) - in - Lst.map2 tys names (fun typ name -> - hash_of_typ ~msg typ (S.var name)) - |> S.seq - |> S.let_ (S.ptuple (Lst.map names S.pvar)) obj - | typ -> - S.apply_trait_method ~assertions ~typ - ~loc:(Syntax.loc_of_type_expression typ) - ~msg trait.name "hash_combine" [ obj; hasher ] No_attr + if type_has_hole typ then S.unit + else + match typ with + | Ptype_tuple { tys; _ } -> + let names = + Lst.mapi tys (fun i -> + fun _ -> + fresh_name + (("x" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide])) + in + S.let_ + (S.ptuple (Lst.map names S.pvar)) + obj + (S.seq + (Lst.map2 tys names (fun typ -> + fun name -> hash_of_typ ~msg typ (S.var name)))) + | typ -> + S.apply_trait_method ~assertions ~typ + ~loc:(Syntax.loc_of_type_expression typ) + ~msg trait.name "hash_combine" [ obj; hasher ] No_attr in match decl.components with | Ptd_abstract -> @@ -874,9 +710,16 @@ let derive_hash (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> let msg = - ("derive(Hash) for newtype " ^ decl.tycon : Stdlib.String.t) + (("derive(Hash) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in hash_of_typ ~msg typ (S.newtype_field obj) | Ptd_error No_payload -> @@ -884,7 +727,9 @@ let derive_hash (trait : Syntax.type_name) (decl : Syntax.type_decl) | Ptd_error (Single_payload typ) -> let var = fresh_name "err_payload" in let msg = - ("derive(Hash) for error type " ^ decl.tycon : Stdlib.String.t) + (("derive(Hash) for error type " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) in S.let_ (S.pconstr decl.tycon [ (None, S.pvar var) ]) @@ -893,189 +738,1506 @@ let derive_hash (trait : Syntax.type_name) (decl : Syntax.type_decl) (S.dot_apply hasher "combine_int" [ S.const_int "0" ]) (hash_of_typ ~msg typ (S.var var))) | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> - Lst.mapi constrs (fun constr_index { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - let args = Option.value ~default:[] constr_args in - let vars = Lst.map args (fun _ -> fresh_name "arg") in - let action = - let msg = - Stdlib.String.concat "" - [ - "derive(Hash) for constructor "; - constr_name; - " of type "; - decl.tycon; - ] - in - S.dot_apply hasher "combine_int" - [ S.const_int (string_of_int constr_index) ] - :: Lst.map2 args vars (fun cparam var -> - hash_of_typ ~msg cparam.cparam_typ (S.var var)) - |> S.seq - in - ( S.pconstr constr_name - (Lst.map2 args vars (fun cparam var -> - let label = - Option.map - (fun (l : Syntax.label) -> l.label_name) - cparam.cparam_label - in - (label, S.pvar var))), - action )) - |> S.match_ obj + S.match_ obj + (Lst.mapi constrs (fun constr_index -> + fun { constr_name; constr_args; _ } -> + let constr_name = constr_name.name in + let args = Option.value ~default:[] constr_args in + let vars = Lst.map args (fun _ -> fresh_name "arg") in + let action = + let msg = + (Stdlib.String.concat "" + [ + "derive(Hash) for constructor "; + constr_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + in + S.seq + (S.dot_apply hasher "combine_int" + [ S.const_int (string_of_int constr_index) ] + :: Lst.map2 args vars (fun cparam -> + fun var -> + hash_of_typ ~msg cparam.cparam_typ (S.var var))) + in + ( S.pconstr constr_name + (Lst.map2 args vars (fun cparam -> + fun var -> + let label = + Option.map + (fun (l : Syntax.label) -> l.label_name) + cparam.cparam_label + in + (label, S.pvar var))), + action ))) | Ptd_record fields -> - Lst.map fields (fun field -> - let field_name = field.field_name.label in - hash_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(Hash) for field "; - field_name; - " of type "; - decl.tycon; - ]) - field.field_ty (S.field obj field_name)) - |> S.seq + S.seq + (Lst.map fields (fun field -> + let field_name = field.field_name.label in + hash_of_typ + ~msg: + (Stdlib.String.concat "" + [ + "derive(Hash) for field "; + field_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + field.field_ty (S.field obj field_name))) | Ptd_alias _ -> S.hole) | _ -> assert false -let derive_to_json (trait : Syntax.type_name) (decl : Syntax.type_decl) - ~(params : string list) ~assertions ~diagnostics = - let rec to_json_of_typ ~msg (typ : Syntax.typ) (obj : Syntax.expr) = - match typ with - | Ptype_tuple { tys; _ } -> - let names = - Lst.mapi tys (fun i _ -> - fresh_name ("x" ^ Int.to_string i : Stdlib.String.t)) +module DeriveJson = struct + type rename_case = + | Unchanged + | Lowercase + | Uppercase + | PascalCase + | CamelCase + | SnakeCase + | ScreamingSnakeCase + | KebabCase + | ScreamingKebabCase + + let parse_rename_directive name = + try + let res = + match name with + | "lowercase" -> Lowercase + | "UPPERCASE" -> Uppercase + | "PascalCase" -> PascalCase + | "camelCase" -> CamelCase + | "snake_case" -> SnakeCase + | "SCREAMING_SNAKE_CASE" -> ScreamingSnakeCase + | "kebab-case" -> KebabCase + | "SCREAMING-KEBAB-CASE" -> ScreamingKebabCase + | _ -> assert false + in + Some res + with _ -> None + + let parse_rename_directive_item_exn (item : Derive_args.meta_item) = + (match parse_rename_directive (Derive_args.item_string_exn item) with + | Some res -> res + | None -> + Derive_args.fail_item item + "Expected one of `lowercase`, `UPPERCASE`, `PascalCase`, \ + `camelCase`, `snake_case`, `SCREAMING_SNAKE_CASE`, `kebab-case`, \ + `SCREAMING-KEBAB-CASE`" + : rename_case) + + let rename_name_parts (case : rename_case) (name_parts : string list) = + (match case with + | Unchanged -> failwith "Unchanged case should not be used here" + | Lowercase -> String.lowercase_ascii (String.concat "" name_parts) + | Uppercase -> String.uppercase_ascii (String.concat "" name_parts) + | PascalCase -> + String.concat "" (Lst.map name_parts String.capitalize_ascii) + | CamelCase -> + let camel_case_name = + List.mapi + (fun i -> + fun part -> + if i = 0 then String.lowercase_ascii part + else String.capitalize_ascii part) + name_parts + in + String.concat "" camel_case_name + | SnakeCase -> String.lowercase_ascii (String.concat "_" name_parts) + | ScreamingSnakeCase -> + String.uppercase_ascii (String.concat "_" name_parts) + | KebabCase -> String.lowercase_ascii (String.concat "-" name_parts) + | ScreamingKebabCase -> + String.uppercase_ascii (String.concat "-" name_parts) + : string) + + let rename_name_from_snake (case : rename_case) (name : string) = + (match case with + | Unchanged -> name + | _ -> + let name_parts = String.split_on_char '_' name in + rename_name_parts case name_parts + : string) + + let rename_name_from_pascal (case : rename_case) (name : string) = + (let rec split_pascal_name (name : string) (last_start : int) (idx : int) + (acc : string list) = + let is_upper ch = ch >= 'A' && ch <= 'Z' in + if idx >= String.length name then + let last_segment = + if last_start < idx then + [ String.sub name last_start (idx - last_start) ] + else [] + in + List.rev (last_segment @ acc) + else + let ch = name.[idx] in + if ch = '_' then split_pascal_name name (idx + 1) (idx + 1) acc + else if not (is_upper ch) then + let next_idx = idx + 1 in + if next_idx >= String.length name then + let sub = String.sub name last_start (idx - last_start + 1) in + split_pascal_name name next_idx next_idx (sub :: acc) + else + let next_ch = name.[next_idx] in + if is_upper next_ch || next_ch = '_' then + let sub = String.sub name last_start (idx - last_start + 1) in + split_pascal_name name next_idx next_idx (sub :: acc) + else split_pascal_name name last_start next_idx acc + else split_pascal_name name last_start (idx + 1) acc + in + match case with + | Unchanged -> name + | _ -> + let name_parts = split_pascal_name name 0 0 [] in + rename_name_parts case name_parts + : string) + + let default_tag_name = "$tag" + + type json_repr = + | Tagged of { tag_name : string } + | ExtTagged + | AdjTagged of { tag_name : string; contents_name : string } + | Untagged + + module StringMap = Basic_map_string + module IntMap = Basic_map_int + + let default_struct_repr = Untagged + let default_enum_repr = Tagged { tag_name = default_tag_name } + + let parse_repr (item : Derive_args.meta_item) + (diag : string -> Rloc.t -> unit) = + (let args = Derive_args.item_value_args_exn item in + let untagged = ref false in + let tag = ref None in + let contents = ref None in + let ext_tagged = ref false in + Derive_args.parse args diag (fun item -> + match () with + | _ when Derive_args.item_label_is "tag" item -> + tag := Some (Derive_args.item_string_exn item) + | _ when Derive_args.item_label_is "contents" item -> + contents := Some (Derive_args.item_string_exn item) + | _ when Derive_args.item_label_is "ext_tagged" item -> + Derive_args.item_no_value_exn item; + ext_tagged := true + | _ when Derive_args.item_label_is "untagged" item -> + Derive_args.item_no_value_exn item; + untagged := true + | _ -> + Derive_args.fail_item item + "Expected one of `tag`, `content`, `ext_tagged` or `untagged`"); + match (!untagged, !tag, !contents, !ext_tagged) with + | true, None, None, false -> Untagged + | false, Some tag, None, false -> Tagged { tag_name = tag } + | false, Some tag, Some content, false -> + AdjTagged { tag_name = tag; contents_name = content } + | false, None, None, true -> ExtTagged + | _ -> + Derive_args.fail_item item + "Expected one of: `tag=...`, both `tag=...` and `contents=...`, \ + `ext_tagged`, `untagged`." + : json_repr) + + type field_value_source = + | SerializedField of string + | SerializedFieldIndex of int + | Constant of Syntax.expr + | Json of json_layout + + and struct_field = { + field_name : string; + value_source : field_value_source; + skip_serialize_if : (Syntax.expr -> Syntax.expr) option; + } + + and struct_field_kind = Field of struct_field + and object_layout = struct_field_kind list + + and json_layout = + | Value of field_value_source + | Array of json_layout list + | Object of object_layout + + type field_layout_args = { + rename : string option; + default : bool; + default_expr : Syntax.expr option; + } + + let default_field_layout_args = + { rename = None; default = false; default_expr = None } + + type struct_layout_args = { + repr : json_repr; + rename_fields : rename_case; + rename_struct : rename_case; + struct_name_override : string option; + field_layout : field_layout_args StringMap.t; + default : bool; + } + + let default_struct_layout_args = + { + repr = default_struct_repr; + rename_fields = Unchanged; + rename_struct = Unchanged; + struct_name_override = None; + field_layout = StringMap.empty; + default = false; + } + + type enum_ctor_repr = CtorTuple | CtorObject + + type enum_ctor_layout_args = { + ctor_name_override : string option; + named_field_layout : field_layout_args StringMap.t; + positional_field_layout : field_layout_args IntMap.t; + } + + type enum_layout_args = { + repr : json_repr; + repr_ctors : enum_ctor_repr; + rename_ctors : rename_case; + rename_fields : rename_case; + ctor_layout_args : enum_ctor_layout_args StringMap.t; + default : bool; + } + + let default_ctor_layout_args = + { + ctor_name_override = None; + named_field_layout = StringMap.empty; + positional_field_layout = IntMap.empty; + } + + let default_enum_layout_args = + { + repr = default_enum_repr; + repr_ctors = CtorObject; + rename_ctors = Unchanged; + rename_fields = Unchanged; + ctor_layout_args = StringMap.empty; + default = false; + } + + let parse_field_attr attr diag = + Derive_args.parse_fold attr diag default_field_layout_args (fun layout -> + fun item -> + match () with + | _ when Derive_args.item_label_is "rename" item -> + let name = Derive_args.item_string_exn item in + { layout with rename = Some name } + | _ when Derive_args.item_label_is "default" item -> ( + match item.value with + | Nothing -> { layout with default = true } + | Value expr -> + { layout with default = true; default_expr = Some expr } + | _ -> + Derive_args.fail_item item + "Expected `default` or a `default=`") + | _ -> Derive_args.fail_item item "Unknown attribute") + + let parse_struct_attr attr diag = + Derive_args.parse_fold attr diag default_struct_layout_args (fun layout -> + fun item -> + match () with + | _ when Derive_args.item_label_is "default" item -> + Derive_args.item_no_value_exn item; + { layout with default = true } + | _ when Derive_args.item_label_is "repr" item -> + let repr = parse_repr item diag in + { layout with repr } + | _ when Derive_args.item_label_is "rename_fields" item -> + let rename_fields = parse_rename_directive_item_exn item in + { layout with rename_fields } + | _ when Derive_args.item_label_is "rename_struct" item -> + let rename_struct = parse_rename_directive_item_exn item in + { layout with rename_struct } + | _ when Derive_args.item_label_is "rename_all" item -> + let rename_directive = parse_rename_directive_item_exn item in + { + layout with + rename_fields = rename_directive; + rename_struct = rename_directive; + } + | _ when Derive_args.item_label_is "fields" item -> + let args = Derive_args.item_value_args_exn item in + let field_layout = + Derive_args.parse_fold args diag StringMap.empty (fun map -> + fun item -> + match Derive_args.item_label item with + | Some field_name -> + let args = Derive_args.item_value_args_exn item in + let layout_args = parse_field_attr args diag in + StringMap.add map field_name layout_args + | _ -> Derive_args.fail_item item "Expected field name") + in + { layout with field_layout } + | _ -> Derive_args.fail_item item "Unknown attribute") + + let parse_enum_ctor_layout_attr diag layout item = + match Derive_args.item_label item with + | Some ctor_name -> + let args = Derive_args.item_value_args_exn item in + let ctor_layout_args = + Derive_args.parse_fold args diag default_ctor_layout_args + (fun layout -> + fun item -> + match () with + | _ when Derive_args.item_label_is "rename" item -> + let name = Derive_args.item_string_exn item in + { layout with ctor_name_override = Some name } + | _ when Derive_args.item_label_is "fields" item -> + let args = Derive_args.item_value_args_exn item in + let named, positional = + Derive_args.parse_fold args diag + (StringMap.empty, IntMap.empty) + (fun (named, positional) -> + fun item -> + match Derive_args.item_label item with + | Some field_name -> ( + let args = Derive_args.item_value_args_exn item in + let field_layout_args = + parse_field_attr args diag + in + match int_of_string_opt field_name with + | Some i -> + ( named, + IntMap.add positional i field_layout_args ) + | None -> + ( StringMap.add named field_name + field_layout_args, + positional )) + | _ -> + Derive_args.fail_item item "Expected field name") + in + { + layout with + named_field_layout = named; + positional_field_layout = positional; + } + | _ -> Derive_args.fail_item item "Unknown attribute") in - S.let_ - (S.ptuple (Lst.map names S.pvar)) - obj - (S.array - (Lst.map2 tys names (fun ty v -> to_json_of_typ ~msg ty (S.var v)))) - | typ -> - S.apply_trait_method ~assertions ~typ - ~loc:(Syntax.loc_of_type_expression typ) - ~msg trait.name "to_json" [ obj ] No_attr - in - match[@warning "-fragile-match"] params with - | self :: [] -> ( - let self = S.var self in - match decl.components with - | Ptd_abstract -> - Local_diagnostics.add_error diagnostics - (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name - ~reason:"target type is abstract" ~loc:trait.loc_); - S.hole - | Ptd_newtype typ -> - to_json_of_typ - ~msg:("derive(ToJson) for newtype " ^ decl.tycon : Stdlib.String.t) - typ (S.newtype_field self) - | Ptd_error No_payload -> - S.map_string_expr [ ("$tag", S.const_string decl.tycon) ] - | Ptd_error (Single_payload typ) -> - let var = fresh_name "err_payload" in - let to_json_for_payload = - to_json_of_typ + StringMap.add layout ctor_name ctor_layout_args + | _ -> Derive_args.fail_item item "Expected constructor name" + + let parse_enum_attr (attr : Syntax.deriving_directive) diag = + let res = + Derive_args.parse_fold attr.args diag default_enum_layout_args + (fun layout -> + fun item -> + match () with + | _ when Derive_args.item_label_is "default" item -> + Derive_args.item_no_value_exn item; + { layout with default = true } + | _ when Derive_args.item_label_is "repr" item -> + let repr = parse_repr item diag in + { layout with repr } + | _ when Derive_args.item_label_is "case_repr" item -> + let args = Derive_args.item_value_args_exn item in + let repr_ctors = + Derive_args.parse_fold args diag CtorObject (fun _ -> + fun item -> + match () with + | _ when Derive_args.item_label_is "tuple" item -> + CtorTuple + | _ when Derive_args.item_label_is "object" item -> + CtorObject + | _ -> + Derive_args.fail_item item + "Expected `tuple` or `object`") + in + { layout with repr_ctors } + | _ when Derive_args.item_label_is "rename_cases" item -> + let rename_ctors = parse_rename_directive_item_exn item in + { layout with rename_ctors } + | _ when Derive_args.item_label_is "rename_fields" item -> + let rename_fields = parse_rename_directive_item_exn item in + { layout with rename_fields } + | _ when Derive_args.item_label_is "rename_all" item -> + let rename_directive = parse_rename_directive_item_exn item in + { + layout with + rename_fields = rename_directive; + rename_ctors = rename_directive; + } + | _ when Derive_args.item_label_is "cases" item -> + let args = Derive_args.item_value_args_exn item in + let ctor_layout_args_list = + Derive_args.parse_fold args diag StringMap.empty + (parse_enum_ctor_layout_attr diag) + in + { layout with ctor_layout_args = ctor_layout_args_list } + | _ -> Derive_args.fail_item item "Unknown attribute") + in + match (res.repr, res.repr_ctors) with + | Tagged _, CtorTuple -> + diag "Internally tagged enum is incompatible with case_repr(tuple)" + attr.loc_; + raise Derive_args.MetaParseErrorNoEmit + | _ -> res + + let option_skip_de_p (value : Syntax.expr) = + (S.match_ value + [ + (S.pconstr "None" [], S.const_bool true); (S.pany, S.const_bool false); + ] + : Syntax.expr) + + let layout_struct_payload (fields : (Syntax.typ * string) list) + (layout : struct_layout_args) = + (let field_renames = + Lst.map fields (fun (_ty, f) -> + let field_layout = + StringMap.find_default layout.field_layout f + default_field_layout_args + in + match field_layout.rename with + | Some s -> s + | None -> rename_name_from_snake layout.rename_fields f) + in + Lst.map2 fields field_renames (fun (ty, name) -> + fun rename -> + Field + { + field_name = rename; + value_source = SerializedField name; + skip_serialize_if = + (if S.type_is_option ty then Some option_skip_de_p else None); + }) + : object_layout) + + let layout_struct_like (serialized_name : string) (repr : json_repr) + (payload : object_layout) = + (match repr with + | Untagged -> payload + | Tagged tag -> + Field + { + field_name = tag.tag_name; + value_source = Constant (S.const_string serialized_name); + skip_serialize_if = None; + } + :: payload + | ExtTagged -> + [ + Field + { + field_name = serialized_name; + value_source = Json (Object payload); + skip_serialize_if = None; + }; + ] + | AdjTagged { tag_name; contents_name } -> + [ + Field + { + field_name = tag_name; + value_source = Constant (S.const_string serialized_name); + skip_serialize_if = None; + }; + Field + { + field_name = contents_name; + value_source = Json (Object payload); + skip_serialize_if = None; + }; + ] + : object_layout) + + let layout_struct (name : string) (fields : (Syntax.typ * string) list) + (layout : struct_layout_args) = + (let payload = layout_struct_payload fields layout in + let name = + match layout.struct_name_override with + | Some s -> s + | _ -> rename_name_from_pascal layout.rename_struct name + in + let payload = layout_struct_like name layout.repr payload in + Object payload + : json_layout) + + let layout_enum_payload_object (fields : string option list) + (layout : enum_layout_args) = + (let ctor_layout = + StringMap.find_default layout.ctor_layout_args "default" + default_ctor_layout_args + in + let field_renames = Vec.empty () in + let _ = + Lst.fold_left fields (0, 0) (fun (absolute, positional) -> + fun f -> + let positional_layout = + IntMap.find_default ctor_layout.positional_field_layout absolute + default_field_layout_args + in + let named_layout = + match f with + | None -> default_field_layout_args + | Some s -> + StringMap.find_default ctor_layout.named_field_layout s + default_field_layout_args + in + let rename, is_positional = + match (positional_layout.rename, named_layout.rename, f) with + | _, Some s, _ -> (s, false) + | Some s, _, _ -> (s, false) + | _, _, Some s -> + (rename_name_from_snake layout.rename_fields s, false) + | None, None, None -> (string_of_int positional, true) + in + Vec.push field_renames rename; + (absolute + 1, if is_positional then positional + 1 else positional)) + in + let field_renames = Vec.to_list field_renames in + Lst.mapi field_renames (fun i -> + fun r -> + Field + { + field_name = r; + value_source = SerializedFieldIndex i; + skip_serialize_if = None; + }) + : object_layout) + + let enum_ctor_renamed (layout_args : enum_layout_args) + (original_name : string) = + (let ctor_override = + StringMap.find_default layout_args.ctor_layout_args original_name + default_ctor_layout_args + in + match ctor_override.ctor_name_override with + | Some s -> s + | None -> rename_name_from_pascal layout_args.rename_ctors original_name + : string) + + let layout_enum_ctor_object (name : string) (enum_args : enum_layout_args) + (fields : string option list) = + (let payload = layout_enum_payload_object fields enum_args in + let ctor_serialized_name = enum_ctor_renamed enum_args name in + let payload = + layout_struct_like ctor_serialized_name enum_args.repr payload + in + Object payload + : json_layout) + + let layout_enum_payload_tuple (name : string) (fields : string option list) + (layout : enum_layout_args) = + (let raw_payloads = + List.mapi (fun i -> fun _ -> Value (SerializedFieldIndex i)) fields + in + match layout.repr with + | Tagged _ -> Value (Constant (S.const_string name)) :: raw_payloads + | _ -> raw_payloads + : json_layout list) + + let layout_tuple_like (name : string) (enum_args : enum_layout_args) + (payload : json_layout list) = + (match enum_args.repr with + | Untagged -> Array payload + | Tagged _ -> + failwith + "Unreachable: Tuple-like ctor does not support internally tagged \ + payload. Error should be intercepted earlier." + | ExtTagged -> + Object + [ + Field + { + field_name = name; + value_source = Json (Array payload); + skip_serialize_if = None; + }; + ] + | AdjTagged { tag_name; contents_name } -> + Object + [ + Field + { + field_name = tag_name; + value_source = Constant (S.const_string name); + skip_serialize_if = None; + }; + Field + { + field_name = contents_name; + value_source = Json (Array payload); + skip_serialize_if = None; + }; + ] + : json_layout) + + let layout_enum_ctor_tuple (name : string) (enum_args : enum_layout_args) + (fields : string option list) = + (let ctor_serialized_name = enum_ctor_renamed enum_args name in + let payload = + layout_enum_payload_tuple ctor_serialized_name fields enum_args + in + layout_tuple_like ctor_serialized_name enum_args payload + : json_layout) + + let layout_enum (ctors : (string * string option list) list) + (options : enum_layout_args) = + let layout_ctor (name, fields) = + match options.repr_ctors with + | CtorObject -> layout_enum_ctor_object name options fields + | CtorTuple -> layout_enum_ctor_tuple name options fields + in + Lst.map ctors layout_ctor + + let serialize_layout + ?(named_fields : (Syntax.expr * Syntax.typ) StringMap.t = StringMap.empty) + ?(indexed_fields : (Syntax.expr * Syntax.typ) array = [||]) + (layout : json_layout) ~(assertions : Syntax.static_assertion Vec.t) + ~(trait : Syntax.type_name) ~(type_description : string) = + let rec ser_layout_internal (layout : json_layout) = + match layout with + | Value v -> ser_value v + | Array values -> ser_array values + | Object fields -> + let map = S.var "$map" in + let write_objects = ser_object fields map in + let string_to_json_map_typ = + S.typ "Map" [ S.typ "String" []; S.typ "Json" [] ] + in + S.let_ (S.pvar "$map") + (S.annotation (S.map_string_expr []) string_to_json_map_typ) + (S.sequence write_objects (S.constr "Object" [ map ])) + and ser_object (fields : object_layout) (write_to_map : Syntax.expr) = + S.seq + (Lst.map fields (fun field -> + match field with + | Field { field_name; value_source; skip_serialize_if = None } -> + let value = ser_value value_source in + S.dot_apply write_to_map "set" + [ S.const_string field_name; value ] + | Field { field_name; value_source; skip_serialize_if = Some skip } + -> + S.if_ + (skip (get_source value_source)) + S.unit + (S.dot_apply write_to_map "set" + [ S.const_string field_name; ser_value value_source ]))) + and ser_array (layout : json_layout list) = + S.array (Lst.map layout (fun l -> ser_layout_internal l)) + and to_json_of_typ_wrap ~msg (typ : Syntax.typ) (obj : Syntax.expr) = + if type_has_hole typ then S.hole + else + match S.extract_option_inner typ with + | Some option_ty -> + S.match_ obj + [ + (S.pconstr "None" [], S.constr "Null" []); + ( S.pconstr "Some" [ (None, S.pvar "$inner") ], + to_json_of_typ ~msg option_ty (S.var "$inner") ); + ] + | _ -> to_json_of_typ ~msg typ obj + and to_json_of_typ ~msg typ obj = + S.apply_trait_method ~assertions ~typ + ~loc:(Syntax.loc_of_type_expression typ) + ~msg: + (Stdlib.String.concat "" + [ + "derive "; + Basic_longident.to_string trait.name; + " for "; + type_description; + " "; + msg; + ]) + trait.name "to_json" [ obj ] No_attr + and get_source (source : field_value_source) = + match source with + | SerializedField field_name -> + let field, _ = StringMap.find_exn named_fields field_name in + field + | SerializedFieldIndex index -> + let field, _ = indexed_fields.(index) in + field + | Constant c -> c + | Json _ -> + failwith + "Unexpected JSON layout in get_source, which is intended to get \ + the value before serialization" + and ser_value (source : field_value_source) = + match source with + | SerializedField field_name -> + let field, typ = StringMap.find_exn named_fields field_name in + to_json_of_typ_wrap + ~msg:(("field " ^ field_name : Stdlib.String.t) [@merlin.hide]) + typ field + | SerializedFieldIndex index -> + let field, typ = indexed_fields.(index) in + to_json_of_typ_wrap + ~msg: + (("field index " ^ Int.to_string index + : Stdlib.String.t) + [@merlin.hide]) + typ field + | Constant c -> S.dot_apply c "to_json" [] + | Json layout -> ser_layout_internal layout + in + ser_layout_internal layout + + let derive_to_json (directive : Syntax.deriving_directive) + (decl : Syntax.type_decl) ~(params : string list) ~assertions ~diagnostics + = + let trait = directive.type_name_ in + let diag = + Derive_args.mk_diag_emitter ~host_type:decl.tycon ~trait_name:trait.name + diagnostics + in + match[@warning "-fragile-match"] params with + | self :: [] -> ( + let self = S.var self in + let do_parse () = + match decl.components with + | Ptd_abstract -> + diag "target type is abstract" trait.loc_; + S.hole + | Ptd_extern -> + diag "target type is external" trait.loc_; + S.hole + | Ptd_newtype typ -> ( + match typ with + | _ when type_has_hole typ -> S.hole + | typ -> + S.apply_trait_method ~assertions ~typ + ~loc:(Syntax.loc_of_type_expression typ) + ~msg: + (("derive(ToJson) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) + trait.name "to_json" + [ S.newtype_field self ] + No_attr) + | Ptd_error No_payload -> + let tag = decl.tycon in + let attrs = parse_enum_attr directive diag in + let layout = layout_enum [ (tag, []) ] attrs in + let layout = List.hd layout in + serialize_layout layout ~assertions ~trait + ~type_description:decl.tycon + | Ptd_error (Single_payload typ) -> + let tag = decl.tycon in + let var = fresh_name "err_payload" in + let attrs = parse_enum_attr directive diag in + let layout = layout_enum [ (tag, [ None ]) ] attrs in + let layout = List.hd layout in + let ser_code = + serialize_layout layout + ~indexed_fields:[| (S.var var, typ) |] + ~assertions ~trait ~type_description:decl.tycon + in + S.let_ (S.pconstr decl.tycon [ (None, S.pvar var) ]) self ser_code + | Ptd_error (Enum_payload ctors) | Ptd_variant ctors -> + let attrs = parse_enum_attr directive diag in + let enum_layout_raw = + Lst.map ctors (fun { constr_name; constr_args; _ } -> + let arg_names = + match constr_args with + | None -> [] + | Some arg_list -> + Lst.map arg_list (fun { cparam_label; _ } -> + Option.map + (fun (lbl : Syntax.label) -> lbl.label_name) + cparam_label) + in + (constr_name.name, arg_names)) + in + let layout = layout_enum enum_layout_raw attrs in + S.match_ self + (Lst.map2 ctors layout (fun { constr_name; constr_args; _ } -> + fun layout -> + let constr_name = constr_name.name in + let args = Option.value ~default:[] constr_args in + let vars = Lst.map args (fun _ -> fresh_name "arg") in + let args_with_types = + Array.of_list + (Lst.map2 vars args (fun name -> + fun arg -> (S.var name, arg.cparam_typ))) + in + let layout_code = + serialize_layout ~indexed_fields:args_with_types layout + ~assertions ~trait + ~type_description: + (Stdlib.String.concat "" + [ + "enum "; + constr_name; + " constructor "; + decl.tycon; + ] [@merlin.hide]) + in + ( S.pconstr constr_name + (Lst.map2 args vars (fun cparam -> + fun var -> + let label = + Option.map + (fun (l : Syntax.label) -> l.label_name) + cparam.cparam_label + in + (label, S.pvar var))), + layout_code ))) + | Ptd_record fields -> + let type_name = decl.tycon in + let attrs = parse_struct_attr directive.args diag in + let field_desc = + Lst.map fields (fun field -> + (field.field_ty, field.field_name.label)) + in + let layout = layout_struct type_name field_desc attrs in + let named_field_types = + StringMap.add_list + (Lst.map fields (fun field -> + ( field.field_name.label, + (S.field self field.field_name.label, field.field_ty) + ))) + StringMap.empty + in + serialize_layout ~named_fields:named_field_types layout + ~assertions ~trait ~type_description:decl.tycon + | Ptd_alias _ -> S.hole + in + match Derive_args.wrap_parse do_parse with + | Some v -> v + | None -> S.hole) + | _ -> assert false + + let deserialize_layout + ?(named_fields : (Syntax.typ * Syntax.expr option) StringMap.t = + StringMap.empty) + ?(positional_fields : (Syntax.typ * Syntax.expr option) array = [||]) + (layout : json_layout) (input_json : Syntax.expr) + (input_json_path : Syntax.expr) + (construct : + (string * Syntax.expr) list -> Syntax.expr list -> Syntax.expr) + (error : Syntax.expr -> string -> Syntax.expr) + ~(assertions : Syntax.static_assertion Vec.t) ~(trait : Syntax.type_name) + ~(type_description : string) = + (let named_field_vars = + StringMap.mapi named_fields (fun key -> + fun _ -> fresh_name ("de_" ^ key)) + in + let positional_field_vars = + Array.map (fun _ -> fresh_name "de_arg") positional_fields + in + let decl_vars expr = + let expr = + Lst.fold_left (StringMap.bindings named_field_vars) expr (fun expr -> + fun (_, var) -> S.letmut var None (S.constr "None" []) expr) + in + Lst.fold_left (Array.to_list positional_field_vars) expr (fun expr -> + fun var -> S.letmut var None (S.constr "None" []) expr) + in + let rec de_layout_internal (layout : json_layout) (input_v : Syntax.expr) + input_json_path = + match layout with + | Value v -> de_value_source from_json_of_typ v input_v input_json_path + | Array values -> de_array values input_v input_json_path + | Object fields -> de_object fields input_v input_json_path + and de_value_source de_fn (v : field_value_source) (input_v : Syntax.expr) + input_json_path = + match v with + | SerializedField field_name -> + let field_typ, _ = StringMap.find_exn named_fields field_name in + let field_deserialized = + de_fn + ~msg:(("field " ^ field_name : Stdlib.String.t) [@merlin.hide]) + field_typ input_v input_json_path + in + let named_field_var = + StringMap.find_exn named_field_vars field_name + in + S.assign named_field_var (S.constr "Some" [ field_deserialized ]) + | SerializedFieldIndex idx -> + let field_typ, _ = positional_fields.(idx) in + let field_deserialized = + de_fn + ~msg: + (("field index " ^ Int.to_string idx + : Stdlib.String.t) + [@merlin.hide]) + field_typ input_v input_json_path + in + let positional_field_var = positional_field_vars.(idx) in + S.assign positional_field_var + (S.constr "Some" [ field_deserialized ]) + | Constant _ -> S.unit + | Json inner -> de_layout_internal inner input_v input_json_path + and de_array (layout : json_layout list) (input_v : Syntax.expr) + input_json_path = + let vars = Lst.map layout (fun _ -> fresh_name "arg") in + let pattern_match_array = + Syntax.Ppat_array + { + pats = Closed (Lst.map vars (fun v -> S.array_pat (S.pvar v))); + loc_ = Rloc.no_location; + } + in + let array_deserialized = + Lst.map2i layout vars (fun index -> + fun layout -> + fun var_name -> + de_layout_internal layout (S.var var_name) + (S.json_path_add_index input_json_path index)) + in + S.match_ input_v + [ + (pattern_match_array, S.seq array_deserialized); + ( S.pany, + error input_json_path + ("Expected array to deserialize " ^ type_description + : Stdlib.String.t) ); + ] + and de_object (fields : object_layout) (input_v : Syntax.expr) + input_json_path = + let map = S.var "_map" in + let pattern_match_object = + S.pconstr "Object" [ (None, S.pvar "_map") ] + in + let object_deserialized = + Lst.map fields (fun field -> + match field with + | Field { field_name; value_source; _ } -> + let original_field = + S.dot_apply map "get" [ S.const_string field_name ] + in + let de_field = + de_value_source struct_field_from_json_of_typ value_source + (S.var "_v") + (S.json_path_add_key input_json_path field_name) + in + S.match_ original_field + [ + (S.pconstr "None" [], S.unit); + (S.pconstr "Some" [ (None, S.pvar "_v") ], de_field); + ]) + in + S.match_ input_v + [ + (pattern_match_object, S.seq object_deserialized); + ( S.pany, + error input_json_path + ("Expected object to deserialize " ^ type_description + : Stdlib.String.t) ); + ] + and struct_field_from_json_of_typ ~msg typ input_v input_json_path = + match S.extract_option_inner typ with + | Some inner -> + let de_res = from_json_of_typ ~msg inner input_v input_json_path in + S.constr "Some" [ de_res ] + | None -> from_json_of_typ ~msg typ input_v input_json_path + and from_json_of_typ ~msg typ input_v input_json_path = + if type_has_hole typ then S.hole + else + S.apply_trait_method ~assertions ~typ + ~msg: + (Stdlib.String.concat "" + [ + "derive "; + Basic_longident.to_string trait.name; + " for "; + type_description; + " "; + msg; + ]) + ~loc:(Syntax.loc_of_type_expression typ) + trait.name "from_json" + [ input_v; input_json_path ] + Exclamation + in + let de_exprs = de_layout_internal layout input_json input_json_path in + let comptime_assert_default_ty (ty : Syntax.typ) (default : Syntax.expr) = + let loc = Syntax.loc_of_expression default in + let res = S.annotation ~loc_:loc default ty in + res + in + let named_fields_assign_default = + Lst.map (StringMap.bindings named_field_vars) (fun (key, var) -> + let ty, default = StringMap.find_exn named_fields key in + let on_none = + match default with + | Some default -> comptime_assert_default_ty ty default + | None when S.type_is_option ty -> S.constr "None" [] + | None -> + error input_json_path + (("Missing field " ^ key : Stdlib.String.t) [@merlin.hide]) + in + S.match_ (S.var var) + [ + (S.pconstr "Some" [ (None, S.pvar "v") ], S.var "v"); + (S.pconstr "None" [], on_none); + ]) + in + let positional_fields_assign_default = + Lst.mapi (Array.to_list positional_field_vars) (fun i -> + fun var -> + let ty, default = positional_fields.(i) in + let on_none = + match default with + | Some default -> comptime_assert_default_ty ty default + | None -> + error input_json_path + (("Missing positional field " ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide]) + in + S.match_ (S.var var) + [ + (S.pconstr "Some" [ (None, S.pvar "v") ], S.var "v"); + (S.pconstr "None" [], on_none); + ]) + in + let named_fields_values = + Lst.map (StringMap.bindings named_field_vars) (fun (key, var) -> + (key, S.var var)) + in + let positional_fields_values = + Lst.map (Array.to_list positional_field_vars) S.var + in + let construct = construct named_fields_values positional_fields_values in + let construct = + Lst.fold_left2 named_fields_assign_default + (StringMap.bindings named_field_vars) construct (fun value -> + fun (_, orig_var_name) -> + fun acc -> S.let_ (S.pvar orig_var_name) value acc) + in + let construct = + Lst.fold_left2 positional_fields_assign_default + (Array.to_list positional_field_vars) construct (fun value -> + fun orig_var_name -> + fun acc -> S.let_ (S.pvar orig_var_name) value acc) + in + let res = S.seq [ de_exprs; construct ] in + decl_vars res + : Syntax.expr) + + let default_of ~(enabled : bool) (explicit_value : Syntax.expr option) + (typ : Syntax.typ) ~assertions ~field_name = + (match explicit_value with + | _ when not enabled -> None + | Some v -> Some v + | None -> + Some + (S.apply_trait_method ~assertions ~typ ~msg: - ("derive(ToJson) for error type " ^ decl.tycon + (("derive(FromJson) for default value of " ^ field_name : Stdlib.String.t) - typ (S.var var) - in - S.let_ - (S.pconstr decl.tycon [ (None, S.pvar var) ]) - self - (S.map_string_expr + [@merlin.hide]) + ~loc:(Syntax.loc_of_type_expression typ) + (Basic_longident.Ldot + { pkg = "moonbitlang/core/builtin"; id = "Default" }) + "default" [] No_attr) + : Syntax.expr option) + + let deserialize_enum (args : enum_layout_args) + (ctors : (string * (Syntax.typ * string option) list) list) + (input_json : Syntax.expr) (input_json_path : Syntax.expr) + ~(assertions : Syntax.static_assertion Vec.t) ~(trait : Syntax.type_name) + ~(type_name : string) = + (let error_expr path msg = + S.raise_json_decode_error path + (S.infix_op "+" msg + (S.const_string + (" when deserializing " ^ type_name : Stdlib.String.t))) + in + let error path msg = + S.raise_json_decode_error path + (S.const_string + (msg ^ " when derserializing " ^ type_name : Stdlib.String.t)) + in + let with_path_add key_expr perform = + S.let_ (S.pvar "$path") + (S.json_path_add_key_expr input_json_path key_expr) + (perform (S.var "$path")) + in + let extract_object (input_v : Syntax.expr) + (perform : Syntax.expr -> Syntax.expr) = + let map_name = fresh_name "map" in + let pattern = S.pconstr "Object" [ (None, S.pvar map_name) ] in + let deserialized = perform (S.var map_name) in + S.match_ input_v + [ + (pattern, deserialized); + (S.pany, error input_json_path "Expected object"); + ] + in + let extract_array (input_v : Syntax.expr) + (perform : Syntax.expr -> Syntax.expr) = + let array_name = fresh_name "array" in + let pattern = S.pconstr "Array" [ (None, S.pvar array_name) ] in + let deserialized = perform (S.var array_name) in + S.match_ input_v + [ + (pattern, deserialized); + (S.pany, error input_json_path "Expected array"); + ] + in + let extract_string (context : string) (e : Syntax.expr) = + S.match_ e + [ + (S.pconstr "String" [ (None, S.pvar "s") ], S.var "s"); + ( S.pany, + error input_json_path + ("Expected string at " ^ context : Stdlib.String.t) ); + ] + in + let extract_field (tag_name : string) = + extract_object input_json (fun map -> + let tag = S.dot_apply map "get" [ S.const_string tag_name ] in + S.match_ tag + [ + (S.pconstr "Some" [ (None, S.pvar "field") ], S.var "field"); + ( S.pany, + error input_json_path + ("Missing tag at field " ^ tag_name : Stdlib.String.t) ); + ]) + in + let extract_tag_and_payload_ext_tagged_k + (and_then : Syntax.expr -> Syntax.expr -> Syntax.expr -> Syntax.expr) = + let result = + extract_object input_json (fun map -> + let size = S.dot_apply map "size" [] in + S.match_ size [ - ("$tag", S.const_string decl.tycon); ("0", to_json_for_payload); + ( Syntax.Ppat_constant + { c = Syntax.Const_int "0"; loc_ = Rloc.no_location }, + error input_json_path "Missing tag in externally-tagged enum" + ); + ( Syntax.Ppat_constant + { c = Syntax.Const_int "1"; loc_ = Rloc.no_location }, + S.dot_apply + (S.dot_apply (S.dot_apply map "iter" []) "peek" []) + "unwrap" [] ); + ( S.pany, + error input_json_path + "More than one key found in externally-tagged enum" ); ]) - | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> - Lst.map constrs (fun { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - let args = Option.value ~default:[] constr_args in - let vars = Lst.map args (fun _ -> fresh_name "arg") in - let action = - let positional_index = ref (-1) in - Lst.map2 args vars (fun cparam var -> - let arg = - to_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(ToJson) for constructor "; - constr_name; - " of type "; - decl.tycon; - ]) - cparam.cparam_typ (S.var var) + in + S.let_ + (S.ptuple [ S.pvar "k"; S.pvar "v" ]) + result + (with_path_add (S.var "k") (fun path -> + and_then (S.var "k") (S.var "v") path)) + in + let extract_tag_array () = + extract_array input_json (fun input_json -> + let tag = S.dot_apply input_json "get" [ S.const_int "0" ] in + S.match_ tag + [ + ( S.pconstr "Some" + [ (None, S.pconstr "String" [ (None, S.pvar "tag") ]) ], + S.var "tag" ); + ( S.pconstr "Some" [ (None, S.pany) ], + error input_json_path "Expected string tag at array[0]" ); + (S.pany, error input_json_path "Missing tag in array[0]"); + ]) + in + let extract_tag_and_payload_k (kind : json_repr) + (ctor_reprs : enum_ctor_repr) + (and_then : Syntax.expr -> Syntax.expr -> Syntax.expr -> Syntax.expr) = + match (kind, ctor_reprs) with + | Tagged { tag_name }, CtorObject -> + and_then + (extract_string tag_name (extract_field tag_name)) + input_json input_json_path + | Tagged _, CtorTuple -> + and_then (extract_tag_array ()) input_json input_json_path + | AdjTagged { tag_name; contents_name }, _ -> + with_path_add (S.const_string contents_name) (fun path -> + and_then + (extract_string tag_name (extract_field tag_name)) + (extract_field contents_name) + path) + | ExtTagged, _ -> extract_tag_and_payload_ext_tagged_k and_then + | Untagged, _ -> + failwith + "Unreachable: untagged constructor should be intercepted earlier" + in + let layout_ctor_payload name fields args = + match args.repr_ctors with + | CtorObject -> Object (layout_enum_payload_object fields args) + | CtorTuple -> Array (layout_enum_payload_tuple name fields args) + in + let positional_fields_desc variant_desc variant_args = + let default_enabled_for_type = args.default in + Lst.mapi variant_desc (fun i -> + fun (ty, name) -> + let positional_layout = + IntMap.find_default variant_args.positional_field_layout i + default_field_layout_args + in + let default_enabled_positional = positional_layout.default in + let default_expr_positional = positional_layout.default_expr in + let named_layout = + match name with + | None -> default_field_layout_args + | Some name -> + StringMap.find_default variant_args.named_field_layout name + default_field_layout_args + in + let default_enabled_named = named_layout.default in + let default_expr_named = named_layout.default_expr in + let default_enabled = + default_enabled_for_type || default_enabled_positional + || default_enabled_named + in + let default_value = + match (default_expr_positional, default_expr_named) with + | Some expr, None -> Some expr + | None, Some expr -> Some expr + | Some _, Some _ -> + failwith + "TODO: default_expr_positional and default_expr_named \ + should not both be set" + | None, None -> None + in + let default_value = + default_of ~enabled:default_enabled default_value ty ~assertions + ~field_name: + (match name with + | None -> + ("index " ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide] + | Some name -> name) + in + (ty, default_value)) + in + let deserialize_tagged () = + extract_tag_and_payload_k args.repr args.repr_ctors (fun tag -> + fun payload -> + fun payload_path -> + let ctor_cases = + Lst.map ctors (fun (ctor_name, ctor_desc) -> + let ctor_tag = enum_ctor_renamed args ctor_name in + let payload_layout = + layout_ctor_payload ctor_tag (Lst.map ctor_desc snd) args + in + let ctor_args = + StringMap.find_default args.ctor_layout_args ctor_name + default_ctor_layout_args + in + let ctor_deserialized = + deserialize_layout + ~positional_fields: + (Array.of_list + (positional_fields_desc ctor_desc ctor_args)) + payload_layout payload payload_path + (fun _named -> + fun positional_fields -> + if _named <> [] then + failwith + "Unreachable: Tagged enum deserialize \ + constructor should not have named fields"; + S.constr_label ctor_name + (Lst.map2 positional_fields ctor_desc (fun value -> + fun desc -> + let label = Option.map S.label (snd desc) in + (value, label)))) + (fun path -> fun msg -> error path msg) + ~assertions ~trait + ~type_description: + (Stdlib.String.concat "" + [ "enum "; type_name; " constructor "; ctor_name ]) + in + ( S.pconstant + (Syntax.Const_string + { string_val = ctor_tag; string_repr = ctor_tag }), + ctor_deserialized )) + in + let err_case = + error_expr input_json_path + (S.infix_op "+" + (S.const_string "Unknown enum constructor ") + (S.var "tag")) + in + S.match_ tag (ctor_cases @ [ (S.pvar "tag", err_case) ])) + in + let deserialize_untagged () = + let ctor_deserializers = + Lst.map ctors (fun (ctor_name, ctor_desc) -> + let ctor_tag = enum_ctor_renamed args ctor_name in + let ctror_layout = + layout_ctor_payload ctor_tag (Lst.map ctor_desc snd) args + in + let ctor_deserialized = + deserialize_layout + ~positional_fields: + (Array.of_list + (Lst.map ctor_desc (fun (ty, _) -> (ty, None)))) + ctror_layout input_json input_json_path + (fun _named -> + fun positional_fields -> + if _named <> [] then + failwith + "Unreachable: Untagged enum deserialize constructor \ + should not have named fields"; + S.constr_label ctor_tag + (Lst.map2 positional_fields ctor_desc (fun value -> + fun desc -> + let label = Option.map S.label (snd desc) in + (value, label)))) + (fun path -> fun msg -> error path msg) + ~assertions ~trait + ~type_description: + (Stdlib.String.concat "" + [ "enum "; type_name; " constructor "; ctor_tag ]) + in + Syntax.Pexpr_try + { + body = + Syntax.Pexpr_return + { + return_value = Some ctor_deserialized; + loc_ = Rloc.no_location; + }; + catch = [ { pattern = S.pany; guard = None; body = S.unit } ]; + catch_all = true; + try_else = None; + try_loc_ = Rloc.no_location; + catch_loc_ = Rloc.no_location; + else_loc_ = Rloc.no_location; + loc_ = Rloc.no_location; + }) + in + let err_case = + error input_json_path + ("Unable to find deserializable constructor of enum " ^ type_name + : Stdlib.String.t) + in + S.sequence (S.seq ctor_deserializers) err_case + in + match args.repr with + | Untagged -> deserialize_untagged () + | Tagged _ | AdjTagged _ | ExtTagged -> deserialize_tagged () + : Syntax.expr) + + let derive_from_json (directive : Syntax.deriving_directive) + (decl : Syntax.type_decl) ~(params : string list) ~assertions ~diagnostics + = + match[@warning "-fragile-match"] params with + | [ json; path ] -> ( + let json, path = (S.var json, S.var path) in + let trait = directive.type_name_ in + let diag = + Derive_args.mk_diag_emitter ~host_type:decl.tycon + ~trait_name:trait.name diagnostics + in + let do_parse () = + match decl.components with + | Ptd_abstract -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is abstract" ~loc:trait.loc_); + S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole + | Ptd_newtype typ -> + if type_has_hole typ then S.hole + else + S.constr decl.tycon + [ + S.apply_trait_method ~assertions ~typ + ~msg: + (("derive(FromJson) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) + ~loc:(Syntax.loc_of_type_expression typ) + trait.name "from_json" [ json; path ] Exclamation; + ] + | Ptd_error (Single_payload typ) -> + let attrs = parse_enum_attr directive diag in + deserialize_enum attrs + [ (decl.tycon, [ (typ, None) ]) ] + json path ~assertions ~trait ~type_name:decl.tycon + | Ptd_error No_payload -> + let attrs = parse_enum_attr directive diag in + deserialize_enum attrs + [ (decl.tycon, []) ] + json path ~assertions ~trait ~type_name:decl.tycon + | Ptd_error (Enum_payload ctors) | Ptd_variant ctors -> + let attrs = parse_enum_attr directive diag in + let enum_layout_raw = + Lst.map ctors (fun { constr_name; constr_args; _ } -> + let arg_names = + match constr_args with + | None -> [] + | Some arg_list -> + Lst.map arg_list + (fun { cparam_label; cparam_typ; _ } -> + ( cparam_typ, + Option.map + (fun (lbl : Syntax.label) -> lbl.label_name) + cparam_label )) in - match cparam.cparam_label with - | None -> - incr positional_index; - (string_of_int !positional_index, arg) - | Some label -> (label.label_name, arg)) - |> List.cons ("$tag", S.const_string constr_name) - |> S.map_string_expr + (constr_name.name, arg_names)) in - ( S.pconstr constr_name - (Lst.map2 args vars (fun cparam var -> - let label = - Option.map - (fun (l : Syntax.label) -> l.label_name) - cparam.cparam_label - in - (label, S.pvar var))), - action )) - |> S.match_ self - | Ptd_record fields -> - let field_is_option_match_cases (field : Syntax.field_decl) = - let field_name = field.field_name.label in - let expr = S.field self field_name in - [ - (S.pconstr "None" [], S.unit); - ( S.pconstr "Some" [ (None, S.pvar "v") ], - S.map_insert_json field_name - (to_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(ToJson) for field "; - field_name; - " of type "; - decl.tycon; - ]) - field.field_ty (S.var "v")) ); - ] - |> S.match_ expr - in - let map_var = S.var "$map" in - let expr_lst = - Lst.map fields (fun field -> - if S.is_option field then field_is_option_match_cases field - else - let field_name = field.field_name.label in - S.map_insert_json field_name - (to_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(ToJson) for field "; - field.field_name.label; - " of type "; - decl.tycon; - ]) - field.field_ty (S.field self field_name))) - in - let obj_constr = S.constr "Object" [ map_var ] in - let string_to_json_map_typ = - S.typ "Map" [ S.typ "String" []; S.typ "Json" [] ] - in - S.let_ (S.pvar "$map") - (S.annotation (S.map_string_expr []) string_to_json_map_typ) - (Lst.fold_right expr_lst obj_constr S.sequence) - | Ptd_alias _ -> S.hole) - | _ -> assert false + deserialize_enum attrs enum_layout_raw json path ~assertions + ~trait ~type_name:decl.tycon + | Ptd_record fields -> + let attrs = parse_struct_attr directive.args diag in + let struct_layout = + layout_struct decl.tycon + (Lst.map fields (fun field -> + (field.field_ty, field.field_name.label))) + attrs + in + let type_enable_default = attrs.default in + let fields_info = + Lst.map fields (fun field -> + let field_default = + StringMap.find_default attrs.field_layout + field.field_name.label default_field_layout_args + in + let default_enabled = + field_default.default || type_enable_default + in + let default_expr = field_default.default_expr in + let default_value = + default_of ~enabled:default_enabled default_expr + field.field_ty ~assertions + ~field_name:field.field_name.label + in + (field.field_name.label, (field.field_ty, default_value))) + in + deserialize_layout + ~named_fields:(StringMap.of_list fields_info) + struct_layout json path + (fun named_fields -> + fun _positional -> + if _positional <> [] then + failwith + "Unreachable: Record deserialize constructor should not \ + have positional fields"; + S.record + (Lst.map fields (fun field -> + let field_name = field.field_name.label in + let field_expr = + Lst.assoc_str_exn named_fields field_name + in + (field_name, field_expr)))) + (fun path -> + fun msg -> S.raise_json_decode_error path (S.const_string msg)) + ~assertions ~trait ~type_description:decl.tycon + | Ptd_alias _ -> S.hole + in + match Derive_args.wrap_parse do_parse with + | Some v -> v + | None -> S.hole) + | _ -> assert false +end + +let derive_to_json = DeriveJson.derive_to_json +let derive_from_json = DeriveJson.derive_from_json let derive_arbitrary (trait : Syntax.type_name) (decl : Syntax.type_decl) ~(params : string list) ~assertions ~diagnostics = @@ -1083,13 +2245,15 @@ let derive_arbitrary (trait : Syntax.type_name) (decl : Syntax.type_decl) | [ size; rng ] -> ( let size, rng = (S.var size, S.var rng) in let rec arbitrary_of_typ ~msg (typ : Syntax.typ) = - match typ with - | Ptype_tuple { tys; _ } -> - S.tuple (Lst.map tys (arbitrary_of_typ ~msg)) - | typ -> - S.apply_trait_method ~assertions ~typ ~msg - ~loc:(Syntax.loc_of_type_expression typ) - trait.name "arbitrary" [ size; rng ] No_attr + if type_has_hole typ then S.hole + else + match typ with + | Ptype_tuple { tys; _ } -> + S.tuple (Lst.map tys (arbitrary_of_typ ~msg)) + | typ -> + S.apply_trait_method ~assertions ~typ ~msg + ~loc:(Syntax.loc_of_type_expression typ) + trait.name "arbitrary" [ size; rng ] No_attr in match decl.components with | Ptd_abstract -> @@ -1097,19 +2261,30 @@ let derive_arbitrary (trait : Syntax.type_name) (decl : Syntax.type_decl) (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name ~reason:"target type is abstract" ~loc:trait.loc_); S.hole + | Ptd_extern -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name + ~reason:"target type is external" ~loc:trait.loc_); + S.hole | Ptd_newtype typ -> - arbitrary_of_typ - ~msg: - ("derive(Arbitrary) for newtype " ^ decl.tycon : Stdlib.String.t) - typ + S.constr decl.tycon + [ + arbitrary_of_typ + ~msg: + (("derive(Arbitrary) for newtype " ^ decl.tycon + : Stdlib.String.t) + [@merlin.hide]) + typ; + ] | Ptd_error No_payload -> S.constr decl.tycon [] | Ptd_error (Single_payload typ) -> S.constr decl.tycon [ arbitrary_of_typ ~msg: - ("derive(Arbitrary) for error type " ^ decl.tycon + (("derive(Arbitrary) for error type " ^ decl.tycon : Stdlib.String.t) + [@merlin.hide]) typ; ] | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> ( @@ -1132,7 +2307,7 @@ let derive_arbitrary (trait : Syntax.type_name) (decl : Syntax.type_decl) constr_name; " of type "; decl.tycon; - ]) + ] [@merlin.hide]) arg.cparam_typ, arg.cparam_label ))) | multi -> @@ -1143,263 +2318,44 @@ let derive_arbitrary (trait : Syntax.type_name) (decl : Syntax.type_decl) (S.const_uint "1")) (S.const_uint (string_of_int (List.length multi))) in - Lst.mapi multi (fun i { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - let args = Option.value ~default:[] constr_args in - let action = - S.constr_label constr_name - (Lst.map args (fun arg -> - ( arbitrary_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(Arbitrary) for constructor "; - constr_name; - " of type "; - decl.tycon; - ]) - arg.cparam_typ, - arg.cparam_label ))) - in - (S.const_uint_pat (string_of_int i), action)) - |> S.match_ exp) - | Ptd_record fields -> - Lst.map fields (fun field -> - let field_name = field.field_name.label in - ( field_name, - arbitrary_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(Arbitrary) for field "; - field_name; - " of type "; - decl.tycon; - ]) - field.field_ty )) - |> S.record - | Ptd_alias _ -> S.hole) - | _ -> assert false - -let derive_from_json (trait : Syntax.type_name) (decl : Syntax.type_decl) - ~(params : string list) ~assertions ~diagnostics = - match[@warning "-fragile-match"] params with - | [ json; path ] -> ( - let json, path = (S.var json, S.var path) in - let from_json_of_typ ~msg (typ : Syntax.typ) (json : Syntax.expr) - (path : Syntax.expr) : Syntax.expr = - S.apply_trait_method ~assertions ~typ ~msg - ~loc:(Syntax.loc_of_type_expression typ) - trait.name "from_json" [ json; path ] Exclamation - in - let err_case = - S.rest_raise_json_decode_error_ path - (S.const_string ("invalid JSON for " ^ decl.tycon : Stdlib.String.t)) - in - match decl.components with - | Ptd_abstract -> - Local_diagnostics.add_error diagnostics - (Errors.cannot_derive ~tycon:decl.tycon ~trait:trait.name - ~reason:"target type is abstract" ~loc:trait.loc_); - S.hole - | Ptd_newtype typ -> - S.constr decl.tycon - [ - S.annotation - (from_json_of_typ - ~msg: - ("derive(FromJson) for newtype " ^ decl.tycon - : Stdlib.String.t) - typ json path) - typ; - ] - | Ptd_error (Single_payload typ) -> - let vars = fresh_name "err_payload" in - let pattern = - [ - ( "$tag", - S.pconstant - (Const_string - { string_val = decl.tycon; string_repr = decl.tycon }) ); - ("0", S.pvar vars); - ] - |> S.map_pat_elem_lst - in - let expr = - let updated_path = - S.apply - (S.method_ (Ldot { pkg = "json"; id = "JsonPath" }) "add_index") - [ path; S.const_int "0" ] - No_attr - in - S.constr decl.tycon - [ - S.annotation - (from_json_of_typ - ~msg: - ("derive(FromJson) for error type " ^ decl.tycon - : Stdlib.String.t) - typ (S.var vars) updated_path) - typ; - ] - in - [ (S.pmap pattern, expr); err_case ] |> S.match_ json - | Ptd_error No_payload -> - let pattern = - [ - ( "$tag", - S.pconstant - (Const_string - { string_val = decl.tycon; string_repr = decl.tycon }) ); - ] - |> S.map_pat_elem_lst - in - let expr = S.constr decl.tycon [] in - [ (S.pmap pattern, expr); err_case ] |> S.match_ json - | Ptd_error (Enum_payload constrs) | Ptd_variant constrs -> - let map_cases = - Lst.map constrs (fun { constr_name; constr_args; _ } -> - let constr_name = constr_name.name in - let args = Option.value ~default:[] constr_args in - let vars = Lst.map args (fun _ -> fresh_name "arg") in - let pattern = - let positional_index = ref (-1) in - Lst.map2 args vars (fun cparam var -> - let p = S.pvar var in - match cparam.cparam_label with - | None -> - incr positional_index; - (string_of_int !positional_index, p) - | Some label -> (label.label_name, p)) - |> List.cons - ( "$tag", - S.pconstant - (Const_string - { - string_val = constr_name; - string_repr = constr_name; - }) ) - |> S.map_pat_elem_lst - in - let expr = - let positional_index = ref (-1) in - Lst.map2 args vars (fun cparam var -> - let updated_path, label_opt = - match cparam.cparam_label with - | None -> - incr positional_index; - let path = - S.apply - (S.method_ - (Ldot { pkg = "json"; id = "JsonPath" }) - "add_index") - [ - path; - S.const_int (string_of_int !positional_index); - ] - No_attr - in - (path, None) - | Some label -> - let path = - S.apply - (S.method_ - (Ldot { pkg = "json"; id = "JsonPath" }) - "add_key") - [ path; S.const_string label.label_name ] - No_attr - in - (path, Some label) + (fun cases -> + let cases = cases @ [ (S.pany, S.panic) ] in + S.match_ exp cases) + (Lst.mapi multi (fun i -> + fun { constr_name; constr_args; _ } -> + let constr_name = constr_name.name in + let args = Option.value ~default:[] constr_args in + let action = + S.constr_label constr_name + (Lst.map args (fun arg -> + ( arbitrary_of_typ + ~msg: + (Stdlib.String.concat "" + [ + "derive(Arbitrary) for constructor "; + constr_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + arg.cparam_typ, + arg.cparam_label ))) in - let typ = cparam.cparam_typ in - ( S.annotation - (from_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(FromJson) for constructor "; - constr_name; - " of type "; - decl.tycon; - ]) - typ (S.var var) updated_path) - typ, - label_opt )) - |> S.constr_label constr_name - in - (S.pmap pattern, expr)) - in - List.append map_cases [err_case] |> S.match_ json + (S.const_uint_pat (string_of_int i), action)))) | Ptd_record fields -> - let vars = Lst.map fields (fun _ -> fresh_name "field") in - let pattern = - Lst.map2 fields vars (fun field var -> - let field_name = field.field_name.label in - let match_absent = S.is_option field in - Syntax.Map_pat_elem - { - key = - Const_string - { string_val = field_name; string_repr = field_name }; - pat = S.pvar var; - match_absent; - key_loc_ = ghost_loc_; - loc_ = ghost_loc_; - }) - in - let expr = - S.record - (Lst.map2 fields vars (fun field var -> - let field_name = field.field_name.label in - let updated_path = - S.apply - (S.method_ - (Ldot { pkg = "json"; id = "JsonPath" }) - "add_key") - [ path; S.const_string field_name ] - No_attr - in - let typ = field.field_ty in - let field_expr = - if S.is_option field then - S.match_ (S.var var) - [ - ( S.pconstr "Some" [ (None, S.pvar "v") ], - S.annotation - (S.constr "Some" - [ - from_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(FromJson) for field "; - field_name; - " of type "; - decl.tycon; - ]) - typ (S.var "v") updated_path; - ]) - typ ); - (S.pconstr "None" [], S.constr "None" []); - ] - else - S.annotation - (from_json_of_typ - ~msg: - (Stdlib.String.concat "" - [ - "derive(FromJson) for field "; - field_name; - " of type "; - decl.tycon; - ]) - typ (S.var var) updated_path) - typ - in - (field_name, field_expr))) - in - let map_cases = (S.pmap pattern, expr) in - [ map_cases; err_case ] |> S.match_ json + S.record + (Lst.map fields (fun field -> + let field_name = field.field_name.label in + ( field_name, + arbitrary_of_typ + ~msg: + (Stdlib.String.concat "" + [ + "derive(Arbitrary) for field "; + field_name; + " of type "; + decl.tycon; + ] [@merlin.hide]) + field.field_ty ))) | Ptd_alias _ -> S.hole) | _ -> assert false @@ -1428,10 +2384,10 @@ let derivers : (string * deriver) list Type_path.Hash.t = [ ("output", deny_all_derive_args_then derive_show) ] ); ( Type_path.Builtin.trait_hash, [ ("hash_combine", deny_all_derive_args_then derive_hash) ] ); + ( Type_path.toplevel_type ~pkg:"moonbitlang/core/json" "FromJson", + [ ("from_json", derive_from_json) ] ); ( Type_path.toplevel_type ~pkg:Basic_config.builtin_package "ToJson", - [ ("to_json", deny_all_derive_args_then derive_to_json) ] ); + [ ("to_json", derive_to_json) ] ); ( Type_path.toplevel_type ~pkg:"moonbitlang/core/quickcheck" "Arbitrary", [ ("arbitrary", deny_all_derive_args_then derive_arbitrary) ] ); - ( Type_path.toplevel_type ~pkg:"moonbitlang/core/json" "FromJson", - [ ("from_json", deny_all_derive_args_then derive_from_json) ] ); ] diff --git a/src/attribute.ml b/src/attribute.ml new file mode 100644 index 0000000..b8eba42 --- /dev/null +++ b/src/attribute.ml @@ -0,0 +1,74 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +type attr_id = { qual : string option; name : string } + +let string_of_id = function + | { qual = None; name } -> name + | { qual = Some qual; name } -> qual ^ "." ^ name + +let sexp_of_attr_id id = S.Atom (string_of_id id) + +type attr_expr = + | Ident of attr_id + | String of Lex_literal.string_literal + | Apply of attr_id * attr_prop list + +and attr_prop = Labeled of string * attr_expr | Expr of attr_expr + +include struct + let _ = fun (_ : attr_expr) -> () + let _ = fun (_ : attr_prop) -> () + + let rec sexp_of_attr_expr = + (function + | Ident arg0__001_ -> + let res0__002_ = sexp_of_attr_id arg0__001_ in + S.List [ S.Atom "Ident"; res0__002_ ] + | String arg0__003_ -> + let res0__004_ = Lex_literal.sexp_of_string_literal arg0__003_ in + S.List [ S.Atom "String"; res0__004_ ] + | Apply (arg0__005_, arg1__006_) -> + let res0__007_ = sexp_of_attr_id arg0__005_ + and res1__008_ = + Moon_sexp_conv.sexp_of_list sexp_of_attr_prop arg1__006_ + in + S.List [ S.Atom "Apply"; res0__007_; res1__008_ ] + : attr_expr -> S.t) + + and sexp_of_attr_prop = + (function + | Labeled (arg0__009_, arg1__010_) -> + let res0__011_ = Moon_sexp_conv.sexp_of_string arg0__009_ + and res1__012_ = sexp_of_attr_expr arg1__010_ in + S.List [ S.Atom "Labeled"; res0__011_; res1__012_ ] + | Expr arg0__013_ -> + let res0__014_ = sexp_of_attr_expr arg0__013_ in + S.List [ S.Atom "Expr"; res0__014_ ] + : attr_prop -> S.t) + + let _ = sexp_of_attr_expr + and _ = sexp_of_attr_prop +end + +type t = { loc_ : Rloc.t; raw : string; parsed : attr_expr option } + +let sexp_of_t { loc_; raw; parsed } = + let loc_sexp = + if !Basic_config.show_loc then [ Rloc.sexp_of_t loc_ ] else [] + in + match parsed with + | None -> S.List (List.append loc_sexp [ S.Atom raw ]) + | Some expr -> S.List (List.append loc_sexp [ sexp_of_attr_expr expr ]) diff --git a/src/attribute_parser.ml b/src/attribute_parser.ml new file mode 100644 index 0000000..0a12c97 --- /dev/null +++ b/src/attribute_parser.ml @@ -0,0 +1,621 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module MenhirBasics = struct + exception Error + + let _eRR _s = raise Error + + type token = Lex_menhir_token.token +end + +include MenhirBasics + +type ('s, 'r) _menhir_state = + | MenhirState00 : ('s, _menhir_box_attribute) _menhir_state + | MenhirState02 : + ( ('s, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_state + | MenhirState03 : + ( ('s, _menhir_box_attribute) _menhir_cell1_LPAREN, + _menhir_box_attribute ) + _menhir_state + | MenhirState05 : + ( ('s, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_state + | MenhirState06 : + ( ( ('s, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_cell1_EQUAL, + _menhir_box_attribute ) + _menhir_state + | MenhirState08 : + ( ( ('s, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_cell1_DOT_LIDENT, + _menhir_box_attribute ) + _menhir_state + | MenhirState12 : + ( ('s, _menhir_box_attribute) _menhir_cell1_property, + _menhir_box_attribute ) + _menhir_state + +and ('s, 'r) _menhir_cell1_property = + | MenhirCell1_property of 's * ('s, 'r) _menhir_state * Attribute.attr_prop + +and ('s, 'r) _menhir_cell1_DOT_LIDENT = + | MenhirCell1_DOT_LIDENT of 's * ('s, 'r) _menhir_state * string + +and ('s, 'r) _menhir_cell1_EQUAL = + | MenhirCell1_EQUAL of 's * ('s, 'r) _menhir_state + +and ('s, 'r) _menhir_cell1_LIDENT = + | MenhirCell1_LIDENT of 's * ('s, 'r) _menhir_state * string + +and ('s, 'r) _menhir_cell1_LPAREN = + | MenhirCell1_LPAREN of 's * ('s, 'r) _menhir_state + +and _menhir_box_attribute = MenhirBox_attribute of Attribute.attr_expr +[@@unboxed] + +let _menhir_action_01 _1 = (_1 : Attribute.attr_expr) + +let _menhir_action_02 name = + (Attribute.Ident { qual = None; name } : Attribute.attr_expr) + +let _menhir_action_03 name qual = + (Attribute.Ident { qual = Some qual; name } : Attribute.attr_expr) + +let _menhir_action_04 name props = + (Apply ({ qual = None; name }, props) : Attribute.attr_expr) + +let _menhir_action_05 name props qual = + (Apply ({ qual = Some qual; name }, props) : Attribute.attr_expr) + +let _menhir_action_06 _1 = (String _1 : Attribute.attr_expr) +let _menhir_action_07 _1 = ([ _1 ] : Attribute.attr_prop list) +let _menhir_action_08 x xs = (x :: xs : Attribute.attr_prop list) +let _menhir_action_09 () = ([] : Attribute.attr_prop list) +let _menhir_action_10 _2 = (_2 : Attribute.attr_prop list) + +let _menhir_action_11 _3 name = + (Attribute.Labeled (name, _3) : Attribute.attr_prop) + +let _menhir_action_12 _1 = (Attribute.Expr _1 : Attribute.attr_prop) + +let _menhir_print_token : token -> string = + fun _tok -> + match _tok with + | Lex_menhir_token.AMPER -> "AMPER" + | Lex_menhir_token.AMPERAMPER -> "AMPERAMPER" + | Lex_menhir_token.AS -> "AS" + | Lex_menhir_token.ASYNC -> "ASYNC" + | Lex_menhir_token.ATTRIBUTE _ -> "ATTRIBUTE" + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ -> "AUGMENTED_ASSIGNMENT" + | Lex_menhir_token.BAR -> "BAR" + | Lex_menhir_token.BARBAR -> "BARBAR" + | Lex_menhir_token.BREAK -> "BREAK" + | Lex_menhir_token.BYTE _ -> "BYTE" + | Lex_menhir_token.BYTES _ -> "BYTES" + | Lex_menhir_token.CARET -> "CARET" + | Lex_menhir_token.CATCH -> "CATCH" + | Lex_menhir_token.CHAR _ -> "CHAR" + | Lex_menhir_token.COLON -> "COLON" + | Lex_menhir_token.COLONCOLON -> "COLONCOLON" + | Lex_menhir_token.COMMA -> "COMMA" + | Lex_menhir_token.COMMENT _ -> "COMMENT" + | Lex_menhir_token.CONST -> "CONST" + | Lex_menhir_token.CONTINUE -> "CONTINUE" + | Lex_menhir_token.DERIVE -> "DERIVE" + | Lex_menhir_token.DOTDOT -> "DOTDOT" + | Lex_menhir_token.DOT_INT _ -> "DOT_INT" + | Lex_menhir_token.DOT_LIDENT _ -> "DOT_LIDENT" + | Lex_menhir_token.DOT_UIDENT _ -> "DOT_UIDENT" + | Lex_menhir_token.ELLIPSIS -> "ELLIPSIS" + | Lex_menhir_token.ELSE -> "ELSE" + | Lex_menhir_token.ENUM -> "ENUM" + | Lex_menhir_token.EOF -> "EOF" + | Lex_menhir_token.EQUAL -> "EQUAL" + | Lex_menhir_token.EXCLAMATION -> "EXCLAMATION" + | Lex_menhir_token.EXTERN -> "EXTERN" + | Lex_menhir_token.FALSE -> "FALSE" + | Lex_menhir_token.FAT_ARROW -> "FAT_ARROW" + | Lex_menhir_token.FLOAT _ -> "FLOAT" + | Lex_menhir_token.FN -> "FN" + | Lex_menhir_token.FOR -> "FOR" + | Lex_menhir_token.GUARD -> "GUARD" + | Lex_menhir_token.IF -> "IF" + | Lex_menhir_token.IMPL -> "IMPL" + | Lex_menhir_token.IMPORT -> "IMPORT" + | Lex_menhir_token.IN -> "IN" + | Lex_menhir_token.INFIX1 _ -> "INFIX1" + | Lex_menhir_token.INFIX2 _ -> "INFIX2" + | Lex_menhir_token.INFIX3 _ -> "INFIX3" + | Lex_menhir_token.INFIX4 _ -> "INFIX4" + | Lex_menhir_token.INT _ -> "INT" + | Lex_menhir_token.INTERP _ -> "INTERP" + | Lex_menhir_token.IS -> "IS" + | Lex_menhir_token.LBRACE -> "LBRACE" + | Lex_menhir_token.LBRACKET -> "LBRACKET" + | Lex_menhir_token.LET -> "LET" + | Lex_menhir_token.LIDENT _ -> "LIDENT" + | Lex_menhir_token.LOOP -> "LOOP" + | Lex_menhir_token.LPAREN -> "LPAREN" + | Lex_menhir_token.MATCH -> "MATCH" + | Lex_menhir_token.MINUS -> "MINUS" + | Lex_menhir_token.MULTILINE_INTERP _ -> "MULTILINE_INTERP" + | Lex_menhir_token.MULTILINE_STRING _ -> "MULTILINE_STRING" + | Lex_menhir_token.MUTABLE -> "MUTABLE" + | Lex_menhir_token.NEWLINE -> "NEWLINE" + | Lex_menhir_token.PACKAGE_NAME _ -> "PACKAGE_NAME" + | Lex_menhir_token.PIPE -> "PIPE" + | Lex_menhir_token.PLUS -> "PLUS" + | Lex_menhir_token.POST_LABEL _ -> "POST_LABEL" + | Lex_menhir_token.PRIV -> "PRIV" + | Lex_menhir_token.PUB -> "PUB" + | Lex_menhir_token.QUESTION -> "QUESTION" + | Lex_menhir_token.RAISE -> "RAISE" + | Lex_menhir_token.RANGE_EXCLUSIVE -> "RANGE_EXCLUSIVE" + | Lex_menhir_token.RANGE_INCLUSIVE -> "RANGE_INCLUSIVE" + | Lex_menhir_token.RBRACE -> "RBRACE" + | Lex_menhir_token.RBRACKET -> "RBRACKET" + | Lex_menhir_token.READONLY -> "READONLY" + | Lex_menhir_token.RETURN -> "RETURN" + | Lex_menhir_token.RPAREN -> "RPAREN" + | Lex_menhir_token.SEMI _ -> "SEMI" + | Lex_menhir_token.STRING _ -> "STRING" + | Lex_menhir_token.STRUCT -> "STRUCT" + | Lex_menhir_token.TEST -> "TEST" + | Lex_menhir_token.THIN_ARROW -> "THIN_ARROW" + | Lex_menhir_token.THROW -> "THROW" + | Lex_menhir_token.TRAIT -> "TRAIT" + | Lex_menhir_token.TRAITALIAS -> "TRAITALIAS" + | Lex_menhir_token.TRUE -> "TRUE" + | Lex_menhir_token.TRY -> "TRY" + | Lex_menhir_token.TYPE -> "TYPE" + | Lex_menhir_token.TYPEALIAS -> "TYPEALIAS" + | Lex_menhir_token.UIDENT _ -> "UIDENT" + | Lex_menhir_token.UNDERSCORE -> "UNDERSCORE" + | Lex_menhir_token.WHILE -> "WHILE" + | Lex_menhir_token.WITH -> "WITH" + +let _menhir_fail : unit -> 'a = + fun () -> + Printf.eprintf + "Internal failure -- please contact the parser generator's developers.\n%!"; + assert false + +include struct + [@@@ocaml.warning "-4-37-39"] + + let rec _menhir_run_17 : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_attribute = + fun _menhir_stack -> + fun _v -> + fun _tok -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EOF -> + let _1 = _v in + let _v = _menhir_action_01 _1 in + MenhirBox_attribute _v + | _ -> _eRR () + + let rec _menhir_run_01 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + let _tok = _menhir_lexer _menhir_lexbuf in + let _1 = _v in + let _v = _menhir_action_06 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + and _menhir_goto_expr : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + match _menhir_s with + | MenhirState00 -> _menhir_run_17 _menhir_stack _v _tok + | MenhirState03 -> + _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | MenhirState12 -> + _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | MenhirState06 -> + _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + | _ -> _menhir_fail () + + and _menhir_run_14 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + let _1 = _v in + let _v = _menhir_action_12 _1 in + _menhir_goto_property _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + and _menhir_goto_property : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_property (_menhir_stack, _menhir_s, _v) + in + let _menhir_s = MenhirState12 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s + | Lex_menhir_token.LIDENT _v -> + _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _1 = _v in + let _v = _menhir_action_07 _1 in + _menhir_goto_non_empty_properties _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s + | _ -> _eRR () + + and _menhir_run_05 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v) + in + _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState05 + | Lex_menhir_token.EQUAL -> ( + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_EQUAL (_menhir_stack, MenhirState05) + in + let _menhir_s = MenhirState06 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s + | Lex_menhir_token.LIDENT _v -> + _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s + | _ -> _eRR ()) + | Lex_menhir_token.DOT_LIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v) + in + _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState05 + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let name = _v in + let _v = _menhir_action_02 name in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | _ -> _eRR () + + and _menhir_run_03 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s) in + _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState03 + | Lex_menhir_token.RPAREN -> + let _tok = _menhir_lexer _menhir_lexbuf in + let _v = _menhir_action_09 () in + _menhir_goto_properties _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | Lex_menhir_token.LIDENT _v -> + let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s) in + _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState03 + | _ -> _eRR () + + and _menhir_goto_properties : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + match _menhir_s with + | MenhirState02 -> + _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + | MenhirState05 -> + _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + | MenhirState08 -> + _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + | _ -> _menhir_fail () + + and _menhir_run_10 : type ttv_stack. + (ttv_stack, _menhir_box_attribute) _menhir_cell1_LIDENT -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + let (MenhirCell1_LIDENT (_menhir_stack, _menhir_s, name)) = + _menhir_stack + in + let props = _v in + let _v = _menhir_action_04 name props in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + and _menhir_run_09 : type ttv_stack. + ( (ttv_stack, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_cell1_DOT_LIDENT -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + let (MenhirCell1_DOT_LIDENT (_menhir_stack, _, name)) = _menhir_stack in + let (MenhirCell1_LIDENT (_menhir_stack, _menhir_s, qual)) = + _menhir_stack + in + let props = _v in + let _v = _menhir_action_05 name props qual in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + and _menhir_run_02 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v) + in + _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState02 + | Lex_menhir_token.DOT_LIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v) + in + _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState02 + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.RPAREN -> + let name = _v in + let _v = _menhir_action_02 name in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | _ -> _eRR () + + and _menhir_run_08 : type ttv_stack. + ((ttv_stack, _menhir_box_attribute) _menhir_cell1_LIDENT as 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_DOT_LIDENT (_menhir_stack, _menhir_s, _v) + in + _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState08 + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.RPAREN -> + let (MenhirCell1_LIDENT (_menhir_stack, _menhir_s, qual)) = + _menhir_stack + in + let name = _v in + let _v = _menhir_action_03 name qual in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + | _ -> _eRR () + + and _menhir_goto_non_empty_properties : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_attribute) _menhir_state -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + match _menhir_s with + | MenhirState03 -> + _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v + | MenhirState12 -> + _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v + | _ -> _menhir_fail () + + and _menhir_run_15 : type ttv_stack. + (ttv_stack, _menhir_box_attribute) _menhir_cell1_LPAREN -> + _ -> + _ -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s)) = _menhir_stack in + let _2 = _v in + let _v = _menhir_action_10 _2 in + _menhir_goto_properties _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + and _menhir_run_13 : type ttv_stack. + (ttv_stack, _menhir_box_attribute) _menhir_cell1_property -> + _ -> + _ -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + let (MenhirCell1_property (_menhir_stack, _menhir_s, x)) = + _menhir_stack + in + let xs = _v in + let _v = _menhir_action_08 x xs in + _menhir_goto_non_empty_properties _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s + + and _menhir_run_07 : type ttv_stack. + ( (ttv_stack, _menhir_box_attribute) _menhir_cell1_LIDENT, + _menhir_box_attribute ) + _menhir_cell1_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + let (MenhirCell1_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT (_menhir_stack, _menhir_s, name)) = + _menhir_stack + in + let _3 = _v in + let _v = _menhir_action_11 _3 name in + _menhir_goto_property _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok + + let rec _menhir_run_00 : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_attribute = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + let _menhir_s = MenhirState00 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s + | Lex_menhir_token.LIDENT _v -> + _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s + | _ -> _eRR () +end + +let attribute _menhir_lexer _menhir_lexbuf = + let _menhir_stack = () in + let (MenhirBox_attribute v) = + _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer + in + v diff --git a/src/basic_arr.ml b/src/basic_arr.ml index 81b8760..483e592 100644 --- a/src/basic_arr.ml +++ b/src/basic_arr.ml @@ -76,7 +76,7 @@ let range from to_ = let map2i f a b = let len = Array.length a in if len <> Array.length b then invalid_arg __FUNCTION__ - else Array.mapi (fun i a -> f i a b.!(i)) a + else Array.mapi (fun i -> fun a -> f i a b.!(i)) a let rec tolist_f_aux a f i res = if i < 0 then res @@ -225,11 +225,12 @@ let find_with_index arr cmp v = in aux 0 len -let find_and_split arr cmp v : _ split = - let i = find_with_index arr cmp v in - if i < 0 then No_split - else - Split (Array.sub arr 0 i, Array.sub arr (i + 1) (Array.length arr - i - 1)) +let find_and_split arr cmp v = + (let i = find_with_index arr cmp v in + if i < 0 then No_split + else + Split (Array.sub arr 0 i, Array.sub arr (i + 1) (Array.length arr - i - 1)) + : _ split) let exists a p = let n = Array.length a in diff --git a/src/basic_binary_search.ml b/src/basic_binary_search.ml index 41e6b41..a12c5df 100644 --- a/src/basic_binary_search.ml +++ b/src/basic_binary_search.ml @@ -15,15 +15,40 @@ open Basic_unsafe_external -let search_range (x : int) (a : int array) : int = - let rec go lower_bound upper_bound = - if lower_bound > upper_bound then -1 - else - let m = lower_bound + ((upper_bound - lower_bound) / 2) in - let x0 = a.!(2 * m) in - let x1 = a.!((2 * m) + 1) in - if x < x0 then go lower_bound (m - 1) - else if x > x1 then go (m + 1) upper_bound - else m - in - go 0 ((Array.length a / 2) - 1) +let search_range (x : int) (a : int array) = + (let rec go lower_bound upper_bound = + if lower_bound > upper_bound then -1 + else + let m = lower_bound + ((upper_bound - lower_bound) / 2) in + let x0 = a.!(2 * m) in + let x1 = a.!((2 * m) + 1) in + if x < x0 then go lower_bound (m - 1) + else if x > x1 then go (m + 1) upper_bound + else m + in + go 0 ((Array.length a / 2) - 1) + : int) + +type binary_search_result = Found of int | Insert_at of int + +let binary_search_by (cmp : 'a -> int) (arr : 'a array) = + (let rec aux lo sz = + if sz <= 1 then lo + else + let half = sz / 2 in + let mid = lo + half in + let new_sz = sz - half in + let new_lo = if cmp arr.!(mid) > 0 then lo else mid in + aux new_lo new_sz + in + let pp = aux 0 (Array.length arr) in + let cmp_pp = cmp arr.!(pp) in + if cmp_pp = 0 then Found pp + else Insert_at (if cmp_pp > 0 then pp else pp + 1) + : binary_search_result) + +let binary_search cmp arr v = binary_search_by (fun x -> cmp x v) arr + +let partition_point (pred : 'a -> bool) (arr : 'a array) = + let res = binary_search_by (fun x -> if pred x then -1 else 1) arr in + match res with Found i | Insert_at i -> i diff --git a/src/basic_case_set_intf.ml b/src/basic_case_set_intf.ml index 2d0aa49..5bce0e6 100644 --- a/src/basic_case_set_intf.ml +++ b/src/basic_case_set_intf.ml @@ -14,8 +14,8 @@ type 'a static_matching_result = - | For_sure_yes of { ok_db : 'a } - | For_sure_no of { fail_db : 'a } + | For_sure_yes + | For_sure_no | Uncertain of { ok_db : 'a; fail_db : 'a } module type CASE_SET = sig diff --git a/src/basic_compress_stamp.ml b/src/basic_compress_stamp.ml index 23b3970..28f728c 100644 --- a/src/basic_compress_stamp.ml +++ b/src/basic_compress_stamp.ml @@ -28,41 +28,43 @@ let basename_without_stamp s = in aux ubound s -let normalize ?global_stamps (impl_sexp : S.t) : S.t = - let tbl = Hashtbl.create 20 in - let rec mapper = function - | S.List xs -> S.List (List.map mapper xs) - | S.Atom s -> - let s = - match basename_without_stamp s with - | None -> s - | Local base_name -> ( - match Hashtbl.find_opt tbl s with - | Some n -> n - | None -> - let new_name = - base_name ^ "/" ^ Int.to_string (Hashtbl.length tbl) - in - Hashtbl.add tbl s new_name; - new_name) - | Global base_name -> ( - match global_stamps with - | None -> - failwith - ("ident '" ^ s - ^ "' occured but global_stamps is not provided" - : Stdlib.String.t) - | Some global_stamps -> ( - match Hashtbl.find_opt global_stamps s with - | Some n -> n - | None -> - let new_name = - base_name ^ "|" - ^ Int.to_string (Hashtbl.length global_stamps) - in - Hashtbl.add global_stamps s new_name; - new_name)) - in - S.Atom s - in - mapper impl_sexp +let normalize ?global_stamps (impl_sexp : S.t) = + (let tbl = Hashtbl.create 20 in + let rec mapper = function + | S.List xs -> S.List (Basic_lst.map xs mapper) + | S.Atom s -> + let s = + match basename_without_stamp s with + | None -> s + | Local base_name -> ( + match Hashtbl.find_opt tbl s with + | Some n -> n + | None -> + let new_name = + base_name ^ "/" ^ Int.to_string (Hashtbl.length tbl) + in + Hashtbl.add tbl s new_name; + new_name) + | Global base_name -> ( + match global_stamps with + | None -> + failwith + (("ident '" ^ s + ^ "' occured but global_stamps is not provided" + : Stdlib.String.t) + [@merlin.hide]) + | Some global_stamps -> ( + match Hashtbl.find_opt global_stamps s with + | Some n -> n + | None -> + let new_name = + base_name ^ "|" + ^ Int.to_string (Hashtbl.length global_stamps) + in + Hashtbl.add global_stamps s new_name; + new_name)) + in + S.Atom s + in + mapper impl_sexp + : S.t) diff --git a/src/basic_config.ml b/src/basic_config.ml index 27f5d06..0dc092a 100644 --- a/src/basic_config.ml +++ b/src/basic_config.ml @@ -62,12 +62,16 @@ let current_package = ref default_package_name let current_import_map : string Basic_map_string.t ref = ref Map_string.empty let builtin_package = "moonbitlang/core/builtin" let debug = ref false +let no_opt = ref false let use_block_params = ref true let test_mode = ref false let std_path = ref "" let export_memory_name : string option ref = ref None let import_memory_module : string option ref = ref None let import_memory_name : string option ref = ref None +let memory_limits_min : int option ref = ref None +let memory_limits_max : int option ref = ref None +let shared_memory : bool ref = ref false let heap_memory_start = ref 10_000 let target = ref Wasm_gc let js_format = ref Esm @@ -75,11 +79,33 @@ let error_format = ref Human let leak_check = ref false let memory_safety_check = ref false let use_js_builtin_string = ref false -let blackbox_test_import_all = ref false +let blackbox_test_import_all_default = true +let blackbox_test_import_all = ref blackbox_test_import_all_default let const_string_module_name = ref "_" +type parser_select = [ `Menhir | `Handrolled | `Both ] + +let parser : parser_select ref = ref `Both let verbose = ref false +let parse_symbol_exn s = + parser := + match s with + | "yacc" -> `Menhir + | "hand" -> `Handrolled + | "both" -> `Both + | _ -> assert false + +let current_parser () = !parser +let symbols = [ "yacc"; "hand"; "both" ] + +let current_parser_display () = + match !parser with + | `Menhir -> "yacc" + | `Handrolled -> "hand" + | `Both -> "both" + type env = Release | Debug + let env = Release let block_line = "///|" diff --git a/src/basic_constr_info.ml b/src/basic_constr_info.ml index 3df0b3c..eb57587 100644 --- a/src/basic_constr_info.ml +++ b/src/basic_constr_info.ml @@ -13,18 +13,22 @@ *) +module Index_set = Basic_diet.Make (Int) + +type constr_repr = Non_constant | Constant | Integer of int + type constr_tag = | Constr_tag_regular of { - total : int; [@ceh.ignore] + total : Index_set.t; [@ceh.ignore] index : int; - is_constant_ : bool; [@ceh.ignore] + repr_ : constr_repr; [@ceh.ignore] name_ : string; [@ceh.ignore] } | Extensible_tag of { pkg : string; type_name : string; name : string; - total : int; [@ceh.ignore] + total : Index_set.t; [@ceh.ignore] index : int; [@ceh.ignore] } @@ -81,7 +85,7 @@ end let sexp_of_constr_tag (tag : constr_tag) = match tag with - | Constr_tag_regular { name_; total = _; index = _; is_constant_ = _ } -> + | Constr_tag_regular { name_; total = _; index = _; repr_ = _ } -> (List (List.cons (Atom "Constr_tag_regular" : S.t) diff --git a/src/basic_core_ident.ml b/src/basic_core_ident.ml index b842c4f..31686ed 100644 --- a/src/basic_core_ident.ml +++ b/src/basic_core_ident.ml @@ -92,45 +92,51 @@ module Key = struct let to_string (x : t) = match x with | Pident { name; stamp } -> - (name ^ "/" ^ Int.to_string stamp : Stdlib.String.t) + (name ^ "/" ^ Int.to_string stamp : Stdlib.String.t) [@merlin.hide] | Pmutable_ident { name; stamp } -> - (name ^ "!" ^ Int.to_string stamp : Stdlib.String.t) + (name ^ "!" ^ Int.to_string stamp : Stdlib.String.t) [@merlin.hide] | Pdot q -> Qual_ident.string_of_t q | Plocal_method { index = _; name_; trait; method_name } -> let trait_str = Type_path.short_name ~cur_pkg_name:None trait in - Stdlib.String.concat "" - [ trait_str; "::"; method_name; "|"; name_; "|" ] + (Stdlib.String.concat "" + [ trait_str; "::"; method_name; "|"; name_; "|" ] [@merlin.hide]) - let sexp_of_t (x : t) : S.t = Atom (to_string x) + let sexp_of_t (x : t) = (Atom (to_string x) : S.t) end include Key -let of_ident (x : Ident.t) : t = - match x with - | Pdot qual_name -> Pdot qual_name - | Plocal_method local_method -> Plocal_method local_method - | Pident { stamp; name; _ } -> Pident { stamp; name } - | Pdyntrait_method _ -> assert false +let of_ident (x : Ident.t) = + (match x with + | Pdot qual_name -> Pdot qual_name + | Plocal_method local_method -> Plocal_method local_method + | Pident { stamp; name; _ } -> Pident { stamp; name } + | Pdyntrait_method _ -> assert false + : t) let of_local_method ~index ~tvar_name ~trait method_name = Plocal_method { index; name_ = tvar_name; trait; method_name } -let of_qual_ident (x : Qual_ident.t) : t = Pdot x +let of_qual_ident (x : Qual_ident.t) = (Pdot x : t) let as_export_name (x : t) = match x with - | Pident _ | Pmutable_ident _ | Plocal_method _ -> assert false + | Pmutable_ident _ -> assert false + | Pident _ -> assert false + | Plocal_method _ -> assert false | Pdot (Qregular { pkg; name }) | Pdot (Qregular_implicit_pkg { pkg; name }) -> ( - match pkg with "" -> name | _ -> (pkg ^ "::" ^ name : Stdlib.String.t)) + match pkg with + | "" -> name + | _ -> (pkg ^ "::" ^ name : Stdlib.String.t) [@merlin.hide]) | Pdot (Qmethod { self_typ; name }) -> let typ_str = Type_path.short_name ~cur_pkg_name:None self_typ in - (typ_str ^ "::" ^ name : Stdlib.String.t) + ((typ_str ^ "::" ^ name : Stdlib.String.t) [@merlin.hide]) | Pdot (Qext_method { trait; self_typ; name }) -> let trait_str = Type_path.short_name ~cur_pkg_name:None trait in let typ_str = Type_path.short_name ~cur_pkg_name:None self_typ in - Stdlib.String.concat "" [ trait_str; "::"; typ_str; "::"; name ] + (Stdlib.String.concat "" + [ trait_str; "::"; typ_str; "::"; name ] [@merlin.hide]) let is_foreign (x : t) = match x with @@ -142,7 +148,7 @@ let make_global_binder ~name_hint binder = match x with | Pdot _ | Plocal_method _ -> to_string x | Pident { name; stamp } | Pmutable_ident { name; stamp } -> - (name ^ "|" ^ Int.to_string stamp : Stdlib.String.t) + (name ^ "|" ^ Int.to_string stamp : Stdlib.String.t) [@merlin.hide] in of_qual_ident (Basic_qual_ident.make @@ -193,33 +199,35 @@ module Map = struct let bal = Map_gen.bal let height = Map_gen.height - let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - - let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) + let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + + let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -255,77 +263,79 @@ module Map = struct let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x - let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) + let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } - let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - - let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) + let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + + let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -336,10 +346,12 @@ module Map = struct (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty - let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) + + let of_array xs = + Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) end module Set = struct @@ -383,111 +395,134 @@ module Set = struct let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] - let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> - No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> - No { result with l = Set_gen.internal_join l v result.l }) - - let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - - let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - - let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - - let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - - let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) + let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + + let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + + let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + + let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + + let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + + let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + + let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -505,8 +540,8 @@ module Set = struct Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t - let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params + let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) @@ -548,6 +583,7 @@ module Hash = struct let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array + let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -560,26 +596,28 @@ module Hash = struct if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -619,22 +657,24 @@ module Hash = struct Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) - let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) + let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -643,6 +683,7 @@ module Hash = struct | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -673,13 +714,13 @@ module Hash = struct let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -687,7 +728,7 @@ module Hash = struct let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = @@ -744,29 +785,31 @@ module Hashset = struct done; tbl - let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - - let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then - Hashset_gen.resize key_index h; - key + let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + + let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/basic_diet.ml b/src/basic_diet.ml index a98f2c7..ae2c404 100644 --- a/src/basic_diet.ml +++ b/src/basic_diet.ml @@ -62,33 +62,34 @@ module Make (Elt : Diet_intf.ELT) = struct let x, y, l' = splitMax l in bal x y l' r - let rec removeAux (t : t) ~lo ~hi : t = - match t with - | Empty -> Empty - | Node n -> - if hi <~ n.x then - let l = removeAux ~lo ~hi n.l in - bal n.x n.y l n.r - else if n.y <~ lo then - let r = removeAux ~lo ~hi n.r in - bal n.x n.y n.l r - else if lo <~ n.x && hi <~ n.y then - let n' = bal (Elt.succ hi) n.y n.l n.r in - removeAux ~lo ~hi:(Elt.pred n.x) n' - else if hi >~ n.y && lo >~ n.x then - let n' = bal n.x (Elt.pred lo) n.l n.r in - removeAux ~lo:(Elt.succ n.y) ~hi n' - else if lo <=~ n.x && hi >=~ n.y then - let l = removeAux ~lo ~hi:n.x n.l in - let r = removeAux ~lo:n.y ~hi n.r in - merge l r - else if Elt.equal hi n.y then bal n.x (Elt.pred lo) n.l n.r - else if Elt.equal lo n.x then bal (Elt.succ hi) n.y n.l n.r - else ( - assert (n.x <~ lo); - assert (hi <~ n.y); - let r = bal (Elt.succ hi) n.y Empty n.r in - bal n.x (Elt.pred lo) n.l r) + let rec removeAux (t : t) ~lo ~hi = + (match t with + | Empty -> Empty + | Node n -> + if hi <~ n.x then + let l = removeAux ~lo ~hi n.l in + bal n.x n.y l n.r + else if n.y <~ lo then + let r = removeAux ~lo ~hi n.r in + bal n.x n.y n.l r + else if lo <~ n.x && hi <~ n.y then + let n' = bal (Elt.succ hi) n.y n.l n.r in + removeAux ~lo ~hi:(Elt.pred n.x) n' + else if hi >~ n.y && lo >~ n.x then + let n' = bal n.x (Elt.pred lo) n.l n.r in + removeAux ~lo:(Elt.succ n.y) ~hi n' + else if lo <=~ n.x && hi >=~ n.y then + let l = removeAux ~lo ~hi:n.x n.l in + let r = removeAux ~lo:n.y ~hi n.r in + merge l r + else if Elt.equal hi n.y then bal n.x (Elt.pred lo) n.l n.r + else if Elt.equal lo n.x then bal (Elt.succ hi) n.y n.l n.r + else ( + assert (n.x <~ lo); + assert (hi <~ n.y); + let r = bal (Elt.succ hi) n.y Empty n.r in + bal n.x (Elt.pred lo) n.l r) + : t) let diff a b = fold removeAux b a let iter_range = iter_range diff --git a/src/basic_duplicate_check.ml b/src/basic_duplicate_check.ml new file mode 100644 index 0000000..7bb83ff --- /dev/null +++ b/src/basic_duplicate_check.ml @@ -0,0 +1,71 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +let check_duplicate_string_list (l : string list) = + (match l with + | [] -> false + | _ :: [] -> false + | [ x0; x1 ] -> x0 = x1 + | [ x0; x1; x2 ] -> x0 = x1 || x0 = x2 || x1 = x2 + | [ x0; x1; x2; x3 ] -> + x0 = x1 || x0 = x2 || x0 = x3 || x1 = x2 || x1 = x3 || x2 = x3 + | _ -> + let rec aux flag container = function + | [] -> !flag + | x :: rest -> + let container = + Basic_set_string.check_add container ~duplicate_flag:flag x + in + !flag || aux flag container rest + in + aux (ref false) Basic_set_string.empty l + : bool) + +let check_duplicate_by (l : 'a list) (f : 'a -> string) = + (match l with + | [] -> None + | _ :: [] -> None + | [ x0; x1 ] -> + let a0 = f x0 in + let a1 = f x1 in + if a0 = a1 then Some x1 else None + | [ x0; x1; x2 ] -> + let a0 = f x0 in + let a1 = f x1 in + if a0 = a1 then Some x1 + else + let a2 = f x2 in + if a0 = a2 || a1 = a2 then Some x2 else None + | [ x0; x1; x2; x3 ] -> + let a0 = f x0 in + let a1 = f x1 in + if a0 = a1 then Some x1 + else + let a2 = f x2 in + if a0 = a2 || a1 = a2 then Some x2 + else + let a3 = f x3 in + if a0 = a3 || a1 = a3 || a2 = a3 then Some x3 else None + | _ -> + let rec aux flag container = function + | [] -> None + | x :: rest -> + let container = + Basic_set_string.check_add container ~duplicate_flag:flag (f x) + in + if !flag then Some x else aux flag container rest + in + aux (ref false) Basic_set_string.empty l + : 'a option) diff --git a/src/basic_encoders.ml b/src/basic_encoders.ml index e2621af..8dd68bb 100644 --- a/src/basic_encoders.ml +++ b/src/basic_encoders.ml @@ -33,76 +33,81 @@ let float32_le x = of_buffer_add Buffer.add_int32_le (Int32.bits_of_float x) let int_sleb128 x = of_buffer_add - (fun b x -> - let rec aux x = - let y = x land 0x7f in - if -64 <= x && x < 64 then Buffer.add_uint8 b y - else ( - Buffer.add_uint8 b (y lor 0x80); - aux (x asr 7)) - in - aux x) + (fun b -> + fun x -> + let rec aux x = + let y = x land 0x7f in + if -64 <= x && x < 64 then Buffer.add_uint8 b y + else ( + Buffer.add_uint8 b (y lor 0x80); + aux (x asr 7)) + in + aux x) x let int_uleb128 x = of_buffer_add - (fun b x -> - let rec aux x = - let y = x land 0x7f in - if 0 <= x && x < 128 then Buffer.add_uint8 b y - else ( - Buffer.add_uint8 b (y lor 0x80); - aux (x lsr 7)) - in - aux x) + (fun b -> + fun x -> + let rec aux x = + let y = x land 0x7f in + if 0 <= x && x < 128 then Buffer.add_uint8 b y + else ( + Buffer.add_uint8 b (y lor 0x80); + aux (x lsr 7)) + in + aux x) x let int32_sleb128 x = of_buffer_add - (fun b x -> - let rec aux x = - let y = - let open Int32 in - to_int (logand x 0x7fl) - in - if -64l <= x && x < 64l then Buffer.add_uint8 b y - else ( - Buffer.add_uint8 b (y lor 0x80); - aux (Int32.shift_right x 7)) - in - aux x) + (fun b -> + fun x -> + let rec aux x = + let y = + let open Int32 in + to_int (logand x 0x7fl) + in + if -64l <= x && x < 64l then Buffer.add_uint8 b y + else ( + Buffer.add_uint8 b (y lor 0x80); + aux (Int32.shift_right x 7)) + in + aux x) x let int32_uleb128 x = of_buffer_add - (fun b x -> - let rec aux x = - let y = - let open Int32 in - to_int (logand x 0x7fl) - in - if 0l <= x && x < 128l then Buffer.add_uint8 b y - else ( - Buffer.add_uint8 b (y lor 0x80); - aux (Int32.shift_right_logical x 7)) - in - aux x) + (fun b -> + fun x -> + let rec aux x = + let y = + let open Int32 in + to_int (logand x 0x7fl) + in + if 0l <= x && x < 128l then Buffer.add_uint8 b y + else ( + Buffer.add_uint8 b (y lor 0x80); + aux (Int32.shift_right_logical x 7)) + in + aux x) x let int64_sleb128 x = of_buffer_add - (fun b x -> - let rec aux x = - let y = - let open Int64 in - to_int (logand x 0x7fL) - in - if -64L <= x && x < 64L then Buffer.add_uint8 b y - else ( - Buffer.add_uint8 b (y lor 0x80); - aux (Int64.shift_right x 7)) - in - aux x) + (fun b -> + fun x -> + let rec aux x = + let y = + let open Int64 in + to_int (logand x 0x7fL) + in + if -64L <= x && x < 64L then Buffer.add_uint8 b y + else ( + Buffer.add_uint8 b (y lor 0x80); + aux (Int64.shift_right x 7)) + in + aux x) x let int_vlq64 = of_buffer_add Vlq64.buffer_add_vlq64 diff --git a/src/basic_fn_address.ml b/src/basic_fn_address.ml index 79fd5da..fb7e3da 100644 --- a/src/basic_fn_address.ml +++ b/src/basic_fn_address.ml @@ -24,52 +24,55 @@ module Key = struct let _ = fun (_ : t) -> () let compare = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then 0 - else - match (a__001_, b__002_) with - | Pdot _a__003_, Pdot _b__004_ -> - Qual_ident.compare _a__003_ _b__004_ - | Pdot _, _ -> -1 - | _, Pdot _ -> 1 - | Pident _a__005_, Pident _b__006_ -> ( - match Stdlib.compare (_a__005_.stamp : int) _b__006_.stamp with - | 0 -> Stdlib.compare (_a__005_.name : string) _b__006_.name - | n -> n) + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then 0 + else + match (a__001_, b__002_) with + | Pdot _a__003_, Pdot _b__004_ -> + Qual_ident.compare _a__003_ _b__004_ + | Pdot _, _ -> -1 + | _, Pdot _ -> 1 + | Pident _a__005_, Pident _b__006_ -> ( + match Stdlib.compare (_a__005_.stamp : int) _b__006_.stamp with + | 0 -> Stdlib.compare (_a__005_.name : string) _b__006_.name + | n -> n) : t -> t -> int) let _ = compare let equal = - (fun a__007_ b__008_ -> - if Stdlib.( == ) a__007_ b__008_ then true - else - match (a__007_, b__008_) with - | Pdot _a__009_, Pdot _b__010_ -> Qual_ident.equal _a__009_ _b__010_ - | Pdot _, _ -> false - | _, Pdot _ -> false - | Pident _a__011_, Pident _b__012_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__011_.stamp : int) _b__012_.stamp) - (Stdlib.( = ) (_a__011_.name : string) _b__012_.name) + (fun a__007_ -> + fun b__008_ -> + if Stdlib.( == ) a__007_ b__008_ then true + else + match (a__007_, b__008_) with + | Pdot _a__009_, Pdot _b__010_ -> Qual_ident.equal _a__009_ _b__010_ + | Pdot _, _ -> false + | _, Pdot _ -> false + | Pident _a__011_, Pident _b__012_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__011_.stamp : int) _b__012_.stamp) + (Stdlib.( = ) (_a__011_.name : string) _b__012_.name) : t -> t -> bool) let _ = equal let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Pdot _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = hsv in - Qual_ident.hash_fold_t hsv _a0 - | Pident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - Ppx_base.hash_fold_string hsv _ir.name + (fun hsv -> + fun arg -> + match arg with + | Pdot _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + Qual_ident.hash_fold_t hsv _a0 + | Pident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + Ppx_base.hash_fold_string hsv _ir.name : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -90,7 +93,7 @@ module Key = struct | Pdot qual_name -> Qual_ident.string_of_t qual_name | Pident { name; stamp } -> name ^ "/" ^ Stdlib.string_of_int stamp - let sexp_of_t x : S.t = Atom (to_string x) + let sexp_of_t x = (Atom (to_string x) : S.t) end include Key @@ -109,8 +112,8 @@ let make_closure_wrapper original_fn = match[@warning "-fragile-match"] original_fn with | Pdot qual_name -> Pdot - (Qual_ident.map qual_name ~f:(fun name : Stdlib.String.t -> - name ^ ".dyncall")) + (Qual_ident.map qual_name ~f:(fun name -> + ((name ^ ".dyncall" : Stdlib.String.t) [@merlin.hide]))) | _ -> assert false let make_object_wrapper fn ~trait = @@ -118,8 +121,8 @@ let make_object_wrapper fn ~trait = Type_path.export_name ~cur_pkg_name:!Basic_config.current_package trait in Pdot - (Qual_ident.map fn ~f:(fun name : Stdlib.String.t -> - name ^ ".dyncall_as_" ^ trait_name)) + (Qual_ident.map fn ~f:(fun name -> + (name ^ ".dyncall_as_" ^ trait_name : Stdlib.String.t))) let source_name t = match t with @@ -130,7 +133,9 @@ let to_wasm_name (x : t) = match x with | Pdot qual_name -> Qual_ident.to_wasm_name qual_name | Pident { name; stamp } -> - "$" ^ Strutil.mangle_wasm_name name ^ "/" ^ string_of_int stamp + Stdlib.String.concat "" + [ "$"; Strutil.mangle_wasm_name name; "/"; Int.to_string stamp ] + [@merlin.hide] let init () = incr id; diff --git a/src/basic_hash_gen.ml b/src/basic_hash_gen.ml index c28fa7d..5964646 100644 --- a/src/basic_hash_gen.ml +++ b/src/basic_hash_gen.ml @@ -13,7 +13,7 @@ *) -module Int_util = Basic_int_util +module Int_util = Basic_int module Vec = Basic_vec open Basic_unsafe_external @@ -83,8 +83,8 @@ let iter2 h f = do_bucket d.!(i) done -let iter h f = iter2 h (fun k v -> f (k, v)) [@@inline] -let to_iter h = Basic_iter.make (fun f -> iter2 h (fun k v -> f (k, v))) +let iter h f = iter2 h (fun k -> fun v -> f (k, v)) [@@inline] +let to_iter h = Basic_iter.make (fun f -> iter2 h (fun k -> fun v -> f (k, v))) let fold h init f = let rec do_bucket b accu = @@ -99,8 +99,10 @@ let fold h init f = done; !accu -let to_list_with h f = fold h [] (fun k data acc -> f k data :: acc) -let to_list h = fold h [] (fun k data acc -> (k, data) :: acc) +let to_list_with h f = + fold h [] (fun k -> fun data -> fun acc -> f k data :: acc) + +let to_list h = fold h [] (fun k -> fun data -> fun acc -> (k, data) :: acc) let rec small_bucket_mem (lst : _ bucket) eq key = match lst with @@ -117,39 +119,41 @@ let rec small_bucket_mem (lst : _ bucket) eq key = | Empty -> false | Cons lst -> eq key lst.key || small_bucket_mem lst.next eq key)) -let rec small_bucket_opt eq key (lst : _ bucket) : _ option = - match lst with - | Empty -> None - | Cons lst -> ( - if eq key lst.key then Some lst.data - else - match lst.next with - | Empty -> None - | Cons lst -> ( - if eq key lst.key then Some lst.data - else - match lst.next with - | Empty -> None - | Cons lst -> - if eq key lst.key then Some lst.data - else small_bucket_opt eq key lst.next)) - -let rec small_bucket_key_opt eq key (lst : _ bucket) : _ option = - match lst with - | Empty -> None - | Cons { key = k; next; _ } -> ( - if eq key k then Some k - else - match next with - | Empty -> None - | Cons { key = k; next; _ } -> ( - if eq key k then Some k - else - match next with - | Empty -> None - | Cons { key = k; next; _ } -> - if eq key k then Some k else small_bucket_key_opt eq key next) - ) +let rec small_bucket_opt eq key (lst : _ bucket) = + (match lst with + | Empty -> None + | Cons lst -> ( + if eq key lst.key then Some lst.data + else + match lst.next with + | Empty -> None + | Cons lst -> ( + if eq key lst.key then Some lst.data + else + match lst.next with + | Empty -> None + | Cons lst -> + if eq key lst.key then Some lst.data + else small_bucket_opt eq key lst.next)) + : _ option) + +let rec small_bucket_key_opt eq key (lst : _ bucket) = + (match lst with + | Empty -> None + | Cons { key = k; next; _ } -> ( + if eq key k then Some k + else + match next with + | Empty -> None + | Cons { key = k; next; _ } -> ( + if eq key k then Some k + else + match next with + | Empty -> None + | Cons { key = k; next; _ } -> + if eq key k then Some k else small_bucket_key_opt eq key next + )) + : _ option) let rec small_bucket_default eq key default (lst : _ bucket) = match lst with @@ -190,14 +194,23 @@ let rec replace_bucket key data (buck : _ bucket) eq_key = false) else replace_bucket key data slot.next eq_key -let to_array (type key a) (x : (key, a) t) : (key * a) array = - let vec = Vec.empty () in - iter x (fun entry -> Vec.push vec entry); - Vec.to_array vec - -let to_array_filter_map (type key a b) (x : (key, a) t) - (f : key * a -> b option) : b array = - let vec = Vec.empty () in - iter x (fun entry -> - match f entry with Some v -> Vec.push vec v | None -> ()); - Vec.to_array vec +let to_array (type key) (type a) (x : (key, a) t) = + (let vec = Vec.empty () in + iter x (fun entry -> Vec.push vec entry); + Vec.to_array vec + : (key * a) array) + +let to_array_map (type key) (type a) (type b) (x : (key, a) t) + (f : key * a -> b) = + (let vec = Vec.empty () in + iter x (fun entry -> Vec.push vec (f entry)); + Vec.to_array vec + : b array) + +let to_array_filter_map (type key) (type a) (type b) (x : (key, a) t) + (f : key * a -> b option) = + (let vec = Vec.empty () in + iter x (fun entry -> + match f entry with Some v -> Vec.push vec v | None -> ()); + Vec.to_array vec + : b array) diff --git a/src/basic_hash_int.ml b/src/basic_hash_int.ml index ee35102..2460c3a 100644 --- a/src/basic_hash_int.ml +++ b/src/basic_hash_int.ml @@ -23,7 +23,7 @@ include struct let _ = sexp_of_key let equal_key = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ : key -> key -> bool) let _ = equal_key @@ -51,6 +51,7 @@ let iter2 = Hash_gen.iter2 let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array +let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -63,26 +64,28 @@ let add (h : _ t) key data = if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -121,22 +124,23 @@ let find_key_opt (h : _ t) key = let find_default (h : _ t) key default = Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) -let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) +let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -145,6 +149,7 @@ let find_all (h : _ t) key = | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -175,13 +180,13 @@ let mem (h : _ t) key = let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -189,7 +194,7 @@ let of_list_map kvs f = let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = diff --git a/src/basic_hash_intf.ml b/src/basic_hash_intf.ml index acebf11..03a3c8f 100644 --- a/src/basic_hash_intf.ml +++ b/src/basic_hash_intf.ml @@ -40,6 +40,7 @@ module type S = sig val to_list_with : 'a t -> (key -> 'a -> 'c) -> 'c list val to_list : 'a t -> (key * 'a) list val to_array : 'a t -> (key * 'a) array + val to_array_map : 'a t -> (key * 'a -> 'b) -> 'b array val to_array_filter_map : 'a t -> (key * 'a -> 'b option) -> 'b array val of_list : (key * 'a) list -> 'a t val of_list2 : key list -> 'a list -> 'a t diff --git a/src/basic_hash_string.ml b/src/basic_hash_string.ml index a4faeeb..f009b5f 100644 --- a/src/basic_hash_string.ml +++ b/src/basic_hash_string.ml @@ -21,7 +21,7 @@ include struct let _ = fun (_ : key) -> () let equal_key = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ : key -> key -> bool) let _ = equal_key @@ -51,6 +51,7 @@ let iter2 = Hash_gen.iter2 let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array +let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -63,26 +64,28 @@ let add (h : _ t) key data = if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -121,22 +124,23 @@ let find_key_opt (h : _ t) key = let find_default (h : _ t) key default = Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) -let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) +let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -145,6 +149,7 @@ let find_all (h : _ t) key = | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -175,13 +180,13 @@ let mem (h : _ t) key = let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -189,7 +194,7 @@ let of_list_map kvs f = let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = diff --git a/src/basic_hashf.ml b/src/basic_hashf.ml index 2027716..e4d5767 100644 --- a/src/basic_hashf.ml +++ b/src/basic_hashf.ml @@ -49,6 +49,7 @@ module Make (Key : Hash_intf.HashedType) = struct let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array + let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -61,26 +62,28 @@ module Make (Key : Hash_intf.HashedType) = struct if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -120,22 +123,24 @@ module Make (Key : Hash_intf.HashedType) = struct Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) - let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) + let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -144,6 +149,7 @@ module Make (Key : Hash_intf.HashedType) = struct | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -174,13 +180,13 @@ module Make (Key : Hash_intf.HashedType) = struct let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -188,7 +194,7 @@ module Make (Key : Hash_intf.HashedType) = struct let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = diff --git a/src/basic_hashset_gen.ml b/src/basic_hashset_gen.ml index 773a162..c8360cb 100644 --- a/src/basic_hashset_gen.ml +++ b/src/basic_hashset_gen.ml @@ -13,7 +13,7 @@ *) -module Int_util = Basic_int_util +module Int_util = Basic_int open Basic_unsafe_external type 'a bucket = diff --git a/src/basic_hashset_int.ml b/src/basic_hashset_int.ml index d1209d9..ceb99a5 100644 --- a/src/basic_hashset_int.ml +++ b/src/basic_hashset_int.ml @@ -21,7 +21,7 @@ include struct let _ = fun (_ : key) -> () let equal_key = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ : key -> key -> bool) let _ = equal_key @@ -66,28 +66,30 @@ let of_array arr = done; tbl -let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - -let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - key +let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + +let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/basic_hashset_string.ml b/src/basic_hashset_string.ml index e03a6dd..8a773cf 100644 --- a/src/basic_hashset_string.ml +++ b/src/basic_hashset_string.ml @@ -21,7 +21,7 @@ include struct let _ = fun (_ : key) -> () let equal_key = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ : key -> key -> bool) let _ = equal_key @@ -66,28 +66,30 @@ let of_array arr = done; tbl -let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - -let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - key +let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + +let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/basic_hashsetf.ml b/src/basic_hashsetf.ml index 20d6e2f..ff8c4f7 100644 --- a/src/basic_hashsetf.ml +++ b/src/basic_hashsetf.ml @@ -65,29 +65,31 @@ struct done; tbl - let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false + let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) - let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then - Hashset_gen.resize key_index h; - key + let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/basic_ident.ml b/src/basic_ident.ml index 37a73ac..1b4d35c 100644 --- a/src/basic_ident.ml +++ b/src/basic_ident.ml @@ -32,18 +32,19 @@ include struct let (hash_fold_local_method : Ppx_base.state -> local_method -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv arg.index - in - hsv - in - hsv - in - Ppx_base.hash_fold_string hsv arg.method_name + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv arg.index + in + hsv + in + hsv + in + Ppx_base.hash_fold_string hsv arg.method_name let _ = hash_fold_local_method @@ -58,24 +59,26 @@ include struct let _ = hash_local_method let compare_local_method = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then 0 - else - match Stdlib.compare (a__001_.index : int) b__002_.index with - | 0 -> - Stdlib.compare (a__001_.method_name : string) b__002_.method_name - | n -> n + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then 0 + else + match Stdlib.compare (a__001_.index : int) b__002_.index with + | 0 -> + Stdlib.compare (a__001_.method_name : string) b__002_.method_name + | n -> n : local_method -> local_method -> int) let _ = compare_local_method let equal_local_method = - (fun a__003_ b__004_ -> - if Stdlib.( == ) a__003_ b__004_ then true - else - Stdlib.( && ) - (Stdlib.( = ) (a__003_.index : int) b__004_.index) - (Stdlib.( = ) (a__003_.method_name : string) b__004_.method_name) + (fun a__003_ -> + fun b__004_ -> + if Stdlib.( == ) a__003_ b__004_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__003_.index : int) b__004_.index) + (Stdlib.( = ) (a__003_.method_name : string) b__004_.method_name) : local_method -> local_method -> bool) let _ = equal_local_method @@ -95,7 +98,8 @@ include struct trait = trait__006_; method_name = method_name__008_; method_index = method_index__010_; - } -> + } + -> let bnds__005_ = ([] : _ Stdlib.List.t) in let bnds__005_ = let arg__011_ = Moon_sexp_conv.sexp_of_int method_index__010_ in @@ -118,15 +122,16 @@ include struct let (hash_fold_dyntrait_method : Ppx_base.state -> dyntrait_method -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv arg.trait - in - Ppx_base.hash_fold_string hsv arg.method_name - in - Ppx_base.hash_fold_int hsv arg.method_index + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv arg.trait + in + Ppx_base.hash_fold_string hsv arg.method_name + in + Ppx_base.hash_fold_int hsv arg.method_index let _ = hash_fold_dyntrait_method @@ -141,33 +146,37 @@ include struct let _ = hash_dyntrait_method let compare_dyntrait_method = - (fun a__012_ b__013_ -> - if Stdlib.( == ) a__012_ b__013_ then 0 - else - match Type_path.compare a__012_.trait b__013_.trait with - | 0 -> ( - match - Stdlib.compare (a__012_.method_name : string) b__013_.method_name - with - | 0 -> - Stdlib.compare - (a__012_.method_index : int) - b__013_.method_index - | n -> n) - | n -> n + (fun a__012_ -> + fun b__013_ -> + if Stdlib.( == ) a__012_ b__013_ then 0 + else + match Type_path.compare a__012_.trait b__013_.trait with + | 0 -> ( + match + Stdlib.compare + (a__012_.method_name : string) + b__013_.method_name + with + | 0 -> + Stdlib.compare + (a__012_.method_index : int) + b__013_.method_index + | n -> n) + | n -> n : dyntrait_method -> dyntrait_method -> int) let _ = compare_dyntrait_method let equal_dyntrait_method = - (fun a__014_ b__015_ -> - if Stdlib.( == ) a__014_ b__015_ then true - else - Stdlib.( && ) - (Type_path.equal a__014_.trait b__015_.trait) - (Stdlib.( && ) - (Stdlib.( = ) (a__014_.method_name : string) b__015_.method_name) - (Stdlib.( = ) (a__014_.method_index : int) b__015_.method_index)) + (fun a__014_ -> + fun b__015_ -> + if Stdlib.( == ) a__014_ b__015_ then true + else + Stdlib.( && ) + (Type_path.equal a__014_.trait b__015_.trait) + (Stdlib.( && ) + (Stdlib.( = ) (a__014_.method_name : string) b__015_.method_name) + (Stdlib.( = ) (a__014_.method_index : int) b__015_.method_index)) : dyntrait_method -> dyntrait_method -> bool) let _ = equal_dyntrait_method @@ -184,27 +193,28 @@ module Key = struct let _ = fun (_ : t) -> () let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Pident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - hsv - | Plocal_method _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = hsv in - hash_fold_local_method hsv _a0 - | Pdyntrait_method _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = hsv in - hash_fold_dyntrait_method hsv _a0 - | Pdot _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 3 in - let hsv = hsv in - Qual_ident.hash_fold_t hsv _a0 + (fun hsv -> + fun arg -> + match arg with + | Pident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + hsv + | Plocal_method _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_local_method hsv _a0 + | Pdyntrait_method _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = hsv in + hash_fold_dyntrait_method hsv _a0 + | Pdot _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 3 in + let hsv = hsv in + Qual_ident.hash_fold_t hsv _a0 : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -220,46 +230,48 @@ module Key = struct let _ = hash let compare = - (fun a__016_ b__017_ -> - if Stdlib.( == ) a__016_ b__017_ then 0 - else - match (a__016_, b__017_) with - | Pident _a__018_, Pident _b__019_ -> - Stdlib.compare (_a__018_.stamp : int) _b__019_.stamp - | Pident _, _ -> -1 - | _, Pident _ -> 1 - | Plocal_method _a__020_, Plocal_method _b__021_ -> - compare_local_method _a__020_ _b__021_ - | Plocal_method _, _ -> -1 - | _, Plocal_method _ -> 1 - | Pdyntrait_method _a__022_, Pdyntrait_method _b__023_ -> - compare_dyntrait_method _a__022_ _b__023_ - | Pdyntrait_method _, _ -> -1 - | _, Pdyntrait_method _ -> 1 - | Pdot _a__024_, Pdot _b__025_ -> - Qual_ident.compare _a__024_ _b__025_ + (fun a__016_ -> + fun b__017_ -> + if Stdlib.( == ) a__016_ b__017_ then 0 + else + match (a__016_, b__017_) with + | Pident _a__018_, Pident _b__019_ -> + Stdlib.compare (_a__018_.stamp : int) _b__019_.stamp + | Pident _, _ -> -1 + | _, Pident _ -> 1 + | Plocal_method _a__020_, Plocal_method _b__021_ -> + compare_local_method _a__020_ _b__021_ + | Plocal_method _, _ -> -1 + | _, Plocal_method _ -> 1 + | Pdyntrait_method _a__022_, Pdyntrait_method _b__023_ -> + compare_dyntrait_method _a__022_ _b__023_ + | Pdyntrait_method _, _ -> -1 + | _, Pdyntrait_method _ -> 1 + | Pdot _a__024_, Pdot _b__025_ -> + Qual_ident.compare _a__024_ _b__025_ : t -> t -> int) let _ = compare let equal = - (fun a__026_ b__027_ -> - if Stdlib.( == ) a__026_ b__027_ then true - else - match (a__026_, b__027_) with - | Pident _a__028_, Pident _b__029_ -> - Stdlib.( = ) (_a__028_.stamp : int) _b__029_.stamp - | Pident _, _ -> false - | _, Pident _ -> false - | Plocal_method _a__030_, Plocal_method _b__031_ -> - equal_local_method _a__030_ _b__031_ - | Plocal_method _, _ -> false - | _, Plocal_method _ -> false - | Pdyntrait_method _a__032_, Pdyntrait_method _b__033_ -> - equal_dyntrait_method _a__032_ _b__033_ - | Pdyntrait_method _, _ -> false - | _, Pdyntrait_method _ -> false - | Pdot _a__034_, Pdot _b__035_ -> Qual_ident.equal _a__034_ _b__035_ + (fun a__026_ -> + fun b__027_ -> + if Stdlib.( == ) a__026_ b__027_ then true + else + match (a__026_, b__027_) with + | Pident _a__028_, Pident _b__029_ -> + Stdlib.( = ) (_a__028_.stamp : int) _b__029_.stamp + | Pident _, _ -> false + | _, Pident _ -> false + | Plocal_method _a__030_, Plocal_method _b__031_ -> + equal_local_method _a__030_ _b__031_ + | Plocal_method _, _ -> false + | _, Plocal_method _ -> false + | Pdyntrait_method _a__032_, Pdyntrait_method _b__033_ -> + equal_dyntrait_method _a__032_ _b__033_ + | Pdyntrait_method _, _ -> false + | _, Pdyntrait_method _ -> false + | Pdot _a__034_, Pdot _b__035_ -> Qual_ident.equal _a__034_ _b__035_ : t -> t -> bool) let _ = equal @@ -277,7 +289,7 @@ module Key = struct "|"; tvar_name; "|"; - ] + ] [@merlin.hide] | Pdyntrait_method { trait; method_name; method_index = _ } -> Stdlib.String.concat "" [ @@ -285,10 +297,10 @@ module Key = struct Type_path.short_name ~cur_pkg_name:None trait; "]::"; method_name; - ] + ] [@merlin.hide] | Pdot q -> Qual_ident.string_of_t q - let sexp_of_t (x : t) : S.t = Atom (to_string x) + let sexp_of_t (x : t) = (Atom (to_string x) : S.t) end include Key @@ -342,33 +354,35 @@ module Map = struct let bal = Map_gen.bal let height = Map_gen.height - let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - - let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) + let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + + let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -404,77 +418,79 @@ module Map = struct let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x - let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) + let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } - let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - - let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) + let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + + let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -485,10 +501,12 @@ module Map = struct (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty - let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) + + let of_array xs = + Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) end module Set = struct @@ -532,111 +550,134 @@ module Set = struct let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] - let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> - No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> - No { result with l = Set_gen.internal_join l v result.l }) - - let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - - let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - - let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - - let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - - let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) + let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + + let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + + let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + + let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + + let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + + let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + + let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -654,8 +695,8 @@ module Set = struct Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t - let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params + let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) @@ -697,6 +738,7 @@ module Hash = struct let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array + let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -709,26 +751,28 @@ module Hash = struct if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -768,22 +812,24 @@ module Hash = struct Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) - let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) + let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -792,6 +838,7 @@ module Hash = struct | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -822,13 +869,13 @@ module Hash = struct let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -836,7 +883,7 @@ module Hash = struct let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = @@ -893,29 +940,31 @@ module Hashset = struct done; tbl - let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - - let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then - Hashset_gen.resize key_index h; - key + let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + + let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/basic_int.ml b/src/basic_int.ml new file mode 100644 index 0000000..4250035 --- /dev/null +++ b/src/basic_int.ml @@ -0,0 +1,45 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +let rec power_2_above x n = + if x >= n then x + else if x * 2 > Sys.max_array_length then x + else power_2_above (x * 2) n + +let string_of_int n = + if n = 0 then "0" + else if n = Int.min_int then Stdlib.string_of_int n + else + let rec count_digits_aux n acc = + if n = 0 then acc else count_digits_aux (n / 10) (acc + 1) + in + let count_digits n = count_digits_aux n 0 in + let negative = n < 0 in + let n = if negative then -n else n in + let len = count_digits n in + let total_len = if negative then len + 1 else len in + let bytes = Bytes.create total_len in + let n = ref n in + let index = + if negative then ( + Bytes.unsafe_set bytes 0 '-'; + 1) + else 0 + in + for pos = total_len - 1 downto index do + Bytes.unsafe_set bytes pos (Char.unsafe_chr (48 + (!n mod 10))); + n := !n / 10 + done; + Bytes.unsafe_to_string bytes diff --git a/src/basic_io.ml b/src/basic_io.ml index 862b6a4..fc8d8e5 100644 --- a/src/basic_io.ml +++ b/src/basic_io.ml @@ -20,15 +20,15 @@ let write file content = output_string out content; close_out_noerr out -let write_s file s = s |> S.to_string |> write file +let write_s file s = write file (S.to_string s) let write_ss file (ss : S.t list) = match ss with | [] -> write file "" | s :: ss -> let out = open_out_bin file in - output_string out (s |> S.to_string); - Lst.iter ss (fun s -> + output_string out (S.to_string s); + Lst.iter ss ~f:(fun s -> output_string out "\n"; output_string out (S.to_string s)); close_out_noerr out @@ -38,8 +38,8 @@ let write_wexps file (wexps : W.t list) = | [] -> write file "" | s :: ss -> let out = open_out_bin file in - output_string out (s |> W.to_string); - Lst.iter ss (fun s -> + output_string out (W.to_string s); + Lst.iter ss ~f:(fun s -> output_string out "\n"; output_string out (W.to_string s)); close_out_noerr out diff --git a/src/basic_iter.ml b/src/basic_iter.ml index 5c7dc5a..3fc4aed 100644 --- a/src/basic_iter.ml +++ b/src/basic_iter.ml @@ -18,11 +18,10 @@ type 'a t = ('a -> unit) -> unit external make : 'a t -> 'a t = "%identity" let iter ~f seq = seq f [@@inline] -let map (seq : _ t) ~f : _ t = fun k -> seq (fun x -> k (f x)) [@@inline] -let flat_map (seq : _ t) ~f : _ t = fun k -> seq (fun x -> f x k) [@@inline] +let map (seq : _ t) ~f = (fun k -> seq (fun x -> k (f x)) : _ t) [@@inline] -let filter_map (seq : _ t) ~f : _ t = - fun k -> seq (fun x -> match f x with None -> () | Some y -> k y) +let filter_map (seq : _ t) ~f = + (fun k -> seq (fun x -> match f x with None -> () | Some y -> k y) : _ t) [@@inline] exception ExitHead @@ -38,21 +37,19 @@ let head (seq : _ t) = exception ExitTake -let take n (seq : _ t) : _ t = - fun k -> - let count = ref 0 in - try - seq (fun x -> - if !count = n then raise_notrace ExitTake; - incr count; - k x) - with ExitTake -> () +let take n (seq : _ t) = + (fun k -> + let count = ref 0 in + try + seq (fun x -> + if !count = n then raise_notrace ExitTake; + incr count; + k x) + with ExitTake -> () + : _ t) let to_rev_list seq = let r = ref [] in seq (fun elt -> r := elt :: !r); !r [@@inline] - -let to_list seq = List.rev (to_rev_list seq) -let of_list l : _ t = fun k -> Basic_lst.iter l k [@@inline] diff --git a/src/basic_longident.ml b/src/basic_longident.ml index eb8efe3..3094411 100644 --- a/src/basic_longident.ml +++ b/src/basic_longident.ml @@ -19,12 +19,13 @@ include struct let _ = fun (_ : qual_name) -> () let equal_qual_name = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then true - else - Stdlib.( && ) - (Stdlib.( = ) (a__001_.pkg : string) b__002_.pkg) - (Stdlib.( = ) (a__001_.id : string) b__002_.id) + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__001_.pkg : string) b__002_.pkg) + (Stdlib.( = ) (a__001_.id : string) b__002_.id) : qual_name -> qual_name -> bool) let _ = equal_qual_name @@ -36,15 +37,16 @@ include struct let _ = fun (_ : t) -> () let equal = - (fun a__003_ b__004_ -> - if Stdlib.( == ) a__003_ b__004_ then true - else - match (a__003_, b__004_) with - | Lident _a__005_, Lident _b__006_ -> - Stdlib.( = ) (_a__005_ : string) _b__006_ - | Lident _, _ -> false - | _, Lident _ -> false - | Ldot _a__007_, Ldot _b__008_ -> equal_qual_name _a__007_ _b__008_ + (fun a__003_ -> + fun b__004_ -> + if Stdlib.( == ) a__003_ b__004_ then true + else + match (a__003_, b__004_) with + | Lident _a__005_, Lident _b__006_ -> + Stdlib.( = ) (_a__005_ : string) _b__006_ + | Lident _, _ -> false + | _, Lident _ -> false + | Ldot _a__007_, Ldot _b__008_ -> equal_qual_name _a__007_ _b__008_ : t -> t -> bool) let _ = equal @@ -54,4 +56,4 @@ let to_string = function | Lident id -> id | Ldot { pkg; id } -> "@" ^ pkg ^ "." ^ id -let sexp_of_t (x : t) : S.t = Atom (to_string x) +let sexp_of_t (x : t) = (Atom (to_string x) : S.t) diff --git a/src/basic_lst.ml b/src/basic_lst.ml index 2640600..608ec07 100644 --- a/src/basic_lst.ml +++ b/src/basic_lst.ml @@ -22,11 +22,56 @@ in standard `List` module when possible. Thank you. module Arr = Basic_arr -let map l f = List.map f l +let rec map l f = + match l with + | [] -> [] + | x1 :: [] -> + let y1 = f x1 in + [ y1 ] + | [ x1; x2 ] -> + let y1 = f x1 in + let y2 = f x2 in + [ y1; y2 ] + | [ x1; x2; x3 ] -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + [ y1; y2; y3 ] + | [ x1; x2; x3; x4 ] -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + let y4 = f x4 in + [ y1; y2; y3; y4 ] + | x1 :: x2 :: x3 :: x4 :: x5 :: tail -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + let y4 = f x4 in + let y5 = f x5 in + y1 :: y2 :: y3 :: y4 :: y5 :: map tail f +[@@tail_mod_cons] + +let rec map_and_check_tail l f = + match l with + | [] -> [] + | x :: [] -> [ f true x ] + | x1 :: (_ :: _ as tail) -> + let y1 = f false x1 in + y1 :: map_and_check_tail tail f +[@@tail_mod_cons] + +let rec iter_and_check_tail l f = + match l with + | [] -> () + | x :: [] -> f true x + | x1 :: (_ :: _ as tail) -> + f false x1; + iter_and_check_tail tail f let has_string (l : string list) query = List.mem query l -let rec map_split xs f = +let rec map_split (xs : 'a list) (f : 'a -> 'b * 'c) = match xs with | [] -> ([], []) | x :: xs -> @@ -37,9 +82,26 @@ let rec map_split xs f = let rec mapi_aux lst i f tail = match lst with | [] -> tail + | x0 :: [] -> f i x0 :: tail + | [ x0; x1 ] -> + let r0 = f i x0 in + let r1 = f (i + 1) x1 in + r0 :: r1 :: tail + | [ x0; x1; x2 ] -> + let r0 = f i x0 in + let r1 = f (i + 1) x1 in + let r2 = f (i + 2) x2 in + r0 :: r1 :: r2 :: tail + | [ x0; x1; x2; x3 ] -> + let r0 = f i x0 in + let r1 = f (i + 1) x1 in + let r2 = f (i + 2) x2 in + let r3 = f (i + 3) x3 in + r0 :: r1 :: r2 :: r3 :: tail | a :: l -> let r = f i a in r :: mapi_aux l (i + 1) f tail +[@@tail_mod_cons] let mapi lst f = List.mapi f lst let mapi_append lst f tail = mapi_aux lst 0 f tail @@ -50,16 +112,186 @@ let rec last xs = | _ :: tl -> last tl | [] -> invalid_arg __FUNCTION__ -let rec map_append l1 l2 f = +let rec append_aux l1 l2 = match l1 with | [] -> l2 - | a :: tl -> f a :: map_append tl l2 f + | a0 :: [] -> a0 :: l2 + | [ a0; a1 ] -> a0 :: a1 :: l2 + | [ a0; a1; a2 ] -> a0 :: a1 :: a2 :: l2 + | [ a0; a1; a2; a3 ] -> a0 :: a1 :: a2 :: a3 :: l2 + | [ a0; a1; a2; a3; a4 ] -> a0 :: a1 :: a2 :: a3 :: a4 :: l2 + | a0 :: a1 :: a2 :: a3 :: a4 :: rest -> + a0 :: a1 :: a2 :: a3 :: a4 :: append_aux rest l2 +[@@tail_mod_cons] -let fold_right l acc f = List.fold_right f l acc +let append l1 l2 = match l2 with [] -> l1 | _ -> append_aux l1 l2 + +let rec map_append l1 l2 f = + match l1 with + | [] -> l2 + | a0 :: [] -> f a0 :: l2 + | [ a0; a1 ] -> + let b0 = f a0 in + let b1 = f a1 in + b0 :: b1 :: l2 + | [ a0; a1; a2 ] -> + let b0 = f a0 in + let b1 = f a1 in + let b2 = f a2 in + b0 :: b1 :: b2 :: l2 + | [ a0; a1; a2; a3 ] -> + let b0 = f a0 in + let b1 = f a1 in + let b2 = f a2 in + let b3 = f a3 in + b0 :: b1 :: b2 :: b3 :: l2 + | [ a0; a1; a2; a3; a4 ] -> + let b0 = f a0 in + let b1 = f a1 in + let b2 = f a2 in + let b3 = f a3 in + let b4 = f a4 in + b0 :: b1 :: b2 :: b3 :: b4 :: l2 + | a0 :: a1 :: a2 :: a3 :: a4 :: rest -> + let b0 = f a0 in + let b1 = f a1 in + let b2 = f a2 in + let b3 = f a3 in + let b4 = f a4 in + b0 :: b1 :: b2 :: b3 :: b4 :: map_append rest l2 f +[@@tail_mod_cons] + +let rec rev_split chunks_acc input_tail = + (match input_tail with + | _x0 :: _x1 :: _x2 :: _x3 :: _x4 :: _x5 :: _x6 :: _x7 :: _x8 :: _x9 :: tail + as chunk_start -> + rev_split (chunk_start :: chunks_acc) tail + | [] -> chunks_acc + | remaining -> remaining :: chunks_acc + : 'a list list) + +let fold_right_chunk l acc f = + match l with + | [] -> acc + | a0 :: [] -> f a0 acc + | [ a0; a1 ] -> f a0 (f a1 acc) + | [ a0; a1; a2 ] -> f a0 (f a1 (f a2 acc)) + | [ a0; a1; a2; a3 ] -> f a0 (f a1 (f a2 (f a3 acc))) + | [ a0; a1; a2; a3; a4 ] -> f a0 (f a1 (f a2 (f a3 (f a4 acc)))) + | [ a0; a1; a2; a3; a4; a5 ] -> f a0 (f a1 (f a2 (f a3 (f a4 (f a5 acc))))) + | [ a0; a1; a2; a3; a4; a5; a6 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 acc)))))) + | [ a0; a1; a2; a3; a4; a5; a6; a7 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 acc))))))) + | [ a0; a1; a2; a3; a4; a5; a6; a7; a8 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 (f a8 acc)))))))) + | a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: a8 :: a9 :: _rest -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 (f a8 (f a9 acc))))))))) + +let fold_right l acc f = + match l with + | [] -> acc + | a0 :: [] -> f a0 acc + | [ a0; a1 ] -> f a0 (f a1 acc) + | [ a0; a1; a2 ] -> f a0 (f a1 (f a2 acc)) + | [ a0; a1; a2; a3 ] -> f a0 (f a1 (f a2 (f a3 acc))) + | [ a0; a1; a2; a3; a4 ] -> f a0 (f a1 (f a2 (f a3 (f a4 acc)))) + | [ a0; a1; a2; a3; a4; a5 ] -> f a0 (f a1 (f a2 (f a3 (f a4 (f a5 acc))))) + | [ a0; a1; a2; a3; a4; a5; a6 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 acc)))))) + | [ a0; a1; a2; a3; a4; a5; a6; a7 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 acc))))))) + | [ a0; a1; a2; a3; a4; a5; a6; a7; a8 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 (f a8 acc)))))))) + | [ a0; a1; a2; a3; a4; a5; a6; a7; a8; a9 ] -> + f a0 (f a1 (f a2 (f a3 (f a4 (f a5 (f a6 (f a7 (f a8 (f a9 acc))))))))) + | _a0 :: _a1 :: _a2 :: _a3 :: _a4 :: _a5 :: _a6 :: _a7 :: _a8 :: _a9 :: rest + -> + let chunks = rev_split [ l ] rest in + let rec fold_chunks chunks acc ~f = + match chunks with + | [] -> acc + | chunk :: preceding_chunks -> + let new_acc = fold_right_chunk chunk acc f in + fold_chunks preceding_chunks new_acc ~f + in + fold_chunks chunks acc ~f let fold_right2 l r acc f = List.fold_right2 f l r acc -let map2 l r f = List.map2 f l r +let rec map2i_aux l r f i = + match (l, r) with + | [], [] -> [] + | a0 :: [], b0 :: [] -> [ f i a0 b0 ] + | [ a0; a1 ], [ b0; b1 ] -> + let c0 = f i a0 b0 in + let c1 = f (i + 1) a1 b1 in + [ c0; c1 ] + | [ a0; a1; a2 ], [ b0; b1; b2 ] -> + let c0 = f i a0 b0 in + let c1 = f (i + 1) a1 b1 in + let c2 = f (i + 2) a2 b2 in + [ c0; c1; c2 ] + | [ a0; a1; a2; a3 ], [ b0; b1; b2; b3 ] -> + let c0 = f i a0 b0 in + let c1 = f (i + 1) a1 b1 in + let c2 = f (i + 2) a2 b2 in + let c3 = f (i + 3) a3 b3 in + [ c0; c1; c2; c3 ] + | [ a0; a1; a2; a3; a4 ], [ b0; b1; b2; b3; b4 ] -> + let c0 = f i a0 b0 in + let c1 = f (i + 1) a1 b1 in + let c2 = f (i + 2) a2 b2 in + let c3 = f (i + 3) a3 b3 in + let c4 = f (i + 4) a4 b4 in + [ c0; c1; c2; c3; c4 ] + | a0 :: a1 :: a2 :: a3 :: a4 :: arest, b0 :: b1 :: b2 :: b3 :: b4 :: brest -> + let c0 = f i a0 b0 in + let c1 = f (i + 1) a1 b1 in + let c2 = f (i + 2) a2 b2 in + let c3 = f (i + 3) a3 b3 in + let c4 = f (i + 4) a4 b4 in + c0 :: c1 :: c2 :: c3 :: c4 :: map2i_aux arest brest f (i + 5) + | _, _ -> invalid_arg __FUNCTION__ +[@@tail_mod_cons] + +let map2i l r f = map2i_aux l r f 0 + +let rec map2 l r f = + match (l, r) with + | [], [] -> [] + | a0 :: [], b0 :: [] -> [ f a0 b0 ] + | [ a0; a1 ], [ b0; b1 ] -> + let c0 = f a0 b0 in + let c1 = f a1 b1 in + [ c0; c1 ] + | [ a0; a1; a2 ], [ b0; b1; b2 ] -> + let c0 = f a0 b0 in + let c1 = f a1 b1 in + let c2 = f a2 b2 in + [ c0; c1; c2 ] + | [ a0; a1; a2; a3 ], [ b0; b1; b2; b3 ] -> + let c0 = f a0 b0 in + let c1 = f a1 b1 in + let c2 = f a2 b2 in + let c3 = f a3 b3 in + [ c0; c1; c2; c3 ] + | [ a0; a1; a2; a3; a4 ], [ b0; b1; b2; b3; b4 ] -> + let c0 = f a0 b0 in + let c1 = f a1 b1 in + let c2 = f a2 b2 in + let c3 = f a3 b3 in + let c4 = f a4 b4 in + [ c0; c1; c2; c3; c4 ] + | a0 :: a1 :: a2 :: a3 :: a4 :: arest, b0 :: b1 :: b2 :: b3 :: b4 :: brest -> + let c0 = f a0 b0 in + let c1 = f a1 b1 in + let c2 = f a2 b2 in + let c3 = f a3 b3 in + let c4 = f a4 b4 in + c0 :: c1 :: c2 :: c3 :: c4 :: map2 arest brest f + | _, _ -> invalid_arg __FUNCTION__ +[@@tail_mod_cons] let rec fold_left_with_offset l accu i f = match l with @@ -71,26 +303,7 @@ let rec filter_map xs (f : 'a -> 'b option) = | [] -> [] | y :: ys -> ( match f y with None -> filter_map ys f | Some z -> z :: filter_map ys f) - -let rec exclude (xs : 'a list) (p : 'a -> bool) : 'a list = - match xs with - | [] -> [] - | x :: xs -> if p x then exclude xs p else x :: exclude xs p - -let rec exclude_with_val l p = - match l with - | [] -> None - | a0 :: xs -> ( - if p a0 then Some (exclude xs p) - else - match xs with - | [] -> None - | a1 :: rest -> ( - if p a1 then Some (a0 :: exclude rest p) - else - match exclude_with_val rest p with - | None -> None - | Some rest -> Some (a0 :: a1 :: rest))) +[@@tail_mod_cons] let rec same_length xs ys = match (xs, ys) with @@ -98,6 +311,44 @@ let rec same_length xs ys = | _ :: xs, _ :: ys -> same_length xs ys | _, _ -> false +let init n f = + match n with + | 0 -> [] + | 1 -> + let a0 = f 0 in + [ a0 ] + | 2 -> + let a0 = f 0 in + let a1 = f 1 in + [ a0; a1 ] + | 3 -> + let a0 = f 0 in + let a1 = f 1 in + let a2 = f 2 in + [ a0; a1; a2 ] + | 4 -> + let a0 = f 0 in + let a1 = f 1 in + let a2 = f 2 in + let a3 = f 3 in + [ a0; a1; a2; a3 ] + | 5 -> + let a0 = f 0 in + let a1 = f 1 in + let a2 = f 2 in + let a3 = f 3 in + let a4 = f 4 in + [ a0; a1; a2; a3; a4 ] + | _ -> Array.to_list (Array.init n f) + +let rec rev_append l1 l2 = + match l1 with + | [] -> l2 + | a0 :: [] -> a0 :: l2 + | [ a0; a1 ] -> a1 :: a0 :: l2 + | a0 :: a1 :: a2 :: rest -> rev_append rest (a2 :: a1 :: a0 :: l2) + +let rev l = rev_append l [] let rec split_at_last_aux acc x = match x with | [] -> invalid_arg __FUNCTION__ @@ -124,6 +375,7 @@ let filter_mapi xs f = match f y i with | None -> aux (i + 1) ys | Some z -> z :: aux (i + 1) ys) + [@@tail_mod_cons] in aux 0 xs @@ -135,6 +387,7 @@ let rec filter_map2 xs ys (f : 'a -> 'b -> 'c option) = | None -> filter_map2 us vs f | Some z -> z :: filter_map2 us vs f) | _ -> invalid_arg __FUNCTION__ +[@@tail_mod_cons] let rec rev_map_append l1 l2 f = match l1 with [] -> l2 | a :: l -> rev_map_append l (f a :: l2) f @@ -168,10 +421,8 @@ let rec flat_map_auxi f acc append lx index = in flat_map_auxi f new_acc append rest (index + 1) -let concat_mapi lx f = flat_map_auxi f [] [] lx 0 let flat_mapi_append lx ~init:append ~f = flat_map_auxi f [] append lx 0 - let rec group (eq : 'a -> 'a -> bool) lst = match lst with [] -> [] | x :: xs -> aux eq x (group eq xs) @@ -182,7 +433,6 @@ and aux eq (x : 'a) (xss : 'a list list) : 'a list list = | _ :: _ -> assert false let stable_group lst eq = group eq lst |> List.rev - let rec drop h n = if n < 0 then invalid_arg __FUNCTION__ else if n = 0 then h @@ -191,19 +441,6 @@ let rec drop h n = let rec find_first x p = match x with [] -> None | x :: l -> if p x then Some x else find_first l p -let find_first_with_index x p = - let rec loop i xs p = - match xs with - | [] -> None - | a :: l -> if p a then Some (i, a) else loop (i + 1) l p - in - loop 0 x p - -let rec find_first_not xs p = - match xs with - | [] -> None - | a :: l -> if p a then find_first_not l p else Some a - let rec find_exn x p = match x with | [] -> invalid_arg __FUNCTION__ @@ -225,18 +462,67 @@ let rec rev_iter l f = rev_iter tail f; f x1 -let iter l f = List.iter f l +let rec iter l ~f = + match l with + | [] -> () + | x1 :: [] -> f x1 + | [ x1; x2 ] -> + f x1; + f x2 + | [ x1; x2; x3 ] -> + f x1; + f x2; + f x3 + | [ x1; x2; x3; x4 ] -> + f x1; + f x2; + f x3; + f x4 + | x1 :: x2 :: x3 :: x4 :: x5 :: tail -> + f x1; + f x2; + f x3; + f x4; + f x5; + iter tail ~f + +let rec iteri_aux l f i = + match l with + | [] -> () + | x1 :: [] -> f i x1 + | [ x1; x2 ] -> + f i x1; + f (i + 1) x2 + | [ x1; x2; x3 ] -> + f i x1; + f (i + 1) x2; + f (i + 2) x3 + | [ x1; x2; x3; x4 ] -> + f i x1; + f (i + 1) x2; + f (i + 2) x3; + f (i + 3) x4 + | x1 :: x2 :: x3 :: x4 :: x5 :: tail -> + f i x1; + f (i + 1) x2; + f (i + 2) x3; + f (i + 3) x4; + f (i + 4) x5; + iteri_aux tail f (i + 5) -let iteri l f = List.iteri f l +let iteri l ~f = iteri_aux l f 0 -let iter2 l1 l2 f = List.iter2 f l1 l2 +let rec iter2 l1 l2 f = + match (l1, l2) with + | [], [] -> () + | a1 :: l1, a2 :: l2 -> + f a1 a2; + iter2 l1 l2 f + | _, _ -> invalid_arg __FUNCTION__ let rec for_all lst p = match lst with [] -> true | a :: l -> p a && for_all l p -let rec for_all_snd lst p = - match lst with [] -> true | (_, a) :: l -> p a && for_all_snd l p - let rec for_all2_no_exn l1 l2 p = match (l1, l2) with | [], [] -> true @@ -253,36 +539,6 @@ let rec find_def xs p def = | [] -> def | x :: l -> ( match p x with Some v -> v | None -> find_def l p def) -let rec split_map l f = - match l with - | [] -> ([], []) - | x1 :: [] -> - let a0, b0 = f x1 in - ([ a0 ], [ b0 ]) - | [ x1; x2 ] -> - let a1, b1 = f x1 in - let a2, b2 = f x2 in - ([ a1; a2 ], [ b1; b2 ]) - | [ x1; x2; x3 ] -> - let a1, b1 = f x1 in - let a2, b2 = f x2 in - let a3, b3 = f x3 in - ([ a1; a2; a3 ], [ b1; b2; b3 ]) - | [ x1; x2; x3; x4 ] -> - let a1, b1 = f x1 in - let a2, b2 = f x2 in - let a3, b3 = f x3 in - let a4, b4 = f x4 in - ([ a1; a2; a3; a4 ], [ b1; b2; b3; b4 ]) - | x1 :: x2 :: x3 :: x4 :: x5 :: tail -> - let a1, b1 = f x1 in - let a2, b2 = f x2 in - let a3, b3 = f x3 in - let a4, b4 = f x4 in - let a5, b5 = f x5 in - let ass, bss = split_map tail f in - (a1 :: a2 :: a3 :: a4 :: a5 :: ass, b1 :: b2 :: b3 :: b4 :: b5 :: bss) - let rec split_map2 l r f = match (l, r) with | [], [] -> ([], []) @@ -314,6 +570,16 @@ let rec split_map2 l r f = (a1 :: a2 :: a3 :: a4 :: a5 :: ass, b1 :: b2 :: b3 :: b4 :: b5 :: bss) | _, _ -> invalid_arg __FUNCTION__ +let sort_via_arrayf lst cmp f = + let arr = Array.of_list lst in + Array.sort cmp arr; + Arr.to_list_f arr f + +let rec assoc_by_string lst (k : string) def = + match lst with + | [] -> ( match def with None -> assert false | Some x -> x) + | (k1, v1) :: rest -> if k1 = k then v1 else assoc_by_string rest k def + (** In a list of key-value pairs, find the value associated with key `k`. *) let rec assoc_by_opt lst comp k = match lst with @@ -321,7 +587,14 @@ let rec assoc_by_opt lst comp k = | (k1, v1) :: rest -> if comp k1 k then Some v1 else assoc_by_opt rest comp k let assoc_str lst str = assoc_by_opt lst String.equal str +let assoc_str_exn lst str = assoc_by_string lst str None + +let rec nth_aux l n = + match l with + | [] -> None + | a :: l -> if n = 0 then Some a else nth_aux l (n - 1) +let nth_opt l n = if n < 0 then None else nth_aux l n let rec exists l p = match l with [] -> false | x :: xs -> p x || exists xs p let rec exists_fst l p = @@ -333,12 +606,8 @@ let rec exists_snd l p = let rec concat_append (xss : 'a list list) (xs : 'a list) : 'a list = match xss with [] -> xs | l :: r -> List.append l (concat_append r xs) -let fold_left l init f = List.fold_left f init l - -let reduce_from_left lst fn = - match lst with - | first :: rest -> fold_left rest first fn - | _ -> invalid_arg __FUNCTION__ +let rec fold_left l accu f = + match l with [] -> accu | a :: l -> fold_left l (f accu a) f let rec fold_left2 l1 l2 accu f = match (l1, l2) with @@ -346,27 +615,19 @@ let rec fold_left2 l1 l2 accu f = | a1 :: l1, a2 :: l2 -> fold_left2 l1 l2 (f a1 a2 accu) f | _, _ -> invalid_arg __FUNCTION__ -let singleton_exn xs = match xs with x :: [] -> x | _ -> assert false - let rec mem_string (xs : string list) (x : string) = match xs with [] -> false | a :: l -> a = x || mem_string l x let rec mem_int (xs : int list) (x : int) = match xs with [] -> false | a :: l -> a = x || mem_int l x -let filter lst p = List.filter p lst - -let rec check_duplicate (xs : string list) = - match xs with - | [] -> false - | x :: rest -> Stdlib__List.exists (( = ) x) rest || check_duplicate rest - -let rec check_duplicate_opt ~equal xs = - match xs with - | [] -> None - | x :: rest -> - if Stdlib.List.exists (equal x) rest then Some x - else check_duplicate_opt ~equal rest +let filter lst p = + let rec find ~p accu lst = + match lst with + | [] -> rev accu + | x :: l -> if p x then find (x :: accu) l ~p else find accu l ~p + in + find [] lst ~p let stable_sort l cmp = match l with @@ -386,32 +647,12 @@ let stable_sort l cmp = Array.stable_sort cmp arr; Array.to_list arr -let stable_sort_as_array l ~cmp = - match l with - | [] -> [||] - | x :: [] -> [| x |] - | [ x1; x2 ] -> if cmp x1 x2 <= 0 then [| x1; x2 |] else [| x2; x1 |] - | [ x1; x2; x3 ] -> - if cmp x1 x2 <= 0 then - if cmp x2 x3 <= 0 then [| x1; x2; x3 |] - else if cmp x1 x3 <= 0 then [| x1; x3; x2 |] - else [| x3; x1; x2 |] - else if cmp x1 x3 <= 0 then [| x2; x1; x3 |] - else if cmp x2 x3 <= 0 then [| x2; x3; x1 |] - else [| x3; x2; x1 |] - | l -> - let arr = Array.of_list l in - Array.stable_sort cmp arr; - arr - -let rec unsafe_take n xs = - match xs, n with - | _, 0 -> [] - | [], _ -> invalid_arg __FUNCTION__ - | x :: tl, _ -> x :: unsafe_take (n - 1) tl +let rec unsafe_take xs n = + match xs with + | [] -> [] + | x :: rest -> if n <= 1 then [ x ] else x :: unsafe_take rest (n - 1) -let take n xs = - if n >= List.length xs then xs else if n <= 0 then [] else unsafe_take n xs +let take xs n = if n <= 0 then [] else unsafe_take xs n (** Accumulated sum, same as numpy.cumsum *) let cumsum lst = @@ -419,4 +660,37 @@ let cumsum lst = | [] -> List.rev acc | x :: xs -> aux ((sum + x) :: acc) (sum + x) xs in - aux [] 0 lst \ No newline at end of file + aux [] 0 lst + +let rec concat (xss : 'a list list) = + (match xss with + | [] -> [] + | xs :: [] -> xs + | xs :: yss -> append_concat xs yss + : 'a list) +[@@tail_mod_cons] + +and append_concat xs yss = + match xs with + | [] -> concat yss + | x :: [] -> x :: concat yss + | [ x1; x2 ] -> x1 :: x2 :: concat yss + | [ x1; x2; x3 ] -> x1 :: x2 :: x3 :: concat yss + | [ x1; x2; x3; x4 ] -> x1 :: x2 :: x3 :: x4 :: concat yss + | x1 :: x2 :: x3 :: x4 :: x5 :: rest -> + x1 :: x2 :: x3 :: x4 :: x5 :: append_concat rest yss +[@@tail_mod_cons] + +let rec combine xs ys = + match (xs, ys) with + | [], [] -> [] + | x :: xs, y :: ys -> (x, y) :: combine xs ys + | _, _ -> invalid_arg __FUNCTION__ +[@@tail_mod_cons] + +let split xs = + let rec aux accu1 accu2 = function + | [] -> (List.rev accu1, List.rev accu2) + | (x, y) :: rest -> aux (x :: accu1) (y :: accu2) rest + in + aux [] [] xs diff --git a/src/basic_map_gen.ml b/src/basic_map_gen.ml index 947dca2..59b6aa9 100644 --- a/src/basic_map_gen.ml +++ b/src/basic_map_gen.ml @@ -85,48 +85,52 @@ let rec bindings_aux accu = function let bindings s = bindings_aux [] s -let rec fill_array_with_f (s : _ t) i arr f : int = - match s with - | Empty -> i - | Leaf { k; v } -> - arr.!(i) <- f k v; - i + 1 - | Node { l; k; v; r; _ } -> - let inext = fill_array_with_f l i arr f in - arr.!(inext) <- f k v; - fill_array_with_f r (inext + 1) arr f - -let rec fill_array_aux (s : _ t) i arr : int = - match s with - | Empty -> i - | Leaf { k; v } -> - arr.!(i) <- (k, v); - i + 1 - | Node { l; k; v; r; _ } -> - let inext = fill_array_aux l i arr in - arr.!(inext) <- (k, v); - fill_array_aux r (inext + 1) arr - -let to_sorted_array (s : ('key, 'a) t) : ('key * 'a) array = - match s with - | Empty -> [||] - | Leaf { k; v } -> [| (k, v) |] - | Node { l; k; v; r; _ } -> - let len = cardinal_aux (cardinal_aux 1 r) l in - let arr = Array.make len (k, v) in - ignore (fill_array_aux s 0 arr : int); - arr - -let to_sorted_array_with_f (type key a b) (s : (key, a) t) (f : key -> a -> b) : - b array = - match s with - | Empty -> [||] - | Leaf { k; v } -> [| f k v |] - | Node { l; k; v; r; _ } -> - let len = cardinal_aux (cardinal_aux 1 r) l in - let arr = Array.make len (f k v) in - ignore (fill_array_with_f s 0 arr f : int); - arr +let rec fill_array_with_f (s : _ t) i arr f = + (match s with + | Empty -> i + | Leaf { k; v } -> + arr.!(i) <- f k v; + i + 1 + | Node { l; k; v; r; _ } -> + let inext = fill_array_with_f l i arr f in + arr.!(inext) <- f k v; + fill_array_with_f r (inext + 1) arr f + : int) + +let rec fill_array_aux (s : _ t) i arr = + (match s with + | Empty -> i + | Leaf { k; v } -> + arr.!(i) <- (k, v); + i + 1 + | Node { l; k; v; r; _ } -> + let inext = fill_array_aux l i arr in + arr.!(inext) <- (k, v); + fill_array_aux r (inext + 1) arr + : int) + +let to_sorted_array (s : ('key, 'a) t) = + (match s with + | Empty -> [||] + | Leaf { k; v } -> [| (k, v) |] + | Node { l; k; v; r; _ } -> + let len = cardinal_aux (cardinal_aux 1 r) l in + let arr = Array.make len (k, v) in + ignore (fill_array_aux s 0 arr : int); + arr + : ('key * 'a) array) + +let to_sorted_array_with_f (type key) (type a) (type b) (s : (key, a) t) + (f : key -> a -> b) = + (match s with + | Empty -> [||] + | Leaf { k; v } -> [| f k v |] + | Node { l; k; v; r; _ } -> + let len = cardinal_aux (cardinal_aux 1 r) l in + let arr = Array.make len (f k v) in + ignore (fill_array_with_f s 0 arr f : int); + arr + : b array) let rec keys_aux accu = function | Empty -> accu diff --git a/src/basic_map_int.ml b/src/basic_map_int.ml index 35fee1e..1175885 100644 --- a/src/basic_map_int.ml +++ b/src/basic_map_int.ml @@ -20,13 +20,13 @@ module Key = struct let _ = fun (_ : t) -> () let equal = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : int) b__002_ : t -> t -> bool) let _ = equal let compare = - (fun a__003_ b__004_ -> Stdlib.compare (a__003_ : int) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.compare (a__003_ : int) b__004_ : t -> t -> int) let _ = compare @@ -59,33 +59,35 @@ let mapi = Map_gen.mapi let bal = Map_gen.bal let height = Map_gen.height -let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - -let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) +let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + +let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -121,77 +123,79 @@ let rec mem (tree : _ Map_gen.t) x = let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x -let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) +let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } -let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - -let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) +let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + +let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -202,7 +206,7 @@ let sexp_of_t f map = (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty -let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) +let of_array xs = Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) diff --git a/src/basic_map_string.ml b/src/basic_map_string.ml index c918cc3..a22728b 100644 --- a/src/basic_map_string.ml +++ b/src/basic_map_string.ml @@ -22,13 +22,13 @@ module Key = struct let _ = sexp_of_t let compare = - (fun a__001_ b__002_ -> Stdlib.compare (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.compare (a__001_ : string) b__002_ : t -> t -> int) let _ = compare let equal = - (fun a__003_ b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ : t -> t -> bool) let _ = equal @@ -59,33 +59,35 @@ let mapi = Map_gen.mapi let bal = Map_gen.bal let height = Map_gen.height -let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - -let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) +let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + +let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -121,77 +123,79 @@ let rec mem (tree : _ Map_gen.t) x = let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x -let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) +let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } -let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - -let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) +let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + +let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -202,7 +206,7 @@ let sexp_of_t f map = (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty -let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) +let of_array xs = Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) diff --git a/src/basic_mapf.ml b/src/basic_mapf.ml index 931d683..55245c1 100644 --- a/src/basic_mapf.ml +++ b/src/basic_mapf.ml @@ -41,33 +41,35 @@ struct let bal = Map_gen.bal let height = Map_gen.height - let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - - let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) + let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + + let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -103,77 +105,79 @@ struct let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x - let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) + let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } - let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - - let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) + let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + + let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -184,8 +188,10 @@ struct (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty - let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) + + let of_array xs = + Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) end diff --git a/src/basic_ordered_hash_map_gen.ml b/src/basic_ordered_hash_map_gen.ml index d6b1f21..b103cb6 100644 --- a/src/basic_ordered_hash_map_gen.ml +++ b/src/basic_ordered_hash_map_gen.ml @@ -13,7 +13,7 @@ *) -module Int_util = Basic_int_util +module Int_util = Basic_int module Unsafe_external = Basic_unsafe_external open Unsafe_external @@ -87,7 +87,7 @@ let to_sorted_array h = else let v = choose h in let arr = Array.make h.size v in - iter h (fun k _ i -> arr.!(i) <- k); + iter h (fun k -> fun _ -> fun i -> arr.!(i) <- k); arr let fold h init f = @@ -103,7 +103,7 @@ let fold h init f = done; !accu -let elements set = fold set [] (fun k _ _ acc -> k :: acc) +let elements set = fold set [] (fun k -> fun _ -> fun _ -> fun acc -> k :: acc) let rec bucket_length acc (x : _ bucket) = match x with Empty -> 0 | Cons rhs -> bucket_length (acc + 1) rhs.next diff --git a/src/basic_qual_ident.ml b/src/basic_qual_ident.ml index 3b2a7cd..1f1b0ae 100644 --- a/src/basic_qual_ident.ml +++ b/src/basic_qual_ident.ml @@ -30,23 +30,24 @@ type t = name : string; } -let hash_fold_t (hsv : Ppx_base.state) (t : t) : Ppx_base.state = - match t with - | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = Ppx_base.hash_fold_string hsv pkg in - Ppx_base.hash_fold_string hsv name - | Qmethod { self_typ; name } -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = Type_path.hash_fold_t hsv self_typ in - Ppx_base.hash_fold_string hsv name - | Qext_method { trait; self_typ; name } -> - let hsv = Ppx_base.hash_fold_int hsv 3 in - let hsv = Type_path.hash_fold_t hsv trait in - let hsv = Type_path.hash_fold_t hsv self_typ in - Ppx_base.hash_fold_string hsv name +let hash_fold_t (hsv : Ppx_base.state) (t : t) = + (match t with + | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = Ppx_base.hash_fold_string hsv pkg in + Ppx_base.hash_fold_string hsv name + | Qmethod { self_typ; name } -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = Type_path.hash_fold_t hsv self_typ in + Ppx_base.hash_fold_string hsv name + | Qext_method { trait; self_typ; name } -> + let hsv = Ppx_base.hash_fold_int hsv 3 in + let hsv = Type_path.hash_fold_t hsv trait in + let hsv = Type_path.hash_fold_t hsv self_typ in + Ppx_base.hash_fold_string hsv name + : Ppx_base.state) -let hash (t : t) = hash_fold_t (Ppx_base.create ()) t |> Ppx_base.get_hash_value +let hash (t : t) = Ppx_base.get_hash_value (hash_fold_t (Ppx_base.create ()) t) let compare (t1 : t) (t2 : t) = if Basic_prelude.phys_equal t1 t2 then 0 @@ -97,8 +98,6 @@ let equal (t1 : t) (t2 : t) = && String.equal name1 name2 let create_predef name = Qregular { pkg = "*predef*"; name } -let op_and = Qregular { pkg = "*predef*"; name = "&&" } -let op_or = Qregular { pkg = "*predef*"; name = "||" } let get_pkg t = match t with @@ -114,16 +113,17 @@ let string_of_t t = | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> if pkg = "" then name else if pkg = Config.builtin_package then "$builtin." ^ name - else Stdlib.String.concat "" [ "$"; pkg; "."; name ] + else Stdlib.String.concat "" [ "$"; pkg; "."; name ] [@merlin.hide] | Qmethod { self_typ; name } -> let typ_str = Type_path.short_name ~cur_pkg_name:None self_typ in - (typ_str ^ "::" ^ name : Stdlib.String.t) + ((typ_str ^ "::" ^ name : Stdlib.String.t) [@merlin.hide]) | Qext_method { trait; self_typ; name } -> let trait_str = Type_path.short_name ~cur_pkg_name:None trait in let typ_str = Type_path.short_name ~cur_pkg_name:None self_typ in - Stdlib.String.concat "" [ trait_str; "::"; name; "|"; typ_str; "|" ] + (Stdlib.String.concat "" + [ trait_str; "::"; name; "|"; typ_str; "|" ] [@merlin.hide]) -let sexp_of_t t : S.t = S.Atom (string_of_t t) +let sexp_of_t t = (S.Atom (string_of_t t) : S.t) let base_name t = match t with @@ -152,16 +152,33 @@ let to_wasm_name t = match t with | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> let name = Strutil.mangle_wasm_name name in - if pkg = "" then ("$" ^ name : Stdlib.String.t) + if pkg = "" then ("$" ^ name : Stdlib.String.t) [@merlin.hide] else let pkg = Strutil.mangle_wasm_name pkg in - Stdlib.String.concat "" [ "$"; pkg; "."; name ] + (Stdlib.String.concat "" [ "$"; pkg; "."; name ] [@merlin.hide]) | Qmethod { self_typ; name } -> let typ_str = Strutil.mangle_wasm_name (Type_path.export_name self_typ) in let name = Strutil.mangle_wasm_name name in - Stdlib.String.concat "" [ "$"; typ_str; "::"; name ] + (Stdlib.String.concat "" [ "$"; typ_str; "::"; name ] [@merlin.hide]) | Qext_method { trait; self_typ; name } -> let trait_str = Strutil.mangle_wasm_name (Type_path.export_name trait) in let typ_str = Strutil.mangle_wasm_name (Type_path.export_name self_typ) in let name = Strutil.mangle_wasm_name name in - Stdlib.String.concat "" [ "$"; trait_str; "::"; typ_str; "::"; name ] + (Stdlib.String.concat "" + [ "$"; trait_str; "::"; typ_str; "::"; name ] [@merlin.hide]) + +let to_toplevel_id t = + (match t with + | Qregular { pkg; name } -> T_regular { pkg; name } + | Qmethod { self_typ; name } -> T_method { self_typ; name } + | Qext_method { trait; self_typ; name } -> + T_ext_method { trait; self_typ; name } + | Qregular_implicit_pkg _ -> assert false + : Type_path.toplevel_id) + +let from_toplevel_id (id : Type_path.toplevel_id) = + match id with + | T_regular { pkg; name } -> Qregular { pkg; name } + | T_method { self_typ; name } -> Qmethod { self_typ; name } + | T_ext_method { trait; self_typ; name } -> + Qext_method { trait; self_typ; name } diff --git a/src/basic_ref.ml b/src/basic_ref.ml index 7cc3b3e..42eadde 100644 --- a/src/basic_ref.ml +++ b/src/basic_ref.ml @@ -60,11 +60,11 @@ let protect2 r1 r2 v1 v2 body = let protect_list rvs body = let olds = Lst.map rvs (fun (x, _) -> !x) in - let () = Lst.iter rvs (fun (x, y) -> x := y) in + let () = Lst.iter rvs ~f:(fun (x, y) -> x := y) in try let res = body () in - List.iter2 (fun (x, _) old -> x := old) rvs olds; + List.iter2 (fun (x, _) -> fun old -> x := old) rvs olds; res with e -> - List.iter2 (fun (x, _) old -> x := old) rvs olds; + List.iter2 (fun (x, _) -> fun old -> x := old) rvs olds; raise e diff --git a/src/basic_scc.ml b/src/basic_scc.ml index 96c7f30..666b6ee 100644 --- a/src/basic_scc.ml +++ b/src/basic_scc.ml @@ -66,4 +66,5 @@ let graph e = let graph_check v = let v = graph v in - (Vec.length v, Vec.fold_left ~f:(fun acc x -> Vec_int.length x :: acc) [] v) + ( Vec.length v, + Vec.fold_left ~f:(fun acc -> fun x -> Vec_int.length x :: acc) [] v ) diff --git a/src/basic_set_gen.ml b/src/basic_set_gen.ml index 6545164..478bd4d 100644 --- a/src/basic_set_gen.ml +++ b/src/basic_set_gen.ml @@ -111,48 +111,49 @@ let rec check_height_and_diff = function let check tree = ignore (check_height_and_diff tree) -let bal l v r : _ t = - let hl = height l in - let hr = height r in - if hl > hr + 2 then - let { l = ll; r = lr; v = lv; h = _ } = ~!l in - let hll = height ll in - let hlr = height lr in - if hll >= hlr then - let hnode = calc_height hlr hr in - unsafe_node lv ll - (unsafe_node_maybe_leaf v lr r hnode) - (calc_height hll hnode) - else - let { l = lrl; r = lrr; v = lrv; _ } = ~!lr in - let hlrl = height lrl in - let hlrr = height lrr in - let hlnode = calc_height hll hlrl in - let hrnode = calc_height hlrr hr in - unsafe_node lrv - (unsafe_node_maybe_leaf lv ll lrl hlnode) - (unsafe_node_maybe_leaf v lrr r hrnode) - (calc_height hlnode hrnode) - else if hr > hl + 2 then - let { l = rl; r = rr; v = rv; _ } = ~!r in - let hrr = height rr in - let hrl = height rl in - if hrr >= hrl then - let hnode = calc_height hl hrl in - unsafe_node rv - (unsafe_node_maybe_leaf v l rl hnode) - rr (calc_height hnode hrr) - else - let { l = rll; r = rlr; v = rlv; _ } = ~!rl in - let hrll = height rll in - let hrlr = height rlr in - let hlnode = calc_height hl hrll in - let hrnode = calc_height hrlr hrr in - unsafe_node rlv - (unsafe_node_maybe_leaf v l rll hlnode) - (unsafe_node_maybe_leaf rv rlr rr hrnode) - (calc_height hlnode hrnode) - else unsafe_node_maybe_leaf v l r (calc_height hl hr) +let bal l v r = + (let hl = height l in + let hr = height r in + if hl > hr + 2 then + let { l = ll; r = lr; v = lv; h = _ } = ~!l in + let hll = height ll in + let hlr = height lr in + if hll >= hlr then + let hnode = calc_height hlr hr in + unsafe_node lv ll + (unsafe_node_maybe_leaf v lr r hnode) + (calc_height hll hnode) + else + let { l = lrl; r = lrr; v = lrv; _ } = ~!lr in + let hlrl = height lrl in + let hlrr = height lrr in + let hlnode = calc_height hll hlrl in + let hrnode = calc_height hlrr hr in + unsafe_node lrv + (unsafe_node_maybe_leaf lv ll lrl hlnode) + (unsafe_node_maybe_leaf v lrr r hrnode) + (calc_height hlnode hrnode) + else if hr > hl + 2 then + let { l = rl; r = rr; v = rv; _ } = ~!r in + let hrr = height rr in + let hrl = height rl in + if hrr >= hrl then + let hnode = calc_height hl hrl in + unsafe_node rv + (unsafe_node_maybe_leaf v l rl hnode) + rr (calc_height hnode hrr) + else + let { l = rll; r = rlr; v = rlv; _ } = ~!rl in + let hrll = height rll in + let hrlr = height rlr in + let hlnode = calc_height hl hrll in + let hrnode = calc_height hrlr hrr in + unsafe_node rlv + (unsafe_node_maybe_leaf v l rll hlnode) + (unsafe_node_maybe_leaf rv rlr rr hrnode) + (calc_height hlnode hrnode) + else unsafe_node_maybe_leaf v l r (calc_height hl hr) + : _ t) let rec remove_min_elt = function | Empty -> invalid_arg __FUNCTION__ diff --git a/src/basic_set_intf.ml b/src/basic_set_intf.ml index fa844cf..8e04d52 100644 --- a/src/basic_set_intf.ml +++ b/src/basic_set_intf.ml @@ -29,6 +29,7 @@ module type S = sig val choose : t -> elt val mem : t -> elt -> bool val add : t -> elt -> t + val check_add : t -> duplicate_flag:bool ref -> elt -> t val remove : t -> elt -> t val union : t -> t -> t val inter : t -> t -> t diff --git a/src/basic_set_string.ml b/src/basic_set_string.ml index dd47ef2..d940e59 100644 --- a/src/basic_set_string.ml +++ b/src/basic_set_string.ml @@ -22,13 +22,13 @@ module Key = struct let _ = sexp_of_t let compare = - (fun a__001_ b__002_ -> Stdlib.compare (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.compare (a__001_ : string) b__002_ : t -> t -> int) let _ = compare let equal = - (fun a__003_ b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.( = ) (a__003_ : string) b__004_ : t -> t -> bool) let _ = equal @@ -75,110 +75,134 @@ let split_r (x : split) = match x with Yes { r; _ } | No { r; _ } -> r let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] -let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> No { result with l = Set_gen.internal_join l v result.l } - ) - -let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - -let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - -let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - -let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - -let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) +let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + +let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + +let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + +let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + +let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + +let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + +let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -196,8 +220,8 @@ let invariant t = Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t -let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params +let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) diff --git a/src/basic_setf.ml b/src/basic_setf.ml index ce0f4a8..4ddba1a 100644 --- a/src/basic_setf.ml +++ b/src/basic_setf.ml @@ -56,111 +56,134 @@ module Make (Key : Set_intf.OrderedType) = struct let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] - let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> - No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> - No { result with l = Set_gen.internal_join l v result.l }) - - let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - - let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - - let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - - let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - - let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) + let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + + let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + + let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + + let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + + let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + + let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + + let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -178,8 +201,8 @@ module Make (Key : Set_intf.OrderedType) = struct Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t - let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params + let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) diff --git a/src/basic_strutil.ml b/src/basic_strutil.ml index 6e47b59..d939452 100644 --- a/src/basic_strutil.ml +++ b/src/basic_strutil.ml @@ -46,10 +46,11 @@ let rec ends_aux s end_ j k = else if s.![j] = end_.![k] then ends_aux s end_ (j - 1) (k - 1) else -1 -let ends_with_index s end_ : int = - let s_finish = String.length s - 1 in - let s_beg = String.length end_ - 1 in - if s_beg > s_finish then -1 else ends_aux s end_ s_finish s_beg +let ends_with_index s end_ = + (let s_finish = String.length s - 1 in + let s_beg = String.length end_ - 1 in + if s_beg > s_finish then -1 else ends_aux s end_ s_finish s_beg + : int) let ends_with_then_chop s beg = let i = ends_with_index s beg in @@ -113,10 +114,11 @@ let rfind ~sub s = let rec unsafe_no_char x ch i last_idx = i > last_idx || (x.![i] <> ch && unsafe_no_char x ch (i + 1) last_idx) -let no_char x ch i len : bool = - let str_len = String.length x in - if i < 0 || i >= str_len || len >= str_len then invalid_arg __FUNCTION__ - else unsafe_no_char x ch i len +let no_char x ch i len = + (let str_len = String.length x in + if i < 0 || i >= str_len || len >= str_len then invalid_arg __FUNCTION__ + else unsafe_no_char x ch i len + : bool) let no_slash x = unsafe_no_char x '/' 0 (String.length x - 1) @@ -217,19 +219,19 @@ let split_on_last c s = go (String.length s - 1) s let no_need_wasm_mangled s = - let rec go i = - if i >= String.length s then true + let rec go i len = + if i >= len then true else - match s.[i] with + match s.![i] with | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '_' | '.' | '*' | '|' | '<' | '>' | '+' | '-' | '@' | ':' | '$' | '!' | '=' | '/' -> - go (i + 1) + go (i + 1) len | _ -> false in - go 0 + go 0 (String.length s) let mangle_wasm_name s = if no_need_wasm_mangled s then s else Base64.encode s diff --git a/src/basic_ty_ident.ml b/src/basic_ty_ident.ml index 2815625..1b49a43 100644 --- a/src/basic_ty_ident.ml +++ b/src/basic_ty_ident.ml @@ -27,7 +27,7 @@ include struct let _ = sexp_of_t let equal = - (fun a__001_ b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.( = ) (a__001_ : string) b__002_ : t -> t -> bool) let _ = equal @@ -43,24 +43,26 @@ include struct and _ = hash end -let of_string (s : string) : t = s -let to_string (t : t) : string = t -let to_wasm_name (t : t) : string = "$" ^ Strutil.mangle_wasm_name (to_string t) +let of_string (s : string) = (s : t) +let to_string (t : t) = (t : string) -let of_type_path (p : Type_path.t) : t = - Type_path.export_name ~cur_pkg_name:!Basic_config.current_package p +let to_wasm_name (t : t) = + ("$" ^ Strutil.mangle_wasm_name (to_string t) : string) -let capture_of_function (addr : Fn_address.t) : t = - of_string (Fn_address.to_string addr ^ "-cap") +let of_type_path (p : Type_path.t) = + (Type_path.export_name ~cur_pkg_name:!Basic_config.current_package p : t) -let code_pointer_of_closure (closure_tid : t) : t = - of_string (to_string closure_tid ^ "-sig") +let capture_of_function (addr : Fn_address.t) = + (of_string (Fn_address.to_string addr ^ "-cap") : t) -let method_of_object (object_tid : t) method_index : t = - (object_tid ^ ".method_" ^ Int.to_string method_index : Stdlib.String.t) +let code_pointer_of_closure (closure_tid : t) = + (of_string (to_string closure_tid ^ "-sig") : t) -let concrete_object_type ~trait ~type_name : t = - (type_name ^ ".as_" ^ of_type_path trait : Stdlib.String.t) +let method_of_object (object_tid : t) method_index = + ((object_tid ^ ".method_" ^ Int.to_string method_index : Stdlib.String.t) : t) + +let concrete_object_type ~trait ~type_name = + ((type_name ^ ".as_" ^ of_type_path trait : Stdlib.String.t) : t) module Hash = Hashf.Make (struct type nonrec t = t diff --git a/src/basic_type_path.ml b/src/basic_type_path.ml index 635aa74..329667b 100644 --- a/src/basic_type_path.ml +++ b/src/basic_type_path.ml @@ -25,8 +25,10 @@ type t = | T_byte | T_char | T_int + | T_int16 | T_int64 | T_uint + | T_uint16 | T_uint64 | T_float | T_double @@ -39,88 +41,138 @@ type t = | T_ref | T_error | Toplevel of { pkg : string; id : string } + | T_local of { toplevel_id : toplevel_id; name : string } | Tuple of int | Constr of { ty : t; tag : Constr_info.constr_tag } +and toplevel_id = + | T_regular of { pkg : string; name : string } + | T_method of { self_typ : t; name : string } + | T_ext_method of { trait : t; self_typ : t; name : string } + include struct let _ = fun (_ : t) -> () + let _ = fun (_ : toplevel_id) -> () let rec compare = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then 0 - else - match (a__001_, b__002_) with - | T_unit, T_unit -> 0 - | T_unit, _ -> -1 - | _, T_unit -> 1 - | T_bool, T_bool -> 0 - | T_bool, _ -> -1 - | _, T_bool -> 1 - | T_byte, T_byte -> 0 - | T_byte, _ -> -1 - | _, T_byte -> 1 - | T_char, T_char -> 0 - | T_char, _ -> -1 - | _, T_char -> 1 - | T_int, T_int -> 0 - | T_int, _ -> -1 - | _, T_int -> 1 - | T_int64, T_int64 -> 0 - | T_int64, _ -> -1 - | _, T_int64 -> 1 - | T_uint, T_uint -> 0 - | T_uint, _ -> -1 - | _, T_uint -> 1 - | T_uint64, T_uint64 -> 0 - | T_uint64, _ -> -1 - | _, T_uint64 -> 1 - | T_float, T_float -> 0 - | T_float, _ -> -1 - | _, T_float -> 1 - | T_double, T_double -> 0 - | T_double, _ -> -1 - | _, T_double -> 1 - | T_string, T_string -> 0 - | T_string, _ -> -1 - | _, T_string -> 1 - | T_option, T_option -> 0 - | T_option, _ -> -1 - | _, T_option -> 1 - | T_result, T_result -> 0 - | T_result, _ -> -1 - | _, T_result -> 1 - | T_error_value_result, T_error_value_result -> 0 - | T_error_value_result, _ -> -1 - | _, T_error_value_result -> 1 - | T_fixedarray, T_fixedarray -> 0 - | T_fixedarray, _ -> -1 - | _, T_fixedarray -> 1 - | T_bytes, T_bytes -> 0 - | T_bytes, _ -> -1 - | _, T_bytes -> 1 - | T_ref, T_ref -> 0 - | T_ref, _ -> -1 - | _, T_ref -> 1 - | T_error, T_error -> 0 - | T_error, _ -> -1 - | _, T_error -> 1 - | Toplevel _a__003_, Toplevel _b__004_ -> ( - match Stdlib.compare (_a__003_.pkg : string) _b__004_.pkg with - | 0 -> Stdlib.compare (_a__003_.id : string) _b__004_.id - | n -> n) - | Toplevel _, _ -> -1 - | _, Toplevel _ -> 1 - | Tuple _a__005_, Tuple _b__006_ -> - Stdlib.compare (_a__005_ : int) _b__006_ - | Tuple _, _ -> -1 - | _, Tuple _ -> 1 - | Constr _a__007_, Constr _b__008_ -> ( - match compare _a__007_.ty _b__008_.ty with - | 0 -> Constr_info.compare_constr_tag _a__007_.tag _b__008_.tag - | n -> n) + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then 0 + else + match (a__001_, b__002_) with + | T_unit, T_unit -> 0 + | T_unit, _ -> -1 + | _, T_unit -> 1 + | T_bool, T_bool -> 0 + | T_bool, _ -> -1 + | _, T_bool -> 1 + | T_byte, T_byte -> 0 + | T_byte, _ -> -1 + | _, T_byte -> 1 + | T_char, T_char -> 0 + | T_char, _ -> -1 + | _, T_char -> 1 + | T_int, T_int -> 0 + | T_int, _ -> -1 + | _, T_int -> 1 + | T_int16, T_int16 -> 0 + | T_int16, _ -> -1 + | _, T_int16 -> 1 + | T_int64, T_int64 -> 0 + | T_int64, _ -> -1 + | _, T_int64 -> 1 + | T_uint, T_uint -> 0 + | T_uint, _ -> -1 + | _, T_uint -> 1 + | T_uint16, T_uint16 -> 0 + | T_uint16, _ -> -1 + | _, T_uint16 -> 1 + | T_uint64, T_uint64 -> 0 + | T_uint64, _ -> -1 + | _, T_uint64 -> 1 + | T_float, T_float -> 0 + | T_float, _ -> -1 + | _, T_float -> 1 + | T_double, T_double -> 0 + | T_double, _ -> -1 + | _, T_double -> 1 + | T_string, T_string -> 0 + | T_string, _ -> -1 + | _, T_string -> 1 + | T_option, T_option -> 0 + | T_option, _ -> -1 + | _, T_option -> 1 + | T_result, T_result -> 0 + | T_result, _ -> -1 + | _, T_result -> 1 + | T_error_value_result, T_error_value_result -> 0 + | T_error_value_result, _ -> -1 + | _, T_error_value_result -> 1 + | T_fixedarray, T_fixedarray -> 0 + | T_fixedarray, _ -> -1 + | _, T_fixedarray -> 1 + | T_bytes, T_bytes -> 0 + | T_bytes, _ -> -1 + | _, T_bytes -> 1 + | T_ref, T_ref -> 0 + | T_ref, _ -> -1 + | _, T_ref -> 1 + | T_error, T_error -> 0 + | T_error, _ -> -1 + | _, T_error -> 1 + | Toplevel _a__003_, Toplevel _b__004_ -> ( + match Stdlib.compare (_a__003_.pkg : string) _b__004_.pkg with + | 0 -> Stdlib.compare (_a__003_.id : string) _b__004_.id + | n -> n) + | Toplevel _, _ -> -1 + | _, Toplevel _ -> 1 + | T_local _a__005_, T_local _b__006_ -> ( + match + compare_toplevel_id _a__005_.toplevel_id _b__006_.toplevel_id + with + | 0 -> Stdlib.compare (_a__005_.name : string) _b__006_.name + | n -> n) + | T_local _, _ -> -1 + | _, T_local _ -> 1 + | Tuple _a__007_, Tuple _b__008_ -> + Stdlib.compare (_a__007_ : int) _b__008_ + | Tuple _, _ -> -1 + | _, Tuple _ -> 1 + | Constr _a__009_, Constr _b__010_ -> ( + match compare _a__009_.ty _b__010_.ty with + | 0 -> Constr_info.compare_constr_tag _a__009_.tag _b__010_.tag + | n -> n) : t -> t -> int) + and compare_toplevel_id = + (fun a__011_ -> + fun b__012_ -> + if Stdlib.( == ) a__011_ b__012_ then 0 + else + match (a__011_, b__012_) with + | T_regular _a__013_, T_regular _b__014_ -> ( + match Stdlib.compare (_a__013_.pkg : string) _b__014_.pkg with + | 0 -> Stdlib.compare (_a__013_.name : string) _b__014_.name + | n -> n) + | T_regular _, _ -> -1 + | _, T_regular _ -> 1 + | T_method _a__015_, T_method _b__016_ -> ( + match compare _a__015_.self_typ _b__016_.self_typ with + | 0 -> Stdlib.compare (_a__015_.name : string) _b__016_.name + | n -> n) + | T_method _, _ -> -1 + | _, T_method _ -> 1 + | T_ext_method _a__017_, T_ext_method _b__018_ -> ( + match compare _a__017_.trait _b__018_.trait with + | 0 -> ( + match compare _a__017_.self_typ _b__018_.self_typ with + | 0 -> Stdlib.compare (_a__017_.name : string) _b__018_.name + | n -> n) + | n -> n) + : toplevel_id -> toplevel_id -> int) + let _ = compare + and _ = compare_toplevel_id let rec hash_fold_t hsv arg = match arg with @@ -129,35 +181,68 @@ include struct | T_byte -> Ppx_base.hash_fold_int hsv 2 | T_char -> Ppx_base.hash_fold_int hsv 3 | T_int -> Ppx_base.hash_fold_int hsv 4 - | T_int64 -> Ppx_base.hash_fold_int hsv 5 - | T_uint -> Ppx_base.hash_fold_int hsv 6 - | T_uint64 -> Ppx_base.hash_fold_int hsv 7 - | T_float -> Ppx_base.hash_fold_int hsv 8 - | T_double -> Ppx_base.hash_fold_int hsv 9 - | T_string -> Ppx_base.hash_fold_int hsv 10 - | T_option -> Ppx_base.hash_fold_int hsv 11 - | T_result -> Ppx_base.hash_fold_int hsv 12 - | T_error_value_result -> Ppx_base.hash_fold_int hsv 13 - | T_fixedarray -> Ppx_base.hash_fold_int hsv 14 - | T_bytes -> Ppx_base.hash_fold_int hsv 15 - | T_ref -> Ppx_base.hash_fold_int hsv 16 - | T_error -> Ppx_base.hash_fold_int hsv 17 + | T_int16 -> Ppx_base.hash_fold_int hsv 5 + | T_int64 -> Ppx_base.hash_fold_int hsv 6 + | T_uint -> Ppx_base.hash_fold_int hsv 7 + | T_uint16 -> Ppx_base.hash_fold_int hsv 8 + | T_uint64 -> Ppx_base.hash_fold_int hsv 9 + | T_float -> Ppx_base.hash_fold_int hsv 10 + | T_double -> Ppx_base.hash_fold_int hsv 11 + | T_string -> Ppx_base.hash_fold_int hsv 12 + | T_option -> Ppx_base.hash_fold_int hsv 13 + | T_result -> Ppx_base.hash_fold_int hsv 14 + | T_error_value_result -> Ppx_base.hash_fold_int hsv 15 + | T_fixedarray -> Ppx_base.hash_fold_int hsv 16 + | T_bytes -> Ppx_base.hash_fold_int hsv 17 + | T_ref -> Ppx_base.hash_fold_int hsv 18 + | T_error -> Ppx_base.hash_fold_int hsv 19 | Toplevel _ir -> - let hsv = Ppx_base.hash_fold_int hsv 18 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_string hsv _ir.pkg - in + let hsv = Ppx_base.hash_fold_int hsv 20 in + let hsv = Ppx_base.hash_fold_string hsv _ir.pkg in Ppx_base.hash_fold_string hsv _ir.id + | T_local _ir -> + let hsv = Ppx_base.hash_fold_int hsv 21 in + let hsv = hash_fold_toplevel_id hsv _ir.toplevel_id in + Ppx_base.hash_fold_string hsv _ir.name | Tuple _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 19 in - let hsv = hsv in + let hsv = Ppx_base.hash_fold_int hsv 22 in Ppx_base.hash_fold_int hsv _a0 | Constr _ir -> - let hsv = Ppx_base.hash_fold_int hsv 20 in + let hsv = Ppx_base.hash_fold_int hsv 23 in let hsv = hash_fold_t hsv _ir.ty in Constr_info.hash_fold_constr_tag hsv _ir.tag + and (hash_fold_toplevel_id : Ppx_base.state -> toplevel_id -> Ppx_base.state) + = + (fun hsv -> + fun arg -> + match arg with + | T_regular _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_string hsv _ir.pkg + in + Ppx_base.hash_fold_string hsv _ir.name + | T_method _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = hsv in + hash_fold_t hsv _ir.self_typ + in + Ppx_base.hash_fold_string hsv _ir.name + | T_ext_method _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = + let hsv = hsv in + hash_fold_t hsv _ir.trait + in + hash_fold_t hsv _ir.self_typ + in + Ppx_base.hash_fold_string hsv _ir.name + : Ppx_base.state -> toplevel_id -> Ppx_base.state) + and (hash : t -> Ppx_base.hash_value) = let func arg = Ppx_base.get_hash_value @@ -166,85 +251,135 @@ include struct in fun x -> func x + and (hash_toplevel_id : toplevel_id -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_toplevel_id hsv arg) + in + fun x -> func x + let _ = hash_fold_t + and _ = hash_fold_toplevel_id and _ = hash + and _ = hash_toplevel_id let rec equal = - (fun a__009_ b__010_ -> - if Stdlib.( == ) a__009_ b__010_ then true - else - match (a__009_, b__010_) with - | T_unit, T_unit -> true - | T_unit, _ -> false - | _, T_unit -> false - | T_bool, T_bool -> true - | T_bool, _ -> false - | _, T_bool -> false - | T_byte, T_byte -> true - | T_byte, _ -> false - | _, T_byte -> false - | T_char, T_char -> true - | T_char, _ -> false - | _, T_char -> false - | T_int, T_int -> true - | T_int, _ -> false - | _, T_int -> false - | T_int64, T_int64 -> true - | T_int64, _ -> false - | _, T_int64 -> false - | T_uint, T_uint -> true - | T_uint, _ -> false - | _, T_uint -> false - | T_uint64, T_uint64 -> true - | T_uint64, _ -> false - | _, T_uint64 -> false - | T_float, T_float -> true - | T_float, _ -> false - | _, T_float -> false - | T_double, T_double -> true - | T_double, _ -> false - | _, T_double -> false - | T_string, T_string -> true - | T_string, _ -> false - | _, T_string -> false - | T_option, T_option -> true - | T_option, _ -> false - | _, T_option -> false - | T_result, T_result -> true - | T_result, _ -> false - | _, T_result -> false - | T_error_value_result, T_error_value_result -> true - | T_error_value_result, _ -> false - | _, T_error_value_result -> false - | T_fixedarray, T_fixedarray -> true - | T_fixedarray, _ -> false - | _, T_fixedarray -> false - | T_bytes, T_bytes -> true - | T_bytes, _ -> false - | _, T_bytes -> false - | T_ref, T_ref -> true - | T_ref, _ -> false - | _, T_ref -> false - | T_error, T_error -> true - | T_error, _ -> false - | _, T_error -> false - | Toplevel _a__011_, Toplevel _b__012_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__011_.pkg : string) _b__012_.pkg) - (Stdlib.( = ) (_a__011_.id : string) _b__012_.id) - | Toplevel _, _ -> false - | _, Toplevel _ -> false - | Tuple _a__013_, Tuple _b__014_ -> - Stdlib.( = ) (_a__013_ : int) _b__014_ - | Tuple _, _ -> false - | _, Tuple _ -> false - | Constr _a__015_, Constr _b__016_ -> - Stdlib.( && ) - (equal _a__015_.ty _b__016_.ty) - (Constr_info.equal_constr_tag _a__015_.tag _b__016_.tag) + (fun a__019_ -> + fun b__020_ -> + if Stdlib.( == ) a__019_ b__020_ then true + else + match (a__019_, b__020_) with + | T_unit, T_unit -> true + | T_unit, _ -> false + | _, T_unit -> false + | T_bool, T_bool -> true + | T_bool, _ -> false + | _, T_bool -> false + | T_byte, T_byte -> true + | T_byte, _ -> false + | _, T_byte -> false + | T_char, T_char -> true + | T_char, _ -> false + | _, T_char -> false + | T_int, T_int -> true + | T_int, _ -> false + | _, T_int -> false + | T_int16, T_int16 -> true + | T_int16, _ -> false + | _, T_int16 -> false + | T_int64, T_int64 -> true + | T_int64, _ -> false + | _, T_int64 -> false + | T_uint, T_uint -> true + | T_uint, _ -> false + | _, T_uint -> false + | T_uint16, T_uint16 -> true + | T_uint16, _ -> false + | _, T_uint16 -> false + | T_uint64, T_uint64 -> true + | T_uint64, _ -> false + | _, T_uint64 -> false + | T_float, T_float -> true + | T_float, _ -> false + | _, T_float -> false + | T_double, T_double -> true + | T_double, _ -> false + | _, T_double -> false + | T_string, T_string -> true + | T_string, _ -> false + | _, T_string -> false + | T_option, T_option -> true + | T_option, _ -> false + | _, T_option -> false + | T_result, T_result -> true + | T_result, _ -> false + | _, T_result -> false + | T_error_value_result, T_error_value_result -> true + | T_error_value_result, _ -> false + | _, T_error_value_result -> false + | T_fixedarray, T_fixedarray -> true + | T_fixedarray, _ -> false + | _, T_fixedarray -> false + | T_bytes, T_bytes -> true + | T_bytes, _ -> false + | _, T_bytes -> false + | T_ref, T_ref -> true + | T_ref, _ -> false + | _, T_ref -> false + | T_error, T_error -> true + | T_error, _ -> false + | _, T_error -> false + | Toplevel _a__021_, Toplevel _b__022_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__021_.pkg : string) _b__022_.pkg) + (Stdlib.( = ) (_a__021_.id : string) _b__022_.id) + | Toplevel _, _ -> false + | _, Toplevel _ -> false + | T_local _a__023_, T_local _b__024_ -> + Stdlib.( && ) + (equal_toplevel_id _a__023_.toplevel_id _b__024_.toplevel_id) + (Stdlib.( = ) (_a__023_.name : string) _b__024_.name) + | T_local _, _ -> false + | _, T_local _ -> false + | Tuple _a__025_, Tuple _b__026_ -> + Stdlib.( = ) (_a__025_ : int) _b__026_ + | Tuple _, _ -> false + | _, Tuple _ -> false + | Constr _a__027_, Constr _b__028_ -> + Stdlib.( && ) + (equal _a__027_.ty _b__028_.ty) + (Constr_info.equal_constr_tag _a__027_.tag _b__028_.tag) : t -> t -> bool) + and equal_toplevel_id = + (fun a__029_ -> + fun b__030_ -> + if Stdlib.( == ) a__029_ b__030_ then true + else + match (a__029_, b__030_) with + | T_regular _a__031_, T_regular _b__032_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__031_.pkg : string) _b__032_.pkg) + (Stdlib.( = ) (_a__031_.name : string) _b__032_.name) + | T_regular _, _ -> false + | _, T_regular _ -> false + | T_method _a__033_, T_method _b__034_ -> + Stdlib.( && ) + (equal _a__033_.self_typ _b__034_.self_typ) + (Stdlib.( = ) (_a__033_.name : string) _b__034_.name) + | T_method _, _ -> false + | _, T_method _ -> false + | T_ext_method _a__035_, T_ext_method _b__036_ -> + Stdlib.( && ) + (equal _a__035_.trait _b__036_.trait) + (Stdlib.( && ) + (equal _a__035_.self_typ _b__036_.self_typ) + (Stdlib.( = ) (_a__035_.name : string) _b__036_.name)) + : toplevel_id -> toplevel_id -> bool) + let _ = equal + and _ = equal_toplevel_id end let equal t1 t2 = @@ -258,8 +393,10 @@ let rec name_aux ~compress ~cur_pkg_name = function | T_byte -> "Byte" | T_char -> "Char" | T_int -> "Int" + | T_int16 -> "Int16" | T_int64 -> "Int64" | T_uint -> "UInt" + | T_uint16 -> "UInt16" | T_uint64 -> "UInt64" | T_float -> "Float" | T_double -> "Double" @@ -282,16 +419,46 @@ let rec name_aux ~compress ~cur_pkg_name = function let pkg = Map_string.find_default !Config.current_import_map pkg pkg in - Stdlib.String.concat "" [ "@"; pkg; "."; id ] - | _ -> Stdlib.String.concat "" [ "@"; pkg; "."; id ]) - | Tuple n -> ("Tuple" ^ Int.to_string n : Stdlib.String.t) + (Stdlib.String.concat "" [ "@"; pkg; "."; id ] [@merlin.hide]) + | _ -> Stdlib.String.concat "" [ "@"; pkg; "."; id ] [@merlin.hide]) + | Tuple n -> ("Tuple" ^ Int.to_string n : Stdlib.String.t) [@merlin.hide] | Constr { ty; tag = Constr_tag_regular { name_; _ } | Extensible_tag { name = name_; _ }; } -> - (name_aux ~compress ~cur_pkg_name ty ^ "." ^ name_ : Stdlib.String.t) + (name_aux ~compress ~cur_pkg_name ty ^ "." ^ name_ + : Stdlib.String.t) + [@merlin.hide] + | T_local { toplevel_id; name } -> + if compress then name + else + let toplevel_id = toplevel_id_to_string toplevel_id in + ((toplevel_id ^ "." ^ name : Stdlib.String.t) [@merlin.hide]) + +and toplevel_id_to_string (id : toplevel_id) = + (match id with + | T_regular { pkg; name } -> + if pkg = "" then name + else if pkg = Config.builtin_package then "$builtin." ^ name + else Stdlib.String.concat "" [ "$"; pkg; "."; name ] [@merlin.hide] + | T_method { self_typ; name } -> + let typ_str = name_aux ~cur_pkg_name:None ~compress:false self_typ in + ((typ_str ^ "::" ^ name : Stdlib.String.t) [@merlin.hide]) + | T_ext_method { trait; self_typ; name } -> + let trait_str = name_aux ~cur_pkg_name:None ~compress:false trait in + let typ_str = name_aux ~cur_pkg_name:None ~compress:false self_typ in + (Stdlib.String.concat "" + [ trait_str; "::"; name; "|"; typ_str; "|" ] [@merlin.hide]) + : string) + +let map_toplevel_id id f = + match id with + | T_regular { pkg; name } -> T_regular { pkg; name = f name } + | T_method { self_typ; name } -> T_method { self_typ; name = f name } + | T_ext_method { trait; self_typ; name } -> + T_ext_method { trait; self_typ; name = f name } let export_name ?cur_pkg_name t = name_aux ~compress:false ~cur_pkg_name t let short_name ~cur_pkg_name t = name_aux ~compress:true ~cur_pkg_name t @@ -299,7 +466,9 @@ let short_name ~cur_pkg_name t = name_aux ~compress:true ~cur_pkg_name t let sexp_of_t t = S.Atom (export_name t) +let sexp_of_toplevel_id id = S.Atom (toplevel_id_to_string id) let toplevel_type ~pkg t = Toplevel { pkg; id = t } +let local_type toplevel_id name = T_local { toplevel_id; name } let constr ~ty ~tag = Constr { ty; tag } let tuple n = Tuple n @@ -314,6 +483,11 @@ let rec get_pkg t = | Toplevel { pkg; id } when pkg = Config.builtin_package && id = "BigInt" -> "moonbitlang/core/bigint" | T_fixedarray -> "moonbitlang/core/array" + | T_local { toplevel_id; _ } -> ( + match toplevel_id with + | T_regular _ -> !Config.current_package + | T_method { self_typ; _ } -> get_pkg self_typ + | T_ext_method { trait; _ } -> get_pkg trait) | Toplevel { pkg; id = _ } -> pkg | Constr { ty; tag = _ } -> get_pkg ty | Tuple _ -> "moonbitlang/core/tuple" @@ -322,8 +496,10 @@ let rec get_pkg t = | T_byte -> "moonbitlang/core/byte" | T_char -> "moonbitlang/core/char" | T_int -> "moonbitlang/core/int" + | T_int16 -> "moonbitlang/core/int16" | T_int64 -> "moonbitlang/core/int64" | T_uint -> "moonbitlang/core/uint" + | T_uint16 -> "moonbitlang/core/uint16" | T_uint64 -> "moonbitlang/core/uint64" | T_float -> "moonbitlang/core/float" | T_double -> "moonbitlang/core/double" @@ -335,13 +511,48 @@ let rec get_pkg t = | T_error -> "moonbitlang/core/error" | T_error_value_result -> "moonbitlang/core/result" +let rec get_base_id t = + match t with + | Toplevel { id; _ } -> id + | T_fixedarray -> "FixedArray" + | T_local { name; _ } -> name + | Constr { ty; tag = _ } -> get_base_id ty + | Tuple i -> "Tuple" ^ string_of_int i + | T_unit -> "Unit" + | T_bool -> "Bool" + | T_byte -> "Byte" + | T_char -> "Char" + | T_int16 -> "Int16" + | T_uint16 -> "UInt16" + | T_int -> "Int" + | T_int64 -> "Int64" + | T_uint -> "UInt" + | T_uint64 -> "UInt64" + | T_float -> "Float" + | T_double -> "Double" + | T_string -> "String" + | T_option -> "Option" + | T_result -> "Result" + | T_bytes -> "Bytes" + | T_ref -> "Ref" + | T_error -> "Error" + | T_error_value_result -> "Result" + +let pkg_of_toplevel_id (id : toplevel_id) = + match id with + | T_regular { pkg; _ } -> pkg + | T_method { self_typ; _ } -> get_pkg self_typ + | T_ext_method { trait; _ } -> get_pkg trait + let can_be_extended_from_builtin t = match t with - | Tuple _ | T_unit | T_bool | T_byte | T_char | T_int | T_int64 | T_uint - | T_uint64 | T_float | T_double | T_string | T_option | T_result | T_bytes - | T_fixedarray | T_ref | T_error | T_error_value_result -> + | Tuple _ | T_unit | T_bool | T_byte | T_char | T_int | T_int16 | T_int64 + | T_uint | T_uint16 | T_uint64 | T_float | T_double | T_string | T_option + | T_result | T_bytes | T_fixedarray | T_ref | T_error | T_error_value_result + -> true | Toplevel { pkg; id = _ } -> pkg = Config.builtin_package + | T_local _ -> false | Constr _ -> false module Builtin = struct @@ -350,8 +561,10 @@ module Builtin = struct let type_path_byte = T_byte let type_path_char = T_char let type_path_int = T_int + let type_path_int16 = T_int16 let type_path_int64 = T_int64 let type_path_uint = T_uint + let type_path_uint16 = T_uint16 let type_path_uint64 = T_uint64 let type_path_float = T_float let type_path_double = T_double @@ -386,6 +599,15 @@ module Builtin = struct let type_path_iter_result = Toplevel { pkg = Config.builtin_package; id = "IterResult" } + let type_path_bytesview = + Toplevel { pkg = Config.builtin_package; id = "BytesView" } + + let type_path_bytes_view = + Toplevel { pkg = "moonbitlang/core/bytes"; id = "View" } + + let type_path_stringview = + Toplevel { pkg = "moonbitlang/core/string"; id = "StringView" } + let type_path_foreach_result = Toplevel { pkg = Config.builtin_package; id = "ForeachResult" } @@ -395,6 +617,9 @@ module Builtin = struct let type_path_maybe_uninit = Toplevel { pkg = Config.builtin_package; id = "UnsafeMaybeUninit" } + let type_path_func_ref = + Toplevel { pkg = Config.builtin_package; id = "FuncRef" } + let trait_eq = Toplevel { pkg = Config.builtin_package; id = "Eq" } let trait_compare = Toplevel { pkg = Config.builtin_package; id = "Compare" } let trait_hash = Toplevel { pkg = Config.builtin_package; id = "Hash" } @@ -452,3 +677,6 @@ let can_use_array_pattern (p : t) = let is_multi_value_result (p : t) = match p with T_error_value_result -> true | _ -> false + +let is_bytesview t = + equal t Builtin.type_path_bytesview || equal t Builtin.type_path_bytes_view diff --git a/src/basic_uchar_utils.ml b/src/basic_uchar_utils.ml index e7063b5..7c81773 100644 --- a/src/basic_uchar_utils.ml +++ b/src/basic_uchar_utils.ml @@ -15,10 +15,11 @@ type uchar = Uchar.t -let uchar_to_string (c : Uchar.t) : string = - let buf = Buffer.create 4 in - Buffer.add_utf_8_uchar buf c; - Buffer.contents buf +let uchar_to_string (c : Uchar.t) = + (let buf = Buffer.create 4 in + Buffer.add_utf_8_uchar buf c; + Buffer.contents buf + : string) let to_string (t : Uchar.t) = Printf.sprintf "U+%04X" (Uchar.to_int t) diff --git a/src/basic_uint32.ml b/src/basic_uint32.ml index 4189a54..3559c0e 100644 --- a/src/basic_uint32.ml +++ b/src/basic_uint32.ml @@ -34,7 +34,7 @@ let logxor = Int32.logxor let shift_left = Int32.shift_left let shift_right = Int32.shift_right_logical let to_int32 x = x -let of_int32 (x : int32) : t = x +let of_int32 (x : int32) = (x : t) let min x y = match compare x y with -1 -> x | _ -> y let max x y = match compare x y with 1 -> x | _ -> y diff --git a/src/basic_uint64.ml b/src/basic_uint64.ml index 963f10a..3f66428 100644 --- a/src/basic_uint64.ml +++ b/src/basic_uint64.ml @@ -33,7 +33,7 @@ let logor = Int64.logor let logxor = Int64.logxor let shift_left = Int64.shift_left let shift_right = Int64.shift_right_logical -let of_int64 (x : int64) : t = x +let of_int64 (x : int64) = (x : t) let to_int64 x = x let min x y = match compare x y with -1 -> x | _ -> y let max x y = match compare x y with 1 -> x | _ -> y diff --git a/src/basic_utf8.ml b/src/basic_utf8.ml index 5fe08ad..c73abca 100644 --- a/src/basic_utf8.ml +++ b/src/basic_utf8.ml @@ -37,95 +37,107 @@ let sub (s : string) ofs len = let epos = get_index spos len in String.sub s spos (epos - spos) -let unsafe_utf8_of_string (s : string) slen (a : int array) : int = - let spos = ref 0 in - let apos = ref 0 in - while !spos < slen do - let spos_code = s.![!spos] in - (match spos_code with - | '\000' .. '\127' as c -> - a.!(!apos) <- Char.code c; - incr spos - | '\192' .. '\223' as c -> - let n1 = Char.code c in - let n2 = Char.code s.![!spos + 1] in - if n2 lsr 6 <> 0b10 then raise MalFormed; - a.!(!apos) <- ((n1 land 0x1f) lsl 6) lor (n2 land 0x3f); - spos := !spos + 2 - | '\224' .. '\239' as c -> - let n1 = Char.code c in - let n2 = Char.code s.![!spos + 1] in - let n3 = Char.code s.![!spos + 2] in - let p = - ((n1 land 0x0f) lsl 12) lor ((n2 land 0x3f) lsl 6) lor (n3 land 0x3f) - in - if (n2 lsr 6 <> 0b10 || n3 lsr 6 <> 0b10) || (p >= 0xd800 && p <= 0xdfff) - then raise MalFormed; - a.!(!apos) <- p; - spos := !spos + 3 - | '\240' .. '\247' as c -> - let n1 = Char.code c in - let n2 = Char.code s.![!spos + 1] in - let n3 = Char.code s.![!spos + 2] in - let n4 = Char.code s.![!spos + 3] in - if n2 lsr 6 <> 0b10 || n3 lsr 6 <> 0b10 || n4 lsr 6 <> 0b10 then - raise MalFormed; - let p = - ((n1 land 0x07) lsl 18) - lor ((n2 land 0x3f) lsl 12) - lor ((n3 land 0x3f) lsl 6) - lor (n4 land 0x3f) - in - if p > 0x10ffff then raise MalFormed; - a.!(!apos) <- p; - spos := !spos + 4 - | _ -> raise MalFormed); - incr apos - done; - !apos +let unsafe_utf8_of_string ~offset ~len (s : string) (a : int array) = + (let spos = ref offset in + let apos = ref 0 in + let end_ = offset + len in + while !spos < end_ do + let spos_code = s.![!spos] in + (match spos_code with + | '\000' .. '\127' as c -> + a.!(!apos) <- Char.code c; + incr spos + | '\192' .. '\223' as c -> + let n1 = Char.code c in + let n2 = Char.code s.![!spos + 1] in + if n2 lsr 6 <> 0b10 then raise MalFormed; + a.!(!apos) <- ((n1 land 0x1f) lsl 6) lor (n2 land 0x3f); + spos := !spos + 2 + | '\224' .. '\239' as c -> + let n1 = Char.code c in + let n2 = Char.code s.![!spos + 1] in + let n3 = Char.code s.![!spos + 2] in + let p = + ((n1 land 0x0f) lsl 12) lor ((n2 land 0x3f) lsl 6) lor (n3 land 0x3f) + in + if + (n2 lsr 6 <> 0b10 || n3 lsr 6 <> 0b10) || (p >= 0xd800 && p <= 0xdfff) + then raise MalFormed; + a.!(!apos) <- p; + spos := !spos + 3 + | '\240' .. '\247' as c -> + let n1 = Char.code c in + let n2 = Char.code s.![!spos + 1] in + let n3 = Char.code s.![!spos + 2] in + let n4 = Char.code s.![!spos + 3] in + if n2 lsr 6 <> 0b10 || n3 lsr 6 <> 0b10 || n4 lsr 6 <> 0b10 then + raise MalFormed; + let p = + ((n1 land 0x07) lsl 18) + lor ((n2 land 0x3f) lsl 12) + lor ((n3 land 0x3f) lsl 6) + lor (n4 land 0x3f) + in + if p > 0x10ffff then raise MalFormed; + a.!(!apos) <- p; + spos := !spos + 4 + | _ -> raise MalFormed); + incr apos + done; + !apos + : int) + +let from_sub_string s ~offset ~len = + if offset < 0 || len < 0 || offset + len > String.length s then + invalid_arg __FUNCTION__; + let a = Array.make len 0 in + let len = unsafe_utf8_of_string ~offset ~len s a in + Vec_int.of_sub_array a 0 len let from_string s = let slen = String.length s in let a = Array.make slen 0 in - let len = unsafe_utf8_of_string s slen a in + let len = unsafe_utf8_of_string ~offset:0 ~len:slen s a in Vec_int.of_sub_array a 0 len let unsafe_string_of_utf8 (a : int array) ~(offset : int) ~(len : int) - (b : bytes) : int = - let apos = ref offset in - let len = ref len in - let i = ref 0 in - while !len > 0 do - let u = a.!(!apos) in - if u < 0 then raise MalFormed - else if u <= 0x007F then ( - b.![!i] <- Char.unsafe_chr u; - incr i) - else if u <= 0x07FF then ( - b.![!i] <- Char.unsafe_chr (0xC0 lor (u lsr 6)); - b.![!i + 1] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); - i := !i + 2) - else if u <= 0xFFFF then ( - b.![!i] <- Char.unsafe_chr (0xE0 lor (u lsr 12)); - b.![!i + 1] <- Char.unsafe_chr (0x80 lor ((u lsr 6) land 0x3F)); - b.![!i + 2] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); - i := !i + 3) - else if u <= 0x10FFFF then ( - b.![!i] <- Char.unsafe_chr (0xF0 lor (u lsr 18)); - b.![!i + 1] <- Char.unsafe_chr (0x80 lor ((u lsr 12) land 0x3F)); - b.![!i + 2] <- Char.unsafe_chr (0x80 lor ((u lsr 6) land 0x3F)); - b.![!i + 3] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); - i := !i + 4) - else raise MalFormed; - incr apos; - decr len - done; - !i + (b : bytes) = + (let apos = ref offset in + let len = ref len in + let i = ref 0 in + while !len > 0 do + let u = a.!(!apos) in + if u < 0 then raise MalFormed + else if u <= 0x007F then ( + b.![!i] <- Char.unsafe_chr u; + incr i) + else if u <= 0x07FF then ( + b.![!i] <- Char.unsafe_chr (0xC0 lor (u lsr 6)); + b.![!i + 1] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); + i := !i + 2) + else if u <= 0xFFFF then ( + b.![!i] <- Char.unsafe_chr (0xE0 lor (u lsr 12)); + b.![!i + 1] <- Char.unsafe_chr (0x80 lor ((u lsr 6) land 0x3F)); + b.![!i + 2] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); + i := !i + 3) + else if u <= 0x10FFFF then ( + b.![!i] <- Char.unsafe_chr (0xF0 lor (u lsr 18)); + b.![!i + 1] <- Char.unsafe_chr (0x80 lor ((u lsr 12) land 0x3F)); + b.![!i + 2] <- Char.unsafe_chr (0x80 lor ((u lsr 6) land 0x3F)); + b.![!i + 3] <- Char.unsafe_chr (0x80 lor (u land 0x3F)); + i := !i + 4) + else raise MalFormed; + incr apos; + decr len + done; + !i + : int) -let string_of_utf8 (lexbuf : int array) ~offset ~len : string = - let b = Bytes.create (len * 4) in - let i = unsafe_string_of_utf8 lexbuf ~offset ~len b in - Bytes.sub_string b 0 i +let string_of_utf8 (lexbuf : int array) ~offset ~len = + (let b = Bytes.create (len * 4) in + let i = unsafe_string_of_utf8 lexbuf ~offset ~len b in + Bytes.sub_string b 0 i + : string) let string_of_vec (v : Vec_int.t) ~offset ~len = if offset < 0 || len < 0 || offset + len > v.len then invalid_arg __FUNCTION__ diff --git a/src/basic_vec.ml b/src/basic_vec.ml index 0b935f6..b78bb1b 100644 --- a/src/basic_vec.ml +++ b/src/basic_vec.ml @@ -33,7 +33,6 @@ open struct if tag (repr a) = double_array_tag then Array.fill (as_float_arr a) i len 0. else Array.fill (as_obj_arr a) i len (Obj.repr ()) - ;; end external unsafe_sub : 'a array -> int -> int -> 'a array = "caml_array_sub" @@ -73,6 +72,7 @@ let sort d cmp = d.len <- Array.length arr ;; +let of_array src = { len = Array.length src; arr = Array.copy src } let reverse_in_place src = Arr.reverse_range src.arr 0 src.len let iter f d = @@ -117,7 +117,7 @@ let map_into_array f src = arr) ;; -let map_into_list src f = +let map_into_list src ~unorder:f = let src_len = src.len in let src_arr = src.arr in if src_len = 0 @@ -185,10 +185,21 @@ let set d i v = let capacity d = Array.length d.arr [@@inline] +let map f src = + let src_len = src.len in + if src_len = 0 then { len = 0; arr = [||] } + else + let src_arr = src.arr in + let first = f src_arr.!(0) in + let arr = Array.make src_len first in + for i = 1 to src_len - 1 do + arr.!(i) <- f src_arr.!(i) + done; + { len = src_len; arr } + let make ~dummy initsize : 'a t = if initsize < 0 then invalid_arg __FUNCTION__; { len = 0; arr = Array.make initsize dummy } -;; let push (d : 'a t) v = let d_len = d.len in @@ -240,7 +251,6 @@ let pop_opt (d : 'a t) : 'a option = fill_with_junk_ d_arr last_index 1; d.len <- last_index; Some last) -;; let pop (d : 'a t) : 'a = let d_len = d.len in @@ -253,7 +263,6 @@ let pop (d : 'a t) : 'a = fill_with_junk_ d_arr last_index 1; d.len <- last_index; last) -;; (* Example usage of array-like operators: @@ -273,4 +282,3 @@ let ( .![]<- ) d i v = set d i v let clear (d : 'a t) : unit = fill_with_junk_ d.arr 0 d.len; d.len <- 0 -;; diff --git a/src/basic_vec_int.ml b/src/basic_vec_int.ml index 9129664..895e734 100644 --- a/src/basic_vec_int.ml +++ b/src/basic_vec_int.ml @@ -70,7 +70,7 @@ let map_into_array f src = done; arr -let map_into_list src f = +let map_into_list src ~unorder:f = let src_len = src.len in let src_arr = src.arr in if src_len = 0 then [] @@ -92,15 +92,16 @@ let mapi f src = done; { len; arr } -let equal eq x y : bool = - if x.len <> y.len then false - else - let rec aux x_arr y_arr i = - if i < 0 then true - else if eq x_arr.!(i) y_arr.!(i) then aux x_arr y_arr (i - 1) - else false - in - aux x.arr y.arr (x.len - 1) +let equal eq x y = + (if x.len <> y.len then false + else + let rec aux x_arr y_arr i = + if i < 0 then true + else if eq x_arr.!(i) y_arr.!(i) then aux x_arr y_arr (i - 1) + else false + in + aux x.arr y.arr (x.len - 1) + : bool) let unsafe_get d i = d.arr.!(i) let last d = if d.len <= 0 then invalid_arg __FUNCTION__ else d.arr.!(d.len - 1) @@ -136,9 +137,10 @@ let init len f = done; { len; arr } -let make initsize : t = - if initsize < 0 then invalid_arg __FUNCTION__; - { len = 0; arr = Array.make initsize 0 } +let make initsize = + (if initsize < 0 then invalid_arg __FUNCTION__; + { len = 0; arr = Array.make initsize 0 } + : t) let push (d : t) v = let d_len = d.len in @@ -157,14 +159,15 @@ let push (d : t) v = d.len <- d_len + 1; d.arr.!(d_len) <- v) -let get_and_delete_range (d : t) idx len : t = - let d_len = d.len in - if len < 0 || idx < 0 || idx + len > d_len then invalid_arg __FUNCTION__; - let arr = d.arr in - let value = unsafe_sub arr idx len in - unsafe_blit arr (idx + len) arr idx (d_len - idx - len); - d.len <- d_len - len; - { len; arr = value } +let get_and_delete_range (d : t) idx len = + (let d_len = d.len in + if len < 0 || idx < 0 || idx + len > d_len then invalid_arg __FUNCTION__; + let arr = d.arr in + let value = unsafe_sub arr idx len in + unsafe_blit arr (idx + len) arr idx (d_len - idx - len); + d.len <- d_len - len; + { len; arr = value } + : t) let get d i = if i < 0 || i >= d.len then invalid_arg (__FUNCTION__ ^ " " ^ string_of_int i) @@ -196,3 +199,9 @@ let arg_min (d : t) = index := i) done; !index + +let iteri d f = + let arr = d.arr in + for i = 0 to d.len - 1 do + f i arr.!(i) + done diff --git a/src/basic_vec_string.ml b/src/basic_vec_string.ml new file mode 100644 index 0000000..d938bb2 --- /dev/null +++ b/src/basic_vec_string.ml @@ -0,0 +1,101 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Unsafe_external = Basic_unsafe_external +open Unsafe_external + +type elt = string + +let min (x : int) y = if x < y then x else y [@@inline] +let unsafe_blit = Array.blit + +type t = { mutable arr : string array; mutable len : int } + +let sexp_of_t x = + Moon_sexp_conv.sexp_of_array Moon_sexp_conv.sexp_of_string + (Array.sub x.arr 0 x.len) + +let length d = d.len +let empty () = { len = 0; arr = [||] } + +let of_list lst = + let arr = Array.of_list lst in + { arr; len = Array.length arr } + +let of_array src = { len = Array.length src; arr = Array.copy src } + +let iter d f = + let arr = d.arr in + for i = 0 to d.len - 1 do + f arr.!(i) + done + +let iteri d f = + let arr = d.arr in + for i = 0 to d.len - 1 do + f i arr.!(i) + done + +let get d i = + if i < 0 || i >= d.len then invalid_arg (__FUNCTION__ ^ " " ^ string_of_int i) + else d.arr.!(i) + +let last d = if d.len <= 0 then invalid_arg __FUNCTION__ else d.arr.!(d.len - 1) + +let set d i v = + if i < 0 || i >= d.len then invalid_arg (__FUNCTION__ ^ " " ^ string_of_int i) + else d.arr.!(i) <- v + +let map f src = + let src_len = src.len in + let src_arr = src.arr in + let arr = Array.make src_len "" in + for i = 0 to src_len - 1 do + arr.!(i) <- f src_arr.!(i) + done; + { len = src_len; arr } + +let make initsize = + (if initsize < 0 then invalid_arg __FUNCTION__; + { len = 0; arr = Array.make initsize "" } + : t) + +let push (d : t) v = + let d_len = d.len in + let d_arr = d.arr in + let d_arr_len = Array.length d_arr in + if d_arr_len = 0 then ( + d.len <- 1; + d.arr <- [| v |]) + else ( + if d_len = d_arr_len then ( + if d_len >= Sys.max_array_length then failwith "exceeds max_array_length"; + let new_capacity = min Sys.max_array_length d_len * 2 in + let new_d_arr = Array.make new_capacity "" in + d.arr <- new_d_arr; + unsafe_blit d_arr 0 new_d_arr 0 d_len); + d.len <- d_len + 1; + d.arr.!(d_len) <- v) + +let map_into_list src ~unorder:f = + let src_len = src.len in + let src_arr = src.arr in + if src_len = 0 then [] + else + let acc = ref [] in + for i = src_len - 1 downto 0 do + acc := f src_arr.!(i) :: !acc + done; + !acc diff --git a/src/builtin.ml b/src/builtin.ml index 0c6eb5a..15eb82e 100644 --- a/src/builtin.ml +++ b/src/builtin.ml @@ -15,75 +15,77 @@ module B = Stype.Type_path.Builtin module Type_path = Basic_type_path +module Constr_info = Basic_constr_info -let f desc t : Stype.t = - T_constr - { - type_constructor = desc; - tys = [ t ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let f desc t = + (T_constr + { + type_constructor = desc; + tys = [ t ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) let type_array = f B.type_path_array let type_fixedarray = f B.type_path_fixedarray let type_maybe_uninit = f B.type_path_maybe_uninit -let type_arrow t1 t2 ~err_ty : Stype.t = - Tarrow { params_ty = t1; ret_ty = t2; generic_ = false; err_ty } +let type_arrow t1 t2 ~err_ty ~is_async = + (Tarrow { params_ty = t1; ret_ty = t2; generic_ = false; err_ty; is_async } + : Stype.t) -let type_product ts : Stype.t = - T_constr - { - type_constructor = Type_path.tuple (List.length ts); - tys = ts; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_product ts = + (T_constr + { + type_constructor = Type_path.tuple (List.length ts); + tys = ts; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) -let type_ref ty : Stype.t = - T_constr - { - type_constructor = B.type_path_ref; - tys = [ ty ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_ref ty = + (T_constr + { + type_constructor = B.type_path_ref; + tys = [ ty ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) -let type_option ty : Stype.t = - T_constr - { - type_constructor = B.type_path_option; - tys = [ ty ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_option ty = + (T_constr + { + type_constructor = B.type_path_option; + tys = [ ty ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) -let type_map key value : Stype.t = - T_constr - { - type_constructor = B.type_path_map; - tys = [ key; value ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_map key value = + (T_constr + { + type_constructor = B.type_path_map; + tys = [ key; value ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) -let type_iter ty : Stype.t = f B.type_path_iter ty +let type_iter ty = (f B.type_path_iter ty : Stype.t) -let type_iter2 key value : Stype.t = - T_constr - { - type_constructor = B.type_path_iter2; - tys = [ key; value ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_iter2 key value = + (T_constr + { + type_constructor = B.type_path_iter2; + tys = [ key; value ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) let tvar_env_1 = Tvar_env.tvar_env_1 let generic_var = Stype.param0 @@ -98,13 +100,17 @@ let constr_none : Typedecl_info.constructor = type_constructor = B.type_path_option; tys = [ arg ]; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; }; cs_args = []; cs_tag = Constr_tag_regular - { total = 2; index = 0; name_ = "None"; is_constant_ = true }; + { + total = Constr_info.Index_set.singleton 0 1; + index = 0; + name_ = "None"; + repr_ = Constant; + }; cs_vis = Read_write; cs_ty_params_ = tvar_env_1; cs_arity_ = Fn_arity.simple 0; @@ -122,13 +128,17 @@ let constr_some : Typedecl_info.constructor = type_constructor = B.type_path_option; tys = [ arg ]; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; }; cs_args = [ arg ]; cs_tag = Constr_tag_regular - { total = 2; index = 1; name_ = "Some"; is_constant_ = false }; + { + total = Constr_info.Index_set.singleton 0 1; + index = 1; + name_ = "Some"; + repr_ = Non_constant; + }; cs_vis = Read_write; cs_ty_params_ = tvar_env_1; cs_arity_ = Fn_arity.simple 1; @@ -148,7 +158,6 @@ let field_val : Typedecl_info.field = type_constructor = B.type_path_ref; tys = [ arg ]; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; }; mut = true; @@ -175,12 +184,16 @@ let constr_ok : Typedecl_info.constructor = type_constructor = B.type_path_result; tys = [ ty_ok; ty_err ]; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; }; cs_tag = Constr_tag_regular - { total = 2; index = 1; name_ = "Ok"; is_constant_ = false }; + { + total = Constr_info.Index_set.singleton 0 1; + index = 1; + name_ = "Ok"; + repr_ = Non_constant; + }; cs_vis = Read_write; cs_ty_params_ = tvar_env_2; cs_arity_ = Fn_arity.simple 1; @@ -200,12 +213,16 @@ let constr_err : Typedecl_info.constructor = type_constructor = B.type_path_result; tys = [ ty_ok; ty_err ]; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; }; cs_tag = Constr_tag_regular - { total = 2; index = 0; name_ = "Err"; is_constant_ = false }; + { + total = Constr_info.Index_set.singleton 0 1; + index = 0; + name_ = "Err"; + repr_ = Non_constant; + }; cs_vis = Read_write; cs_ty_params_ = tvar_env_2; cs_arity_ = Fn_arity.simple 1; @@ -219,31 +236,35 @@ type local_typedecl_info = { ty_desc : Typedecl_info.type_components; } -let f_poly1 (t : local_typedecl_info) : Typedecl_info.t = - { - ty_constr = t.ty_constr; - ty_arity = t.ty_arity; - ty_desc = t.ty_desc; - ty_vis = Vis_fully_pub; - ty_params_ = tvar_env_1; - ty_loc_ = Loc.no_location; - ty_doc_ = Docstring.empty; - ty_is_only_tag_enum_ = false; - ty_is_suberror_ = false; - } +let f_poly1 (t : local_typedecl_info) = + ({ + ty_constr = t.ty_constr; + ty_arity = t.ty_arity; + ty_desc = t.ty_desc; + ty_vis = Vis_fully_pub; + ty_params_ = tvar_env_1; + ty_loc_ = Loc.no_location; + ty_doc_ = Docstring.empty; + ty_attrs = []; + ty_is_only_tag_enum_ = false; + ty_is_suberror_ = false; + } + : Typedecl_info.t) -let f_poly2 (t : local_typedecl_info) : Typedecl_info.t = - { - ty_constr = t.ty_constr; - ty_arity = t.ty_arity; - ty_desc = t.ty_desc; - ty_vis = Vis_fully_pub; - ty_params_ = tvar_env_2; - ty_loc_ = Loc.no_location; - ty_doc_ = Docstring.empty; - ty_is_only_tag_enum_ = false; - ty_is_suberror_ = false; - } +let f_poly2 (t : local_typedecl_info) = + ({ + ty_constr = t.ty_constr; + ty_arity = t.ty_arity; + ty_desc = t.ty_desc; + ty_vis = Vis_fully_pub; + ty_params_ = tvar_env_2; + ty_loc_ = Loc.no_location; + ty_doc_ = Docstring.empty; + ty_attrs = []; + ty_is_only_tag_enum_ = false; + ty_is_suberror_ = false; + } + : Typedecl_info.t) let ty_constr_option : Typedecl_info.t = f_poly1 @@ -287,6 +308,21 @@ let ty_constr_error : Typedecl_info.t = ty_params_ = tvar_env_1; ty_loc_ = Loc.no_location; ty_doc_ = Docstring.empty; + ty_attrs = []; + ty_is_only_tag_enum_ = false; + ty_is_suberror_ = false; + } + +let ty_constr_func_ref : Typedecl_info.t = + { + ty_constr = B.type_path_func_ref; + ty_arity = 1; + ty_desc = Abstract_type; + ty_vis = Vis_fully_pub; + ty_params_ = tvar_env_1; + ty_loc_ = Loc.no_location; + ty_doc_ = Docstring.empty; + ty_attrs = []; ty_is_only_tag_enum_ = false; ty_is_suberror_ = false; } @@ -294,20 +330,22 @@ let ty_constr_error : Typedecl_info.t = let builtin_types = Typing_info.make_types () let _ = - [ - ty_constr_option; - ty_constr_fixedarray; - ty_constr_ref; - ty_constr_result; - ty_constr_error; - ] - |> List.iter (fun (t : Typedecl_info.t) -> - Typing_info.add_type builtin_types (Type_path_util.name t.ty_constr) t) + Basic_lst.iter + ~f:(fun (t : Typedecl_info.t) -> + Typing_info.add_type builtin_types (Type_path_util.name t.ty_constr) t) + [ + ty_constr_option; + ty_constr_fixedarray; + ty_constr_ref; + ty_constr_result; + ty_constr_error; + ty_constr_func_ref; + ] let builtin_values : Typing_info.values = Typing_info.make_values () let _ = - List.iter - (Typing_info.add_constructor builtin_values) - [ constr_none; constr_some; constr_err; constr_ok ]; + Basic_lst.iter + [ constr_none; constr_some; constr_err; constr_ok ] + ~f:(Typing_info.add_constructor builtin_values); Typing_info.add_field builtin_values ~field:field_val diff --git a/src/check_match.ml b/src/check_match.ml index 28740b1..3c24de2 100644 --- a/src/check_match.ml +++ b/src/check_match.ml @@ -17,7 +17,6 @@ module Vec = Basic_vec module Lst = Basic_lst module Path = Pat_path module Db = Patmatch_db -module Iter = Basic_iter let mark_reachable = Pattern_id.mark_reachable let is_unreachable = Pattern_id.is_unreachable @@ -30,60 +29,85 @@ let report_unused_pat ~diagnostics pat = Local_diagnostics.add_warning diagnostics { kind = Unused_pat; loc = Typedtree.loc_of_pat pat } -let lint_cases ~diagnostics ~book (cases : Typedtree.match_case list) : unit = - let rec visit_cases (cases : Typedtree.match_case list) index = - match cases with - | [] -> () - | case :: cases -> - let pat_id = [ index ] in - if is_unreachable book pat_id then report_unreachable ~diagnostics case; - visit_pat case.pat pat_id; - visit_cases cases (index + 1) - and visit_pat pat pat_id = - if is_unreachable book pat_id then report_unused_pat ~diagnostics pat - else - match pat with - | Tpat_any _ | Tpat_var _ | Tpat_constant _ -> () - | Tpat_alias { pat; _ } | Tpat_constraint { pat; _ } -> - visit_pat pat (0 :: pat_id) - | Tpat_range _ -> () - | Tpat_or { pat1; pat2; _ } -> - visit_pat pat1 (0 :: pat_id); - visit_pat pat2 (1 :: pat_id) - | Tpat_tuple { pats; _ } -> - Lst.iteri pats (fun i pat -> visit_pat pat (i :: pat_id)) - | Tpat_record { fields; _ } -> - Lst.iteri fields (fun i (Field_pat { pat; _ }) -> - visit_pat pat (i :: pat_id)) - | Tpat_constr { args = []; _ } -> () - | Tpat_constr { args; _ } -> - Lst.iteri args (fun arg_index (Constr_pat_arg { pat; _ }) -> - visit_pat pat (arg_index :: pat_id)) - | Tpat_array { pats; _ } -> ( - match pats with - | Closed pats -> - Lst.iteri pats (fun i pat -> visit_pat pat (i :: pat_id)) - | Open (pats1, pats2, _dotdot_binder) -> - let len1 = List.length pats1 in - Lst.iteri pats1 (fun i pat -> visit_pat pat (i :: pat_id)); - Lst.iteri pats2 (fun i pat -> - visit_pat pat ((i + len1) :: pat_id))) - | Tpat_map { elems; _ } -> - Lst.iteri elems (fun i (_, pat) -> visit_pat pat (i :: pat_id)) - in - visit_cases cases 0 +let lint_cases ~diagnostics ~book ~cases_reachability + (cases : Typedtree.match_case list) = + (let rec visit_cases (cases : Typedtree.match_case list) index = + match cases with + | [] -> () + | case :: cases -> + if cases_reachability.(index) then + let pat_id = [ index ] in + visit_pat case.pat pat_id + else report_unreachable ~diagnostics case; + visit_cases cases (index + 1) + and visit_pat pat pat_id = + if is_unreachable book pat_id then report_unused_pat ~diagnostics pat + else + match pat with + | Tpat_any _ | Tpat_var _ | Tpat_constant _ -> () + | Tpat_alias { pat; _ } | Tpat_constraint { pat; _ } -> + visit_pat pat (0 :: pat_id) + | Tpat_range _ -> () + | Tpat_or { pat1; pat2; _ } -> + visit_pat pat1 (0 :: pat_id); + visit_pat pat2 (1 :: pat_id) + | Tpat_tuple { pats; _ } -> + Lst.iteri pats ~f:(fun i -> fun pat -> visit_pat pat (i :: pat_id)) + | Tpat_record { fields; _ } -> + Lst.iteri fields ~f:(fun i -> + fun (Field_pat { pat; _ }) -> visit_pat pat (i :: pat_id)) + | Tpat_constr { args = []; _ } -> () + | Tpat_constr { args; _ } -> + Lst.iteri args ~f:(fun arg_index -> + fun (Constr_pat_arg { pat; _ }) -> + visit_pat pat (arg_index :: pat_id)) + | Tpat_array { pats; _ } -> ( + match pats with + | Closed pats -> + Lst.iteri pats ~f:(fun i -> + fun pat -> visit_pat pat (i :: pat_id)) + | Open (pats1, pats2, _dotdot_binder) -> + let len1 = List.length pats1 in + Lst.iteri pats1 ~f:(fun i -> + fun pat -> visit_pat pat (i :: pat_id)); + Lst.iteri pats2 ~f:(fun i -> + fun pat -> visit_pat pat ((i + len1) :: pat_id))) + | Tpat_map { elems; _ } -> + Lst.iteri elems ~f:(fun i -> + fun (_, pat) -> visit_pat pat (i :: pat_id)) + in + visit_cases cases 0 + : unit) -let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) - (cases : Typedtree.match_case list) (genv : Global_env.t) - ~(catch_all_loc : Rloc.t option) (loc : Rloc.t) = +let try_combine_array_pat_to_string (pat : Typedtree.array_pattern) = + (let exception Not_all_char_literal in + try + match pat with + | Closed pats -> + let vec = Basic_vec_int.empty () in + Lst.iter pats ~f:(fun p -> + match p with + | Tpat_constant { c = C_char c; _ } -> + Basic_vec_int.push vec (Uchar.to_int c) + | _ -> raise_notrace Not_all_char_literal); + let str = Basic_utf8.string_of_vec vec ~offset:0 ~len:vec.len in + Some str + | Open _ -> raise_notrace Not_all_char_literal + with Not_all_char_literal -> None + : string option) + +let analyze_cases (ty : Stype.t) (cases : Typedtree.match_case list) + (genv : Global_env.t) ~(catch_all_loc : Rloc.t option) + ~(only_check_unused_pat : bool) = let book = Pattern_id.create () in + let cases_reachability = Array.make (List.length cases) false in let missing_cases = Vec.empty () in - let dispatch ~ok_cont ~fail_cont (r : Db.static_eval_result) ~pat_id = + let dispatch ~db ~ok_cont ~fail_cont (r : Db.static_eval_result) ~pat_id = match r with - | For_sure_yes r -> + | For_sure_yes -> mark_reachable book pat_id; - ok_cont r.ok_db - | For_sure_no r -> fail_cont r.fail_db + ok_cont db + | For_sure_no -> fail_cont db | Uncertain r -> mark_reachable book pat_id; ok_cont r.ok_db; @@ -106,7 +130,11 @@ let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) ~fail_cont:(fun db -> process_pat ~db ~path pat2 ~pat_id:(1 :: pat_id) ~ok_cont ~fail_cont) | Tpat_constant { c; _ } -> - Db.eval_constant db path c |> dispatch ~ok_cont ~fail_cont ~pat_id + dispatch ~ok_cont ~fail_cont ~pat_id ~db + (match c with + | C_string str -> + Db.eval_string_constant db path str ~check_match:true + | _ -> Db.eval_constant db path c) | Tpat_range { lhs; rhs; inclusive; ty = _ } -> let lo = match lhs with @@ -120,8 +148,8 @@ let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) | Tpat_any _ -> None | _ -> assert false in - Db.eval_range db path lo hi ~inclusive - |> dispatch ~ok_cont ~fail_cont ~pat_id + dispatch ~ok_cont ~fail_cont ~pat_id ~db + (Db.eval_range db path lo hi ~inclusive) | Tpat_tuple { pats; _ } -> mark_reachable book pat_id; let rec go db pats index = @@ -146,15 +174,19 @@ let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) ~fail_cont in go db fields 0 - | Tpat_constr { tag; args; used_error_subtyping; constr = _; ty = _ } -> - let arg_path arg_index : Path.t = - match tag with - | Constr_tag_regular { index; total = _ } -> - Constr_field { tag_index = index; arg_index } :: path - | Extensible_tag ext_tag -> - if used_error_subtyping then - Error_constr_field { tag; arg_index } :: path - else Constr_field { tag_index = ext_tag.index; arg_index } :: path + | Tpat_constr + { tag; args; used_error_subtyping; type_name = _; constr = _; ty = _ } + -> + let arg_path arg_index = + (match tag with + | Constr_tag_regular { index; total = _ } -> + Constr_field { tag_index = index; arg_index } :: path + | Extensible_tag ext_tag -> + if used_error_subtyping then + Error_constr_field { tag; arg_index } :: path + else + Constr_field { tag_index = ext_tag.index; arg_index } :: path + : Path.t) in let ok_cont db = let rec loop db arg_index (args : Typedtree.constr_pat_arg list) = @@ -168,25 +200,25 @@ let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) in loop db 0 args in - Db.eval_constructor db path tag ~used_error_subtyping - |> dispatch ~ok_cont ~fail_cont ~pat_id - | Tpat_array { pats; _ } -> + dispatch ~ok_cont ~fail_cont ~pat_id ~db + (Db.eval_constructor db path tag ~used_error_subtyping) + | Tpat_array { pats; _ } -> ( let has_dotdot, pats_with_info, num_pats = match pats with | Closed pats -> ( false, - Lst.mapi pats (fun i pat -> (pat, Path.Field i, i)), + Lst.mapi pats (fun i -> fun pat -> (pat, Path.Field i, i)), List.length pats ) | Open (pats1, pats2, _dotdot_binder) -> let len1 = List.length pats1 in let len2 = List.length pats2 in let pats2 = - Lst.mapi pats2 (fun i pat -> - (pat, Path.Last_field (len2 - 1 - i), i + len1)) + Lst.mapi pats2 (fun i -> + fun pat -> (pat, Path.Last_field (len2 - 1 - i), i + len1)) in ( true, Lst.mapi_append pats1 - (fun i pat -> (pat, Path.Field i, i)) + (fun i -> fun pat -> (pat, Path.Field i, i)) pats2, len1 + len2 ) in @@ -202,62 +234,110 @@ let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) in go db pats_with_info in - let r = - (if has_dotdot then Db.eval_geq_array_len else Db.eval_eq_array_len) - db path num_pats - in - dispatch r ~ok_cont ~fail_cont ~pat_id - | Tpat_map { elems; op_get_info_ = _, op_get_ty, _; ty = _ } -> - mark_reachable book pat_id; - let ty_op_get_result = - match[@warning "-fragile-match"] op_get_ty with - | Tarrow { params_ty = _; ret_ty; err_ty = _ } -> ret_ty - | _ -> assert false + let default () = + let r = + if has_dotdot then Db.eval_geq_array_len db path num_pats + else Db.eval_eq_array_len db path num_pats + in + dispatch r ~db ~ok_cont ~fail_cont ~pat_id + [@@inline] in - let rec go pat_index db elems = - match elems with - | [] -> ok_cont db - | (key, pat) :: elems -> - process_pat pat - ~db:(Db.eval_map_elem db path key ~elem_ty:ty_op_get_result) - ~path:(Map_elem { key } :: path) - ~pat_id:(pat_index :: pat_id) - ~ok_cont:(fun db -> go (pat_index + 1) db elems) - ~fail_cont + let default_string () = + let r = + if has_dotdot then Db.eval_geq_array_len_string db path num_pats + else Db.eval_eq_array_len_string db path num_pats + in + dispatch r ~db ~ok_cont ~fail_cont ~pat_id + [@@inline] in - go 0 db elems + match Stype.type_repr (Typedtree_util.type_of_pat pat) with + | T_builtin T_string -> ( + match try_combine_array_pat_to_string pats with + | Some str -> ( + match Db.eval_string_constant db path str ~check_match:true with + | (For_sure_no | For_sure_yes) as r -> + dispatch ~ok_cont ~fail_cont ~pat_id ~db r + | Uncertain _ -> default_string ()) + | None -> default_string ()) + | _ -> default ()) + | Tpat_map { elems; op_get_info_ = _, op_get_ty, _; ty = _ } -> ( + mark_reachable book pat_id; + match[@warning "-fragile-match"] op_get_ty with + | Tarrow { ret_ty = ty_op_get_result; _ } -> + let rec go pat_index db elems = + match elems with + | [] -> ok_cont db + | (key, pat) :: elems -> + process_pat pat + ~db:(Db.eval_map_elem db path key ~elem_ty:ty_op_get_result) + ~path:(Map_elem { key } :: path) + ~pat_id:(pat_index :: pat_id) + ~ok_cont:(fun db -> go (pat_index + 1) db elems) + ~fail_cont + in + go 0 db elems + | _ -> assert false) in let rec process_cases (db : Db.t) (cases : Typedtree.match_case list) index = match cases with | [] -> Vec.push missing_cases db - | { pat; _ } :: cases -> + | { pat; guard = None; _ } :: cases -> let pat_id = [ index ] in - let ok_cont _db = () in + let ok_cont _db = cases_reachability.(index) <- true in let fail_cont (db : Db.t) = process_cases db cases (index + 1) in process_pat ~db ~path:[] pat ~pat_id ~ok_cont ~fail_cont + | { pat; guard = Some _; _ } :: cases -> + let pat_id = [ index ] in + process_pat ~db ~path:[] pat ~pat_id + ~ok_cont:(fun _ -> cases_reachability.(index) <- true) + ~fail_cont:(fun _ -> ()); + process_cases db cases (index + 1) in process_cases Db.empty cases 0; - (if Vec.length missing_cases > 0 && catch_all_loc = None then + let patterns = Basic_vec.empty () in + (if + Vec.length missing_cases > 0 + && catch_all_loc = None && not only_check_unused_pat + then let empty_match = cases = [] in - let cases = - (fun f -> Vec.iter f missing_cases) - |> Iter.flat_map ~f:(fun db -> - Patmatch_static_info.synthesize_missing_case_pattern db ~genv - ~empty_match ty - |> Iter.of_list) - |> Iter.map ~f:(fun (_) -> "") - |> Iter.to_list - in - if cases <> [] then - Local_diagnostics.add_warning diagnostics - { kind = Partial_match cases; loc }); + Vec.iter (fun db -> + let ps = + Patmatch_static_info.synthesize_missing_case_pattern db ~genv + ~empty_match ty + in + Basic_lst.iter ps ~f:(fun p -> Vec.push patterns p)) + missing_cases); + (book, cases_reachability, patterns, Vec.length missing_cases = 0) + +let get_missing_case_patterns (ty : Stype.t) (cases : Typedtree.match_case list) + (genv : Global_env.t) = + let _, _, missing_cases, _ = + analyze_cases ty cases genv ~catch_all_loc:None ~only_check_unused_pat:false + in + missing_cases + +let check_match ~(diagnostics : Local_diagnostics.t) (ty : Stype.t) + (cases : Typedtree.match_case list) (genv : Global_env.t) + ~(catch_all_loc : Rloc.t option) ~(is_let_match : bool) + ~(only_check_unused_pat : bool) (loc : Rloc.t) = + let book, cases_reachability, missing_case_patterns, missing_case_db_is_empty + = + analyze_cases ty cases genv ~catch_all_loc ~only_check_unused_pat + in + (if Vec.length missing_case_patterns > 0 && not only_check_unused_pat then + let has_guard = Lst.exists cases (fun { guard; _ } -> guard <> None) in + Local_diagnostics.add_warning diagnostics + { + kind = Partial_match { hint_cases = [ "" ]; is_let_match; has_guard }; + loc; + }); (match catch_all_loc with | None -> () | Some loc -> - if Vec.length missing_cases = 0 then + if missing_case_db_is_empty then Local_diagnostics.add_warning diagnostics { kind = Useless_catch_all; loc }); - lint_cases ~diagnostics ~book cases + lint_cases ~diagnostics ~book ~cases_reachability cases let rec irrefutable_pattern (pat : Typedtree.pat) = match pat with @@ -277,12 +357,43 @@ let obj = object inherit [_] Typedtree.iter as super + method! visit_Texpr_guard_let ((diagnostics, genv) as _ctx) pat rhs + pat_binders otherwise body ty loc_ = + super#visit_Texpr_guard_let _ctx pat rhs pat_binders otherwise body ty + loc_; + check_match ~diagnostics ~catch_all_loc:None + (Typedtree_util.type_of_typed_expr rhs) + [ + { + pat; + action = Texpr_unit { loc_ = Rloc.no_location }; + pat_binders; + guard = None; + }; + ] + genv Rloc.no_location ~is_let_match:false ~only_check_unused_pat:true; + match otherwise with + | None -> () + | Some else_cases -> + let guard_case = + { Typedtree.pat; action = body; pat_binders; guard = None } + in + let match_loc_ = + Rloc.of_pos + ( Rloc.get_start loc_, + Rloc.get_end (Typedtree.loc_of_typed_expr rhs) ) + in + check_match ~diagnostics ~catch_all_loc:None + (Typedtree_util.type_of_typed_expr rhs) + (guard_case :: else_cases) genv match_loc_ ~is_let_match:false + ~only_check_unused_pat:false + method! visit_Texpr_match ((diagnostics, genv) as _ctx) expr cases typ match_loc loc = super#visit_Texpr_match _ctx expr cases typ match_loc loc; check_match ~diagnostics ~catch_all_loc:None (Typedtree_util.type_of_typed_expr expr) - cases genv match_loc + cases genv match_loc ~is_let_match:false ~only_check_unused_pat:false method! visit_Texpr_try ((diagnostics, genv) as ctx) body catch catch_all try_else ty err_ty catch_loc else_loc loc = @@ -290,13 +401,15 @@ let obj = catch_loc else_loc loc; check_match ~diagnostics ~catch_all_loc:(if catch_all then Some catch_loc else None) - err_ty catch genv catch_loc; + err_ty catch genv catch_loc ~is_let_match:false + ~only_check_unused_pat:false; match try_else with | None -> () | Some try_else -> check_match ~diagnostics ~catch_all_loc:None (Typedtree_util.type_of_typed_expr body) - try_else genv else_loc + try_else genv else_loc ~is_let_match:false + ~only_check_unused_pat:false method! visit_Texpr_let ((diagnostics, genv) as ctx) (pat : Typedtree.pat) rhs pat_binders body ty loc = @@ -304,14 +417,29 @@ let obj = if not (irrefutable_pattern pat) then check_match ~diagnostics ~catch_all_loc:None (Typedtree_util.type_of_typed_expr rhs) - [ { pat; action = body; pat_binders } ] - genv - (Typedtree.loc_of_typed_expr rhs) + [ { pat; action = body; pat_binders; guard = None } ] + genv (Typedtree.loc_of_pat pat) ~is_let_match:true + ~only_check_unused_pat:false + + method! visit_Texpr_is ((diagnostics, genv) as ctx) expr pat pat_binders loc + = + super#visit_Texpr_is ctx expr pat pat_binders loc; + check_match ~diagnostics ~catch_all_loc:None + (Typedtree_util.type_of_typed_expr expr) + [ + { + pat; + action = Texpr_unit { loc_ = Rloc.no_location }; + pat_binders; + guard = None; + }; + ] + genv loc ~is_let_match:false ~only_check_unused_pat:true end let analyze ~diagnostics (genv, output) = let (Output { value_defs; _ } : Typedtree.output) = output in - Lst.iter value_defs (fun impl -> + Lst.iter value_defs ~f:(fun impl -> let base = Typedtree.loc_of_impl impl in let local_diagnostics = Local_diagnostics.make ~base in obj#visit_impl (local_diagnostics, genv) impl; diff --git a/src/check_purity.ml b/src/check_purity.ml index dcd2096..6404e19 100644 --- a/src/check_purity.ml +++ b/src/check_purity.ml @@ -13,26 +13,31 @@ *) -let rec check (lam : Clam.lambda) : bool = - match lam with - | Levent { expr; loc_ = _ } -> check expr - | Lvar _ | Lconst _ | Lallocate _ | Lclosure _ | Lget_field _ - | Lclosure_field _ | Lmake_array _ | Larray_get_item _ | Lcast _ -> - true - | Lloop _ | Lapply _ | Lstub_call _ | Ljoinlet _ | Ljoinapply _ | Lbreak _ - | Lcontinue _ | Lreturn _ | Lcatch _ | Lset_field _ | Larray_set_item _ - | Lassign _ -> - false - | Lif { pred; ifso; ifnot } -> check pred && check ifso && check ifnot - | Llet { name = _; e; body } -> check e && check body - | Lletrec { body; _ } -> check body - | Lprim { fn; args } -> Primitive.is_pure fn && List.for_all check args - | Lsequence { expr1; expr2 } -> check expr1 && check expr2 - | Lswitch { obj = _; cases; default } -> - List.for_all (fun (_, arm) -> check arm) cases && check default - | Lswitchstring { obj; cases; default } -> - check obj - && List.for_all (fun (_, arm) -> check arm) cases - && check default - | Lswitchint { obj = _; cases; default } -> - List.for_all (fun (_, arm) -> check arm) cases && check default +module Lst = Basic_lst + +let rec check (lam : Clam.lambda) = + (match lam with + | Levent { expr; loc_ = _ } -> check expr + | Lvar _ | Lconst _ | Lallocate _ | Lclosure _ | Lget_raw_func _ + | Lget_field _ | Lclosure_field _ | Lmake_array _ | Larray_get_item _ + | Lcast _ -> + true + | Lloop _ | Lapply _ | Lstub_call _ | Ljoinlet _ | Ljoinapply _ | Lbreak _ + | Lcontinue _ | Lreturn _ | Lcatch _ | Lset_field _ | Larray_set_item _ + | Lassign _ -> + false + | Lif { pred; ifso; ifnot } -> check pred && check ifso && check ifnot + | Llet { name = _; e; body } -> check e && check body + | Lletrec { body; _ } -> check body + | Lprim { fn; args } -> Primitive.is_pure fn && List.for_all check args + | Lsequence { exprs; last_expr } -> + Lst.for_all exprs check && check last_expr + | Lswitch { obj = _; cases; default } -> + List.for_all (fun (_, arm) -> check arm) cases && check default + | Lswitchstring { obj; cases; default } -> + check obj + && List.for_all (fun (_, arm) -> check arm) cases + && check default + | Lswitchint { obj = _; cases; default } -> + List.for_all (fun (_, arm) -> check arm) cases && check default + : bool) diff --git a/src/check_purity1.ml b/src/check_purity1.ml deleted file mode 100644 index ade4aab..0000000 --- a/src/check_purity1.ml +++ /dev/null @@ -1,40 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -let rec check (lam : Clam1.lambda) : bool = - match lam with - | Levent { expr; loc_ = _ } | Lcast { expr; target_type = _ } -> check expr - | Lvar _ | Lconst _ | Lallocate _ | Lclosure _ | Lmake_multi_result _ - | Lget_field _ | Lclosure_field _ | Lmake_array _ | Larray_get_item _ -> - true - | Lloop _ | Lapply _ | Lstub_call _ | Ljoinlet _ | Ljoinapply _ | Lbreak _ - | Lcontinue _ | Lreturn _ | Lcatch _ | Lset_field _ | Larray_set_item _ - | Lassign _ -> - false - | Lif { pred; ifso; ifnot } -> check pred && check ifso && check ifnot - | Lhandle_error { obj; ok_branch = _, ok_branch; err_branch = _, err_branch } - -> - check obj && check ok_branch && check err_branch - | Llet { name = _; e; body } | Llet_multi { names = _; e; body } -> - check e && check body - | Lletrec { body; _ } -> check body - | Lprim { fn; args = _ } -> Primitive.is_pure fn - | Lsequence { expr1; expr2 } -> check expr1 && check expr2 - | Lswitch { obj = _; cases; default } -> - List.for_all (fun (_, arm) -> check arm) cases && check default - | Lswitchstring { obj = _; cases; default } -> - List.for_all (fun (_, arm) -> check arm) cases && check default - | Lswitchint { obj = _; cases; default } -> - List.for_all (fun (_, arm) -> check arm) cases && check default diff --git a/src/checked_attributes.ml b/src/checked_attributes.ml new file mode 100644 index 0000000..9cf453f --- /dev/null +++ b/src/checked_attributes.ml @@ -0,0 +1,143 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Lst = Basic_lst + +type location = Rloc.t + +include struct + let _ = fun (_ : location) -> () + let sexp_of_location = (Rloc.sexp_of_t : location -> S.t) + let _ = sexp_of_location +end + +type attribute = + | Tattr_alert of { loc_ : location; category : string; message : string } + | Tattr_intrinsic of { loc_ : location; intrinsic : string } + +include struct + let _ = fun (_ : attribute) -> () + + let sexp_of_attribute = + (function + | Tattr_alert + { + loc_ = loc___002_; + category = category__004_; + message = message__006_; + } -> + let bnds__001_ = ([] : _ Stdlib.List.t) in + let bnds__001_ = + let arg__007_ = Moon_sexp_conv.sexp_of_string message__006_ in + (S.List [ S.Atom "message"; arg__007_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__005_ = Moon_sexp_conv.sexp_of_string category__004_ in + (S.List [ S.Atom "category"; arg__005_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__003_ = sexp_of_location loc___002_ in + (S.List [ S.Atom "loc_"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) + in + S.List (S.Atom "Tattr_alert" :: bnds__001_) + | Tattr_intrinsic { loc_ = loc___009_; intrinsic = intrinsic__011_ } -> + let bnds__008_ = ([] : _ Stdlib.List.t) in + let bnds__008_ = + let arg__012_ = Moon_sexp_conv.sexp_of_string intrinsic__011_ in + (S.List [ S.Atom "intrinsic"; arg__012_ ] :: bnds__008_ + : _ Stdlib.List.t) + in + let bnds__008_ = + let arg__010_ = sexp_of_location loc___009_ in + (S.List [ S.Atom "loc_"; arg__010_ ] :: bnds__008_ : _ Stdlib.List.t) + in + S.List (S.Atom "Tattr_intrinsic" :: bnds__008_) + : attribute -> S.t) + + let _ = sexp_of_attribute +end + +type t = attribute list + +include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (fun x__013_ -> Moon_sexp_conv.sexp_of_list sexp_of_attribute x__013_ + : t -> S.t) + + let _ = sexp_of_t +end + +let check ~local_diagnostics + ~(context : [ `TopLet | `TopFun | `TopTypeDecl | `Impl | `Trait ]) + (attrs : Attribute.t list) = + (Lst.fold_left attrs [] (fun acc -> + fun attr -> + match attr with + | { Attribute.loc_; raw = _; parsed = Some expr } -> ( + let warn_unused_attribute name = + Local_diagnostics.add_warning local_diagnostics + { loc = loc_; kind = Unused_attribute name } + in + match expr with + | Apply + ( { qual = None; name = "intrinsic" }, + Expr (String { string_val = intrinsic; _ }) :: [] ) -> ( + match context with + | `TopLet | `TopTypeDecl | `Impl | `Trait -> + warn_unused_attribute "intrinsic"; + acc + | `TopFun -> Tattr_intrinsic { loc_; intrinsic } :: acc) + | Apply + ( { qual = None; name = "deprecated" }, + Expr (String message) :: [] ) -> ( + match context with + | `TopLet | `TopTypeDecl | `Impl | `Trait -> + warn_unused_attribute "deprecated"; + acc + | `TopFun -> + Tattr_alert + { + loc_; + category = "deprecated"; + message = message.string_val; + } + :: acc) + | Apply + ( { qual = None; name = "alert" }, + [ + Expr (Ident { qual = None; name = category }); + Expr (String message); + ] ) -> ( + match context with + | `TopLet | `TopTypeDecl | `Impl | `Trait -> + warn_unused_attribute "alert"; + acc + | `TopFun -> + Tattr_alert { loc_; category; message = message.string_val } + :: acc) + | _ -> acc) + | _ -> acc) + : t) + +let check_alerts ~diagnostics t loc = + Lst.iter t ~f:(fun pragma -> + match pragma with + | Tattr_alert { category; message; loc_ = _ } -> + Local_diagnostics.add_alert diagnostics { category; message; loc } + | _ -> ()) diff --git a/src/clam.ml b/src/clam.ml index 78722cf..2d168ae 100644 --- a/src/clam.ml +++ b/src/clam.ml @@ -146,18 +146,23 @@ include struct let sexp_of_join_kind = (function - | Tail_join -> S.Atom "Tail_join" | Nontail_join -> S.Atom "Nontail_join" + | Tail_join -> S.Atom "Tail_join" + | Nontail_join -> S.Atom "Nontail_join" : join_kind -> S.t) let _ = sexp_of_join_kind end -type aggregate_kind = Tuple | Struct | Enum of { tag : constr_tag } +type alloc_kind = + | Tuple + | Struct + | Enum of { tag : constr_tag } + | Object of { methods : address list } include struct - let _ = fun (_ : aggregate_kind) -> () + let _ = fun (_ : alloc_kind) -> () - let sexp_of_aggregate_kind = + let sexp_of_alloc_kind = (function | Tuple -> S.Atom "Tuple" | Struct -> S.Atom "Struct" @@ -168,62 +173,152 @@ include struct (S.List [ S.Atom "tag"; arg__005_ ] :: bnds__003_ : _ Stdlib.List.t) in S.List (S.Atom "Enum" :: bnds__003_) - : aggregate_kind -> S.t) + | Object { methods = methods__007_ } -> + let bnds__006_ = ([] : _ Stdlib.List.t) in + let bnds__006_ = + let arg__008_ = + Moon_sexp_conv.sexp_of_list sexp_of_address methods__007_ + in + (S.List [ S.Atom "methods"; arg__008_ ] :: bnds__006_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Object" :: bnds__006_) + : alloc_kind -> S.t) - let _ = sexp_of_aggregate_kind + let _ = sexp_of_alloc_kind end -type closure_address = - | Normal of address - | Well_known_mut_rec - | Object of address list +type get_field_kind = + | Tuple + | Struct + | Enum + | Object of { number_of_methods : int } + +include struct + let _ = fun (_ : get_field_kind) -> () + + let sexp_of_get_field_kind = + (function + | Tuple -> S.Atom "Tuple" + | Struct -> S.Atom "Struct" + | Enum -> S.Atom "Enum" + | Object { number_of_methods = number_of_methods__010_ } -> + let bnds__009_ = ([] : _ Stdlib.List.t) in + let bnds__009_ = + let arg__011_ = Moon_sexp_conv.sexp_of_int number_of_methods__010_ in + (S.List [ S.Atom "number_of_methods"; arg__011_ ] :: bnds__009_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Object" :: bnds__009_) + : get_field_kind -> S.t) + + let _ = sexp_of_get_field_kind +end + +type set_field_kind = Struct | Enum + +include struct + let _ = fun (_ : set_field_kind) -> () + + let sexp_of_set_field_kind = + (function Struct -> S.Atom "Struct" | Enum -> S.Atom "Enum" + : set_field_kind -> S.t) + + let _ = sexp_of_set_field_kind +end + +type closure_address = Normal of address | Well_known_mut_rec + +type get_item_extra = + | Need_non_null_cast + | Need_signed_info of { signed : bool } + | No_extra + +include struct + let _ = fun (_ : get_item_extra) -> () + + let sexp_of_get_item_extra = + (function + | Need_non_null_cast -> S.Atom "Need_non_null_cast" + | Need_signed_info { signed = signed__013_ } -> + let bnds__012_ = ([] : _ Stdlib.List.t) in + let bnds__012_ = + let arg__014_ = Moon_sexp_conv.sexp_of_bool signed__013_ in + (S.List [ S.Atom "signed"; arg__014_ ] :: bnds__012_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Need_signed_info" :: bnds__012_) + | No_extra -> S.Atom "No_extra" + : get_item_extra -> S.t) + + let _ = sexp_of_get_item_extra +end let sexp_of_closure_address addr = match addr with | Normal addr -> S.List [ sexp_of_address addr ] | Well_known_mut_rec -> S.List [] - | Object methods -> S.List (Atom "Object" :: Lst.map methods sexp_of_address) class ['a] mapbase = object - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_prim : 'a -> Primitive.prim -> Primitive.prim = fun _ e -> e - method visit_constr_tag : 'a -> constr_tag -> constr_tag = fun _ e -> e - method visit_binder : 'a -> binder -> binder = fun _ e -> e - method visit_address : 'a -> address -> address = fun _ e -> e - method visit_join : 'a -> join -> join = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_ltype : 'a -> ltype -> ltype = fun _ e -> e + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + + method visit_prim : 'a -> Primitive.prim -> Primitive.prim = + fun _ -> fun e -> e + + method visit_constr_tag : 'a -> constr_tag -> constr_tag = + fun _ -> fun e -> e + + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e + method visit_address : 'a -> address -> address = fun _ -> fun e -> e + method visit_join : 'a -> join -> join = fun _ -> fun e -> e + method visit_label : 'a -> label -> label = fun _ -> fun e -> e + method visit_ltype : 'a -> ltype -> ltype = fun _ -> fun e -> e method private visit_func_stubs : 'a -> func_stubs -> func_stubs = - fun _ e -> e + fun _ -> fun e -> e + + method private visit_alloc_kind : 'a -> alloc_kind -> alloc_kind = + fun _ -> fun e -> e - method private visit_aggregate_kind : 'a -> aggregate_kind -> aggregate_kind + method private visit_get_field_kind : 'a -> get_field_kind -> get_field_kind = - fun _ e -> e + fun _ -> fun e -> e - method private visit_closure_address - : 'a -> closure_address -> closure_address = - fun _ e -> e + method private visit_set_field_kind : 'a -> set_field_kind -> set_field_kind + = + fun _ -> fun e -> e + + method private visit_closure_address : + 'a -> closure_address -> closure_address = + fun _ -> fun e -> e end class ['a] iterbase = object - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_prim : 'a -> Primitive.prim -> unit = fun _ _ -> () - method visit_constr_tag : 'a -> constr_tag -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () - method visit_address : 'a -> address -> unit = fun _ _ -> () - method visit_join : 'a -> join -> unit = fun _ _ -> () - method visit_label : 'a -> label -> unit = fun _ _ -> () - method visit_ltype : 'a -> ltype -> unit = fun _ _ -> () - method private visit_func_stubs : 'a -> func_stubs -> unit = fun _ _ -> () - - method private visit_aggregate_kind : 'a -> aggregate_kind -> unit = - fun _ _ -> () + method visit_var : 'a -> var -> unit = fun _ -> fun _ -> () + method visit_prim : 'a -> Primitive.prim -> unit = fun _ -> fun _ -> () + method visit_constr_tag : 'a -> constr_tag -> unit = fun _ -> fun _ -> () + method visit_binder : 'a -> binder -> unit = fun _ -> fun _ -> () + method visit_address : 'a -> address -> unit = fun _ -> fun _ -> () + method visit_join : 'a -> join -> unit = fun _ -> fun _ -> () + method visit_label : 'a -> label -> unit = fun _ -> fun _ -> () + method visit_ltype : 'a -> ltype -> unit = fun _ -> fun _ -> () + + method private visit_func_stubs : 'a -> func_stubs -> unit = + fun _ -> fun _ -> () + + method private visit_alloc_kind : 'a -> alloc_kind -> unit = + fun _ -> fun _ -> () + + method private visit_get_field_kind : 'a -> get_field_kind -> unit = + fun _ -> fun _ -> () + + method private visit_set_field_kind : 'a -> set_field_kind -> unit = + fun _ -> fun _ -> () method private visit_closure_address : 'a -> closure_address -> unit = - fun _ _ -> () + fun _ -> fun _ -> () end class virtual ['a] sexpbase = @@ -231,55 +326,70 @@ class virtual ['a] sexpbase = inherit [_] Sexp_visitors.sexp method visit_location : 'a -> location -> S.t = - fun _ loc -> sexp_of_location loc + fun _ -> fun loc -> sexp_of_location loc - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x + method visit_var : 'a -> var -> S.t = fun _ -> fun x -> sexp_of_var x method visit_prim : 'a -> Primitive.prim -> S.t = - fun _ x -> Primitive.sexp_of_prim x + fun _ -> fun x -> Primitive.sexp_of_prim x method visit_constr_tag : 'a -> constr_tag -> S.t = - fun _ x -> sexp_of_constr_tag x + fun _ -> fun x -> sexp_of_constr_tag x - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x + method visit_binder : 'a -> binder -> S.t = + fun _ -> fun x -> sexp_of_binder x method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x + fun _ -> fun x -> sexp_of_constant x + + method visit_address : 'a -> address -> S.t = + fun _ -> fun x -> sexp_of_address x - method visit_address : 'a -> address -> S.t = fun _ x -> sexp_of_address x - method visit_join : 'a -> join -> S.t = fun _ x -> sexp_of_join x - method visit_label : 'a -> label -> S.t = fun _ x -> sexp_of_label x - method visit_fn_kind : 'a -> fn_kind -> S.t = fun _ x -> sexp_of_fn_kind x - method visit_ltype : 'a -> ltype -> S.t = fun _ x -> sexp_of_ltype x + method visit_join : 'a -> join -> S.t = fun _ -> fun x -> sexp_of_join x + method visit_label : 'a -> label -> S.t = fun _ -> fun x -> sexp_of_label x + + method visit_fn_kind : 'a -> fn_kind -> S.t = + fun _ -> fun x -> sexp_of_fn_kind x + + method visit_ltype : 'a -> ltype -> S.t = fun _ -> fun x -> sexp_of_ltype x method visit_join_kind : 'a -> join_kind -> S.t = - fun _ x -> sexp_of_join_kind x + fun _ -> fun x -> sexp_of_join_kind x method visit_type_defs : 'a -> type_defs -> S.t = - fun _ x -> sexp_of_type_defs x + fun _ -> fun x -> sexp_of_type_defs x - method visit_tid : 'a -> tid -> S.t = fun _ x -> sexp_of_tid x + method visit_tid : 'a -> tid -> S.t = fun _ -> fun x -> sexp_of_tid x method private visit_func_stubs : 'a -> func_stubs -> S.t = - fun _ x -> sexp_of_func_stubs x + fun _ -> fun x -> sexp_of_func_stubs x + + method private visit_alloc_kind : 'a -> alloc_kind -> S.t = + fun _ -> fun x -> sexp_of_alloc_kind x + + method private visit_get_field_kind : 'a -> get_field_kind -> S.t = + fun _ -> fun x -> sexp_of_get_field_kind x - method private visit_aggregate_kind : 'a -> aggregate_kind -> S.t = - fun _ x -> sexp_of_aggregate_kind x + method private visit_set_field_kind : 'a -> set_field_kind -> S.t = + fun _ -> fun x -> sexp_of_set_field_kind x method private visit_closure_address : 'a -> closure_address -> S.t = - fun _ x -> sexp_of_closure_address x + fun _ -> fun x -> sexp_of_closure_address x - method private visit_make_array_kind - : 'a -> Primitive.make_array_kind -> S.t = - fun _ x -> Primitive.sexp_of_make_array_kind x + method private visit_make_array_kind : + 'a -> Primitive.make_array_kind -> S.t = + fun _ -> fun x -> Primitive.sexp_of_make_array_kind x method private visit_array_get_kind : 'a -> Primitive.array_get_kind -> S.t = - fun _ x -> Primitive.sexp_of_array_get_kind x + fun _ -> fun x -> Primitive.sexp_of_array_get_kind x method private visit_array_set_kind : 'a -> Primitive.array_set_kind -> S.t = - fun _ x -> Primitive.sexp_of_array_set_kind x + fun _ -> fun x -> Primitive.sexp_of_array_set_kind x + + method private visit_get_item_extra : 'a -> get_item_extra -> S.t = + fun _ -> fun x -> sexp_of_get_item_extra x end type fn = { params : binder list; body : lambda; return_type_ : ltype list } @@ -306,7 +416,7 @@ and closure = { } and aggregate = { - kind : aggregate_kind; + kind : alloc_kind; tid : (tid[@visitors.opaque]); fields : lambda list; } @@ -322,16 +432,18 @@ and intrinsic = dst_tid : (tid[@visitors.opaque]); } | FixedArray_fill of { tid : (tid[@visitors.opaque]) } + | Char_to_string and lambda = | Levent of { expr : lambda; loc_ : location } | Lallocate of aggregate | Lclosure of closure + | Lget_raw_func of address | Lget_field of { obj : lambda; tid : (tid[@visitors.opaque]); index : int; - kind : aggregate_kind; + kind : get_field_kind; } | Lclosure_field of { obj : lambda; @@ -343,7 +455,7 @@ and lambda = field : lambda; tid : (tid[@visitors.opaque]); index : int; - kind : aggregate_kind; + kind : set_field_kind; } | Lmake_array of { tid : (tid[@visitors.opaque]); @@ -355,7 +467,7 @@ and lambda = kind : (Primitive.array_get_kind[@visitors.opaque]); arr : lambda; index : lambda; - need_non_null_cast : bool; + extra : (get_item_extra[@visitors.opaque]); } | Larray_set_item of { tid : (tid[@visitors.opaque]); @@ -383,7 +495,7 @@ and lambda = | Llet of { name : binder; e : lambda; body : lambda } | Lletrec of { names : binder list; fns : closure list; body : lambda } | Lprim of { fn : prim; args : lambda list } - | Lsequence of { expr1 : lambda; expr2 : lambda; expr1_type_ : ltype } + | Lsequence of { exprs : lambda list; last_expr : lambda } | Ljoinlet of { name : join; params : binder list; @@ -428,668 +540,780 @@ include struct inherit [_] iterbase method visit_fn : _ -> fn -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_ltype env)) - _visitors_this.return_type_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_binder env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_lambda env _visitors_this.body in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_ltype env)) + _visitors_this.return_type_ + in + () method visit_top_func_item : _ -> top_func_item -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.fn_kind_ - in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_this.tid in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_address env _visitors_this.binder in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.fn_kind_ + in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_this.tid in + () method visit_prog : _ -> prog -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_top_func_item env)) - _visitors_this.fns - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_lambda env) t - | None -> ()) - _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (fun _visitors_this -> ()) t - | None -> ()) - _visitors_c1 - in - ())) - _visitors_this.globals - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.type_defs - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_top_func_item env)) + _visitors_this.fns + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_lambda env) t + | None -> ()) + _visitors_this.main + in + let _visitors_r2 = self#visit_lambda env _visitors_this.init in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_c1 + in + ())) + _visitors_this.globals + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_this.type_defs + in + () method visit_closure : _ -> closure -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_var env)) - _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_this.tid in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_var env)) + _visitors_this.captures + in + let _visitors_r1 = + self#visit_closure_address env _visitors_this.address + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_this.tid in + () method visit_aggregate : _ -> aggregate -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.tid in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_this.fields - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_alloc_kind env _visitors_this.kind in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.tid in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_this.fields + in + () method visit_Dynamic : _ -> var -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + () method visit_StaticFn : _ -> address -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + () method visit_Object : _ -> var -> int -> ltype -> unit = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fmethod_index - in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - () + fun env -> + fun _visitors_fobj -> + fun _visitors_fmethod_index -> + fun _visitors_fmethod_ty -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fmethod_index + in + let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in + () method visit_target : _ -> target -> unit = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 + | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 + | Object + { + obj = _visitors_fobj; + method_index = _visitors_fmethod_index; + method_ty = _visitors_fmethod_ty; + } -> + self#visit_Object env _visitors_fobj _visitors_fmethod_index + _visitors_fmethod_ty method visit_FixedArray_copy : _ -> _ -> _ -> unit = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fsrc_tid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fdst_tid in - () + fun env -> + fun _visitors_fsrc_tid -> + fun _visitors_fdst_tid -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fsrc_tid in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fdst_tid in + () method visit_FixedArray_fill : _ -> _ -> unit = - fun env _visitors_ftid -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - () + fun env -> + fun _visitors_ftid -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in + () + + method visit_Char_to_string : _ -> unit = fun env -> () method visit_intrinsic : _ -> intrinsic -> unit = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid + fun env -> + fun _visitors_this -> + match _visitors_this with + | FixedArray_copy + { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> + self#visit_FixedArray_copy env _visitors_fsrc_tid + _visitors_fdst_tid + | FixedArray_fill { tid = _visitors_ftid } -> + self#visit_FixedArray_fill env _visitors_ftid + | Char_to_string -> self#visit_Char_to_string env method visit_Levent : _ -> lambda -> location -> unit = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Lallocate : _ -> aggregate -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_aggregate env _visitors_c0 in + () method visit_Lclosure : _ -> closure -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - () - - method visit_Lget_field - : _ -> lambda -> _ -> int -> aggregate_kind -> unit = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_closure env _visitors_c0 in + () + + method visit_Lget_raw_func : _ -> address -> unit = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + () + + method visit_Lget_field : + _ -> lambda -> _ -> int -> get_field_kind -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in + let _visitors_r3 = + self#visit_get_field_kind env _visitors_fkind + in + () method visit_Lclosure_field : _ -> lambda -> _ -> int -> unit = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in - () - - method visit_Lset_field - : _ -> lambda -> lambda -> _ -> int -> aggregate_kind -> unit = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = self#visit_lambda env _visitors_ffield in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_findex in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - () + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in + () + + method visit_Lset_field : + _ -> lambda -> lambda -> _ -> int -> set_field_kind -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_ffield -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = self#visit_lambda env _visitors_ffield in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_findex in + let _visitors_r4 = + self#visit_set_field_kind env _visitors_fkind + in + () method visit_Lmake_array : _ -> _ -> _ -> lambda list -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_felems - in - () - - method visit_Larray_get_item - : _ -> _ -> _ -> lambda -> lambda -> bool -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fneed_non_null_cast -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_fneed_non_null_cast - in - () - - method visit_Larray_set_item - : _ -> _ -> _ -> lambda -> lambda -> lambda option -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_lambda env) t - | None -> ()) - _visitors_fitem - in - () - - method visit_Lapply - : _ -> target -> intrinsic option -> lambda list -> unit = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_intrinsic env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - () - - method visit_Lstub_call - : _ -> func_stubs -> lambda list -> ltype list -> ltype option -> unit - = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_ltype env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_ltype env) t - | None -> ()) - _visitors_freturn_ty - in - () + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_felems -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_felems + in + () + + method visit_Larray_get_item : + _ -> _ -> _ -> lambda -> lambda -> _ -> unit = + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fextra -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fextra in + () + + method visit_Larray_set_item : + _ -> _ -> _ -> lambda -> lambda -> lambda option -> unit = + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fitem -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_lambda env) t + | None -> ()) + _visitors_fitem + in + () + + method visit_Lapply : + _ -> target -> intrinsic option -> lambda list -> unit = + fun env -> + fun _visitors_ffn -> + fun _visitors_fprim -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_target env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_intrinsic env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + () + + method visit_Lstub_call : + _ -> func_stubs -> lambda list -> ltype list -> ltype option -> unit = + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_ltype env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_ltype env) t + | None -> ()) + _visitors_freturn_ty + in + () method visit_Lconst : _ -> constant -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - () - - method visit_Lloop - : _ -> binder list -> lambda -> lambda list -> label -> ltype -> unit - = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in + () + + method visit_Lloop : + _ -> binder list -> lambda -> lambda list -> label -> ltype -> unit = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_ftype_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_binder env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_lambda env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r3 = self#visit_label env _visitors_flabel in + let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in + () method visit_Lif : _ -> lambda -> lambda -> lambda -> ltype -> unit = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - () + fun env -> + fun _visitors_fpred -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fpred in + let _visitors_r1 = self#visit_lambda env _visitors_fifso in + let _visitors_r2 = self#visit_lambda env _visitors_fifnot in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + () method visit_Llet : _ -> binder -> lambda -> lambda -> unit = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - () + fun env -> + fun _visitors_fname -> + fun _visitors_fe -> + fun _visitors_fbody -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + () method visit_Lletrec : _ -> binder list -> closure list -> lambda -> unit = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_closure env)) - _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - () + fun env -> + fun _visitors_fnames -> + fun _visitors_ffns -> + fun _visitors_fbody -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_binder env)) + _visitors_fnames + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_closure env)) + _visitors_ffns + in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + () method visit_Lprim : _ -> prim -> lambda list -> unit = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - () - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - () - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - ltype list -> - unit = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r5 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_ltype env)) - _visitors_ftype_ - in - () + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_prim env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + () + + method visit_Lsequence : _ -> lambda list -> lambda -> unit = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_lambda env _visitors_flast_expr in + () + + method visit_Ljoinlet : + _ -> + join -> + binder list -> + lambda -> + lambda -> + join_kind -> + ltype list -> + unit = + fun env -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_fe -> + fun _visitors_fbody -> + fun _visitors_fkind -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_binder env)) + _visitors_fparams + in + let _visitors_r2 = self#visit_lambda env _visitors_fe in + let _visitors_r3 = self#visit_lambda env _visitors_fbody in + let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fkind in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_ltype env)) + _visitors_ftype_ + in + () method visit_Ljoinapply : _ -> join -> lambda list -> unit = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - () + fun env -> + fun _visitors_fname -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + () method visit_Lbreak : _ -> lambda option -> label -> unit = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_lambda env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - () + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_lambda env) t + | None -> ()) + _visitors_farg + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + () method visit_Lcontinue : _ -> lambda list -> label -> unit = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - () + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + () method visit_Lreturn : _ -> lambda -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - () - - method visit_Lswitch - : _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - () - - method visit_Lswitchint - : _ -> var -> (int * lambda) list -> lambda -> ltype -> unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - () - - method visit_Lswitchstring - : _ -> lambda -> (string * lambda) list -> lambda -> ltype -> unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_lambda env _visitors_c0 in + () + + method visit_Lswitch : + _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + ())) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + () + + method visit_Lswitchint : + _ -> var -> (int * lambda) list -> lambda -> ltype -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + ())) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + () + + method visit_Lswitchstring : + _ -> lambda -> (string * lambda) list -> lambda -> ltype -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + ())) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + () method visit_Lvar : _ -> var -> unit = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - () + fun env -> + fun _visitors_fvar -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + () method visit_Lassign : _ -> var -> lambda -> unit = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - () + fun env -> + fun _visitors_fvar -> + fun _visitors_fe -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + () method visit_Lcatch : _ -> lambda -> lambda -> ltype -> unit = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - () + fun env -> + fun _visitors_fbody -> + fun _visitors_fon_exception -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fbody in + let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in + let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in + () method visit_Lcast : _ -> lambda -> ltype -> unit = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftarget_type -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in + () method visit_lambda : _ -> lambda -> unit = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - need_non_null_cast = _visitors_fneed_non_null_cast; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fneed_non_null_cast - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type + fun env -> + fun _visitors_this -> + match _visitors_this with + | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Levent env _visitors_fexpr _visitors_floc_ + | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 + | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 + | Lget_raw_func _visitors_c0 -> + self#visit_Lget_raw_func env _visitors_c0 + | Lget_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lget_field env _visitors_fobj _visitors_ftid + _visitors_findex _visitors_fkind + | Lclosure_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + } -> + self#visit_Lclosure_field env _visitors_fobj _visitors_ftid + _visitors_findex + | Lset_field + { + obj = _visitors_fobj; + field = _visitors_ffield; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lset_field env _visitors_fobj _visitors_ffield + _visitors_ftid _visitors_findex _visitors_fkind + | Lmake_array + { + tid = _visitors_ftid; + kind = _visitors_fkind; + elems = _visitors_felems; + } -> + self#visit_Lmake_array env _visitors_ftid _visitors_fkind + _visitors_felems + | Larray_get_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + extra = _visitors_fextra; + } -> + self#visit_Larray_get_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fextra + | Larray_set_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + item = _visitors_fitem; + } -> + self#visit_Larray_set_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fitem + | Lapply + { + fn = _visitors_ffn; + prim = _visitors_fprim; + args = _visitors_fargs; + } -> + self#visit_Lapply env _visitors_ffn _visitors_fprim + _visitors_fargs + | Lstub_call + { + fn = _visitors_ffn; + args = _visitors_fargs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + } -> + self#visit_Lstub_call env _visitors_ffn _visitors_fargs + _visitors_fparams_ty _visitors_freturn_ty + | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 + | Lloop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + type_ = _visitors_ftype_; + } -> + self#visit_Lloop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_ftype_ + | Lif + { + pred = _visitors_fpred; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + type_ = _visitors_ftype_; + } -> + self#visit_Lif env _visitors_fpred _visitors_fifso + _visitors_fifnot _visitors_ftype_ + | Llet + { + name = _visitors_fname; + e = _visitors_fe; + body = _visitors_fbody; + } -> + self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody + | Lletrec + { + names = _visitors_fnames; + fns = _visitors_ffns; + body = _visitors_fbody; + } -> + self#visit_Lletrec env _visitors_fnames _visitors_ffns + _visitors_fbody + | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> + self#visit_Lprim env _visitors_ffn _visitors_fargs + | Lsequence + { exprs = _visitors_fexprs; last_expr = _visitors_flast_expr } -> + self#visit_Lsequence env _visitors_fexprs _visitors_flast_expr + | Ljoinlet + { + name = _visitors_fname; + params = _visitors_fparams; + e = _visitors_fe; + body = _visitors_fbody; + kind = _visitors_fkind; + type_ = _visitors_ftype_; + } -> + self#visit_Ljoinlet env _visitors_fname _visitors_fparams + _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ + | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> + self#visit_Ljoinapply env _visitors_fname _visitors_fargs + | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> + self#visit_Lbreak env _visitors_farg _visitors_flabel + | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> + self#visit_Lcontinue env _visitors_fargs _visitors_flabel + | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 + | Lswitch + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitch env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchint + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchint env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchstring + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchstring env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar + | Lassign { var = _visitors_fvar; e = _visitors_fe } -> + self#visit_Lassign env _visitors_fvar _visitors_fe + | Lcatch + { + body = _visitors_fbody; + on_exception = _visitors_fon_exception; + type_ = _visitors_ftype_; + } -> + self#visit_Lcatch env _visitors_fbody _visitors_fon_exception + _visitors_ftype_ + | Lcast + { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } + -> + self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type end [@@@VISITORS.END] @@ -1104,834 +1328,931 @@ include struct inherit [_] mapbase method visit_fn : _ -> fn -> fn = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_ltype env)) - _visitors_this.return_type_ - in - { - params = _visitors_r0; - body = _visitors_r1; - return_type_ = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_binder env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_lambda env _visitors_this.body in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_ltype env)) + _visitors_this.return_type_ + in + { + params = _visitors_r0; + body = _visitors_r1; + return_type_ = _visitors_r2; + } method visit_top_func_item : _ -> top_func_item -> top_func_item = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.fn_kind_ - in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_this.tid - in - { - binder = _visitors_r0; - fn_kind_ = _visitors_r1; - fn = _visitors_r2; - tid = _visitors_r3; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_address env _visitors_this.binder in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.fn_kind_ + in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_this.tid + in + { + binder = _visitors_r0; + fn_kind_ = _visitors_r1; + fn = _visitors_r2; + tid = _visitors_r3; + } method visit_prog : _ -> prog -> prog = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_top_func_item env)) - _visitors_this.fns - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_lambda env) t) - | None -> None) - _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some ((fun _visitors_this -> _visitors_this) t) - | None -> None) - _visitors_c1 - in - (_visitors_r0, _visitors_r1))) - _visitors_this.globals - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.type_defs - in - { - fns = _visitors_r0; - main = _visitors_r1; - init = _visitors_r2; - globals = _visitors_r3; - type_defs = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_top_func_item env)) + _visitors_this.fns + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_lambda env) t) + | None -> None) + _visitors_this.main + in + let _visitors_r2 = self#visit_lambda env _visitors_this.init in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_c1 + in + (_visitors_r0, _visitors_r1))) + _visitors_this.globals + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_this.type_defs + in + { + fns = _visitors_r0; + main = _visitors_r1; + init = _visitors_r2; + globals = _visitors_r3; + type_defs = _visitors_r4; + } method visit_closure : _ -> closure -> closure = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_var env)) - _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.tid - in - { - captures = _visitors_r0; - address = _visitors_r1; - tid = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_var env)) + _visitors_this.captures + in + let _visitors_r1 = + self#visit_closure_address env _visitors_this.address + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.tid + in + { + captures = _visitors_r0; + address = _visitors_r1; + tid = _visitors_r2; + } method visit_aggregate : _ -> aggregate -> aggregate = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.tid - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_this.fields - in - { kind = _visitors_r0; tid = _visitors_r1; fields = _visitors_r2 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_alloc_kind env _visitors_this.kind in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.tid + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_this.fields + in + { kind = _visitors_r0; tid = _visitors_r1; fields = _visitors_r2 } method visit_Dynamic : _ -> var -> target = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - Dynamic _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + Dynamic _visitors_r0 method visit_StaticFn : _ -> address -> target = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - StaticFn _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + StaticFn _visitors_r0 method visit_Object : _ -> var -> int -> ltype -> target = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fmethod_index - in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - Object - { - obj = _visitors_r0; - method_index = _visitors_r1; - method_ty = _visitors_r2; - } + fun env -> + fun _visitors_fobj -> + fun _visitors_fmethod_index -> + fun _visitors_fmethod_ty -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fmethod_index + in + let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in + Object + { + obj = _visitors_r0; + method_index = _visitors_r1; + method_ty = _visitors_r2; + } method visit_target : _ -> target -> target = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 + | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 + | Object + { + obj = _visitors_fobj; + method_index = _visitors_fmethod_index; + method_ty = _visitors_fmethod_ty; + } -> + self#visit_Object env _visitors_fobj _visitors_fmethod_index + _visitors_fmethod_ty method visit_FixedArray_copy : _ -> _ -> _ -> intrinsic = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fsrc_tid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fdst_tid - in - FixedArray_copy { src_tid = _visitors_r0; dst_tid = _visitors_r1 } + fun env -> + fun _visitors_fsrc_tid -> + fun _visitors_fdst_tid -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fsrc_tid + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fdst_tid + in + FixedArray_copy { src_tid = _visitors_r0; dst_tid = _visitors_r1 } method visit_FixedArray_fill : _ -> _ -> intrinsic = - fun env _visitors_ftid -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - FixedArray_fill { tid = _visitors_r0 } + fun env -> + fun _visitors_ftid -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + FixedArray_fill { tid = _visitors_r0 } + + method visit_Char_to_string : _ -> intrinsic = fun env -> Char_to_string method visit_intrinsic : _ -> intrinsic -> intrinsic = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid + fun env -> + fun _visitors_this -> + match _visitors_this with + | FixedArray_copy + { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> + self#visit_FixedArray_copy env _visitors_fsrc_tid + _visitors_fdst_tid + | FixedArray_fill { tid = _visitors_ftid } -> + self#visit_FixedArray_fill env _visitors_ftid + | Char_to_string -> self#visit_Char_to_string env method visit_Levent : _ -> lambda -> location -> lambda = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Levent { expr = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Levent { expr = _visitors_r0; loc_ = _visitors_r1 } method visit_Lallocate : _ -> aggregate -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - Lallocate _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_aggregate env _visitors_c0 in + Lallocate _visitors_r0 method visit_Lclosure : _ -> closure -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - Lclosure _visitors_r0 - - method visit_Lget_field - : _ -> lambda -> _ -> int -> aggregate_kind -> lambda = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - Lget_field - { - obj = _visitors_r0; - tid = _visitors_r1; - index = _visitors_r2; - kind = _visitors_r3; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_closure env _visitors_c0 in + Lclosure _visitors_r0 + + method visit_Lget_raw_func : _ -> address -> lambda = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + Lget_raw_func _visitors_r0 + + method visit_Lget_field : + _ -> lambda -> _ -> int -> get_field_kind -> lambda = + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_findex + in + let _visitors_r3 = + self#visit_get_field_kind env _visitors_fkind + in + Lget_field + { + obj = _visitors_r0; + tid = _visitors_r1; + index = _visitors_r2; + kind = _visitors_r3; + } method visit_Lclosure_field : _ -> lambda -> _ -> int -> lambda = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - Lclosure_field - { obj = _visitors_r0; tid = _visitors_r1; index = _visitors_r2 } - - method visit_Lset_field - : _ -> lambda -> lambda -> _ -> int -> aggregate_kind -> lambda = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = self#visit_lambda env _visitors_ffield in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - Lset_field - { - obj = _visitors_r0; - field = _visitors_r1; - tid = _visitors_r2; - index = _visitors_r3; - kind = _visitors_r4; - } + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_findex + in + Lclosure_field + { obj = _visitors_r0; tid = _visitors_r1; index = _visitors_r2 } + + method visit_Lset_field : + _ -> lambda -> lambda -> _ -> int -> set_field_kind -> lambda = + fun env -> + fun _visitors_fobj -> + fun _visitors_ffield -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = self#visit_lambda env _visitors_ffield in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_findex + in + let _visitors_r4 = + self#visit_set_field_kind env _visitors_fkind + in + Lset_field + { + obj = _visitors_r0; + field = _visitors_r1; + tid = _visitors_r2; + index = _visitors_r3; + kind = _visitors_r4; + } method visit_Lmake_array : _ -> _ -> _ -> lambda list -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_felems - in - Lmake_array - { tid = _visitors_r0; kind = _visitors_r1; elems = _visitors_r2 } - - method visit_Larray_get_item - : _ -> _ -> _ -> lambda -> lambda -> bool -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fneed_non_null_cast -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fneed_non_null_cast - in - Larray_get_item - { - tid = _visitors_r0; - kind = _visitors_r1; - arr = _visitors_r2; - index = _visitors_r3; - need_non_null_cast = _visitors_r4; - } - - method visit_Larray_set_item - : _ -> _ -> _ -> lambda -> lambda -> lambda option -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_lambda env) t) - | None -> None) - _visitors_fitem - in - Larray_set_item - { - tid = _visitors_r0; - kind = _visitors_r1; - arr = _visitors_r2; - index = _visitors_r3; - item = _visitors_r4; - } - - method visit_Lapply - : _ -> target -> intrinsic option -> lambda list -> lambda = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_intrinsic env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - Lapply { fn = _visitors_r0; prim = _visitors_r1; args = _visitors_r2 } - - method visit_Lstub_call - : _ -> - func_stubs -> - lambda list -> - ltype list -> - ltype option -> - lambda = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_ltype env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_ltype env) t) - | None -> None) - _visitors_freturn_ty - in - Lstub_call - { - fn = _visitors_r0; - args = _visitors_r1; - params_ty = _visitors_r2; - return_ty = _visitors_r3; - } + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_felems -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_felems + in + Lmake_array + { tid = _visitors_r0; kind = _visitors_r1; elems = _visitors_r2 } + + method visit_Larray_get_item : + _ -> _ -> _ -> lambda -> lambda -> _ -> lambda = + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fextra -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fextra + in + Larray_get_item + { + tid = _visitors_r0; + kind = _visitors_r1; + arr = _visitors_r2; + index = _visitors_r3; + extra = _visitors_r4; + } + + method visit_Larray_set_item : + _ -> _ -> _ -> lambda -> lambda -> lambda option -> lambda = + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fitem -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_ftid + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_lambda env) t) + | None -> None) + _visitors_fitem + in + Larray_set_item + { + tid = _visitors_r0; + kind = _visitors_r1; + arr = _visitors_r2; + index = _visitors_r3; + item = _visitors_r4; + } + + method visit_Lapply : + _ -> target -> intrinsic option -> lambda list -> lambda = + fun env -> + fun _visitors_ffn -> + fun _visitors_fprim -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_target env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_intrinsic env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + Lapply + { fn = _visitors_r0; prim = _visitors_r1; args = _visitors_r2 } + + method visit_Lstub_call : + _ -> func_stubs -> lambda list -> ltype list -> ltype option -> lambda + = + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_ltype env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_ltype env) t) + | None -> None) + _visitors_freturn_ty + in + Lstub_call + { + fn = _visitors_r0; + args = _visitors_r1; + params_ty = _visitors_r2; + return_ty = _visitors_r3; + } method visit_Lconst : _ -> constant -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Lconst _visitors_r0 - - method visit_Lloop - : _ -> - binder list -> - lambda -> - lambda list -> - label -> - ltype -> - lambda = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in - Lloop - { - params = _visitors_r0; - body = _visitors_r1; - args = _visitors_r2; - label = _visitors_r3; - type_ = _visitors_r4; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + Lconst _visitors_r0 + + method visit_Lloop : + _ -> binder list -> lambda -> lambda list -> label -> ltype -> lambda + = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_ftype_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_binder env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_lambda env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r3 = self#visit_label env _visitors_flabel in + let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in + Lloop + { + params = _visitors_r0; + body = _visitors_r1; + args = _visitors_r2; + label = _visitors_r3; + type_ = _visitors_r4; + } method visit_Lif : _ -> lambda -> lambda -> lambda -> ltype -> lambda = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - Lif - { - pred = _visitors_r0; - ifso = _visitors_r1; - ifnot = _visitors_r2; - type_ = _visitors_r3; - } + fun env -> + fun _visitors_fpred -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fpred in + let _visitors_r1 = self#visit_lambda env _visitors_fifso in + let _visitors_r2 = self#visit_lambda env _visitors_fifnot in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + Lif + { + pred = _visitors_r0; + ifso = _visitors_r1; + ifnot = _visitors_r2; + type_ = _visitors_r3; + } method visit_Llet : _ -> binder -> lambda -> lambda -> lambda = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - Llet { name = _visitors_r0; e = _visitors_r1; body = _visitors_r2 } - - method visit_Lletrec - : _ -> binder list -> closure list -> lambda -> lambda = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_closure env)) - _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - Lletrec - { names = _visitors_r0; fns = _visitors_r1; body = _visitors_r2 } + fun env -> + fun _visitors_fname -> + fun _visitors_fe -> + fun _visitors_fbody -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + Llet { name = _visitors_r0; e = _visitors_r1; body = _visitors_r2 } + + method visit_Lletrec : + _ -> binder list -> closure list -> lambda -> lambda = + fun env -> + fun _visitors_fnames -> + fun _visitors_ffns -> + fun _visitors_fbody -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_binder env)) + _visitors_fnames + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_closure env)) + _visitors_ffns + in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + Lletrec + { names = _visitors_r0; fns = _visitors_r1; body = _visitors_r2 } method visit_Lprim : _ -> prim -> lambda list -> lambda = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - Lprim { fn = _visitors_r0; args = _visitors_r1 } - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> lambda = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - Lsequence - { - expr1 = _visitors_r0; - expr2 = _visitors_r1; - expr1_type_ = _visitors_r2; - } - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - ltype list -> - lambda = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r5 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_ltype env)) - _visitors_ftype_ - in - Ljoinlet - { - name = _visitors_r0; - params = _visitors_r1; - e = _visitors_r2; - body = _visitors_r3; - kind = _visitors_r4; - type_ = _visitors_r5; - } + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_prim env _visitors_ffn in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + Lprim { fn = _visitors_r0; args = _visitors_r1 } + + method visit_Lsequence : _ -> lambda list -> lambda -> lambda = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_lambda env _visitors_flast_expr in + Lsequence { exprs = _visitors_r0; last_expr = _visitors_r1 } + + method visit_Ljoinlet : + _ -> + join -> + binder list -> + lambda -> + lambda -> + join_kind -> + ltype list -> + lambda = + fun env -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_fe -> + fun _visitors_fbody -> + fun _visitors_fkind -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_binder env)) + _visitors_fparams + in + let _visitors_r2 = self#visit_lambda env _visitors_fe in + let _visitors_r3 = self#visit_lambda env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_ltype env)) + _visitors_ftype_ + in + Ljoinlet + { + name = _visitors_r0; + params = _visitors_r1; + e = _visitors_r2; + body = _visitors_r3; + kind = _visitors_r4; + type_ = _visitors_r5; + } method visit_Ljoinapply : _ -> join -> lambda list -> lambda = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - Ljoinapply { name = _visitors_r0; args = _visitors_r1 } + fun env -> + fun _visitors_fname -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + Ljoinapply { name = _visitors_r0; args = _visitors_r1 } method visit_Lbreak : _ -> lambda option -> label -> lambda = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_lambda env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - Lbreak { arg = _visitors_r0; label = _visitors_r1 } + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_lambda env) t) + | None -> None) + _visitors_farg + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + Lbreak { arg = _visitors_r0; label = _visitors_r1 } method visit_Lcontinue : _ -> lambda list -> label -> lambda = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_lambda env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - Lcontinue { args = _visitors_r0; label = _visitors_r1 } + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_lambda env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + Lcontinue { args = _visitors_r0; label = _visitors_r1 } method visit_Lreturn : _ -> lambda -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - Lreturn _visitors_r0 - - method visit_Lswitch - : _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> lambda - = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - Lswitch - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Lswitchint - : _ -> var -> (int * lambda) list -> lambda -> ltype -> lambda = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - Lswitchint - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Lswitchstring - : _ -> lambda -> (string * lambda) list -> lambda -> ltype -> lambda = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - Lswitchstring - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_lambda env _visitors_c0 in + Lreturn _visitors_r0 + + method visit_Lswitch : + _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> lambda = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + Lswitch + { + obj = _visitors_r0; + cases = _visitors_r1; + default = _visitors_r2; + type_ = _visitors_r3; + } + + method visit_Lswitchint : + _ -> var -> (int * lambda) list -> lambda -> ltype -> lambda = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + Lswitchint + { + obj = _visitors_r0; + cases = _visitors_r1; + default = _visitors_r2; + type_ = _visitors_r3; + } + + method visit_Lswitchstring : + _ -> lambda -> (string * lambda) list -> lambda -> ltype -> lambda = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + Lswitchstring + { + obj = _visitors_r0; + cases = _visitors_r1; + default = _visitors_r2; + type_ = _visitors_r3; + } method visit_Lvar : _ -> var -> lambda = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - Lvar { var = _visitors_r0 } + fun env -> + fun _visitors_fvar -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + Lvar { var = _visitors_r0 } method visit_Lassign : _ -> var -> lambda -> lambda = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - Lassign { var = _visitors_r0; e = _visitors_r1 } + fun env -> + fun _visitors_fvar -> + fun _visitors_fe -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + Lassign { var = _visitors_r0; e = _visitors_r1 } method visit_Lcatch : _ -> lambda -> lambda -> ltype -> lambda = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - Lcatch - { - body = _visitors_r0; - on_exception = _visitors_r1; - type_ = _visitors_r2; - } + fun env -> + fun _visitors_fbody -> + fun _visitors_fon_exception -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fbody in + let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in + let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in + Lcatch + { + body = _visitors_r0; + on_exception = _visitors_r1; + type_ = _visitors_r2; + } method visit_Lcast : _ -> lambda -> ltype -> lambda = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - Lcast { expr = _visitors_r0; target_type = _visitors_r1 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftarget_type -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in + Lcast { expr = _visitors_r0; target_type = _visitors_r1 } method visit_lambda : _ -> lambda -> lambda = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - need_non_null_cast = _visitors_fneed_non_null_cast; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fneed_non_null_cast - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type + fun env -> + fun _visitors_this -> + match _visitors_this with + | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Levent env _visitors_fexpr _visitors_floc_ + | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 + | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 + | Lget_raw_func _visitors_c0 -> + self#visit_Lget_raw_func env _visitors_c0 + | Lget_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lget_field env _visitors_fobj _visitors_ftid + _visitors_findex _visitors_fkind + | Lclosure_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + } -> + self#visit_Lclosure_field env _visitors_fobj _visitors_ftid + _visitors_findex + | Lset_field + { + obj = _visitors_fobj; + field = _visitors_ffield; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lset_field env _visitors_fobj _visitors_ffield + _visitors_ftid _visitors_findex _visitors_fkind + | Lmake_array + { + tid = _visitors_ftid; + kind = _visitors_fkind; + elems = _visitors_felems; + } -> + self#visit_Lmake_array env _visitors_ftid _visitors_fkind + _visitors_felems + | Larray_get_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + extra = _visitors_fextra; + } -> + self#visit_Larray_get_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fextra + | Larray_set_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + item = _visitors_fitem; + } -> + self#visit_Larray_set_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fitem + | Lapply + { + fn = _visitors_ffn; + prim = _visitors_fprim; + args = _visitors_fargs; + } -> + self#visit_Lapply env _visitors_ffn _visitors_fprim + _visitors_fargs + | Lstub_call + { + fn = _visitors_ffn; + args = _visitors_fargs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + } -> + self#visit_Lstub_call env _visitors_ffn _visitors_fargs + _visitors_fparams_ty _visitors_freturn_ty + | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 + | Lloop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + type_ = _visitors_ftype_; + } -> + self#visit_Lloop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_ftype_ + | Lif + { + pred = _visitors_fpred; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + type_ = _visitors_ftype_; + } -> + self#visit_Lif env _visitors_fpred _visitors_fifso + _visitors_fifnot _visitors_ftype_ + | Llet + { + name = _visitors_fname; + e = _visitors_fe; + body = _visitors_fbody; + } -> + self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody + | Lletrec + { + names = _visitors_fnames; + fns = _visitors_ffns; + body = _visitors_fbody; + } -> + self#visit_Lletrec env _visitors_fnames _visitors_ffns + _visitors_fbody + | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> + self#visit_Lprim env _visitors_ffn _visitors_fargs + | Lsequence + { exprs = _visitors_fexprs; last_expr = _visitors_flast_expr } -> + self#visit_Lsequence env _visitors_fexprs _visitors_flast_expr + | Ljoinlet + { + name = _visitors_fname; + params = _visitors_fparams; + e = _visitors_fe; + body = _visitors_fbody; + kind = _visitors_fkind; + type_ = _visitors_ftype_; + } -> + self#visit_Ljoinlet env _visitors_fname _visitors_fparams + _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ + | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> + self#visit_Ljoinapply env _visitors_fname _visitors_fargs + | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> + self#visit_Lbreak env _visitors_farg _visitors_flabel + | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> + self#visit_Lcontinue env _visitors_fargs _visitors_flabel + | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 + | Lswitch + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitch env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchint + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchint env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchstring + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchstring env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar + | Lassign { var = _visitors_fvar; e = _visitors_fe } -> + self#visit_Lassign env _visitors_fvar _visitors_fe + | Lcatch + { + body = _visitors_fbody; + on_exception = _visitors_fon_exception; + type_ = _visitors_ftype_; + } -> + self#visit_Lcatch env _visitors_fbody _visitors_fon_exception + _visitors_ftype_ + | Lcast + { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } + -> + self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type end [@@@VISITORS.END] @@ -1946,751 +2267,865 @@ include struct inherit [_] sexpbase method visit_fn : _ -> fn -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - self#visit_list self#visit_ltype env _visitors_this.return_type_ - in - self#visit_record env - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("return_type_", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_binder env _visitors_this.params + in + let _visitors_r1 = self#visit_lambda env _visitors_this.body in + let _visitors_r2 = + self#visit_list self#visit_ltype env _visitors_this.return_type_ + in + self#visit_record env + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("return_type_", _visitors_r2); + ] method visit_top_func_item : _ -> top_func_item -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = self#visit_fn_kind env _visitors_this.fn_kind_ in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = - self#visit_option self#visit_tid env _visitors_this.tid - in - self#visit_record env - [ - ("binder", _visitors_r0); - ("fn_kind_", _visitors_r1); - ("fn", _visitors_r2); - ("tid", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_address env _visitors_this.binder in + let _visitors_r1 = self#visit_fn_kind env _visitors_this.fn_kind_ in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = + self#visit_option self#visit_tid env _visitors_this.tid + in + self#visit_record env + [ + ("binder", _visitors_r0); + ("fn_kind_", _visitors_r1); + ("fn", _visitors_r2); + ("tid", _visitors_r3); + ] method visit_prog : _ -> prog -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_top_func_item env _visitors_this.fns - in - let _visitors_r1 = - self#visit_option self#visit_lambda env _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - self#visit_option self#visit_constant env _visitors_c1 - in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_this.globals - in - let _visitors_r4 = - self#visit_type_defs env _visitors_this.type_defs - in - self#visit_record env - [ - ("fns", _visitors_r0); - ("main", _visitors_r1); - ("init", _visitors_r2); - ("globals", _visitors_r3); - ("type_defs", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_top_func_item env _visitors_this.fns + in + let _visitors_r1 = + self#visit_option self#visit_lambda env _visitors_this.main + in + let _visitors_r2 = self#visit_lambda env _visitors_this.init in + let _visitors_r3 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = + self#visit_option self#visit_constant env _visitors_c1 + in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_this.globals + in + let _visitors_r4 = + self#visit_type_defs env _visitors_this.type_defs + in + self#visit_record env + [ + ("fns", _visitors_r0); + ("main", _visitors_r1); + ("init", _visitors_r2); + ("globals", _visitors_r3); + ("type_defs", _visitors_r4); + ] method visit_closure : _ -> closure -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_var env _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = self#visit_tid env _visitors_this.tid in - self#visit_record env - [ - ("captures", _visitors_r0); - ("address", _visitors_r1); - ("tid", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_var env _visitors_this.captures + in + let _visitors_r1 = + self#visit_closure_address env _visitors_this.address + in + let _visitors_r2 = self#visit_tid env _visitors_this.tid in + self#visit_record env + [ + ("captures", _visitors_r0); + ("address", _visitors_r1); + ("tid", _visitors_r2); + ] method visit_aggregate : _ -> aggregate -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = self#visit_tid env _visitors_this.tid in - let _visitors_r2 = - self#visit_list self#visit_lambda env _visitors_this.fields - in - self#visit_record env - [ - ("kind", _visitors_r0); - ("tid", _visitors_r1); - ("fields", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_alloc_kind env _visitors_this.kind in + let _visitors_r1 = self#visit_tid env _visitors_this.tid in + let _visitors_r2 = + self#visit_list self#visit_lambda env _visitors_this.fields + in + self#visit_record env + [ + ("kind", _visitors_r0); + ("tid", _visitors_r1); + ("fields", _visitors_r2); + ] method visit_Dynamic : _ -> var -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - self#visit_inline_tuple env "Dynamic" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + self#visit_inline_tuple env "Dynamic" [ _visitors_r0 ] method visit_StaticFn : _ -> address -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - self#visit_inline_tuple env "StaticFn" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + self#visit_inline_tuple env "StaticFn" [ _visitors_r0 ] method visit_Object : _ -> var -> int -> ltype -> S.t = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_int env _visitors_fmethod_index in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - self#visit_inline_record env "Object" - [ - ("obj", _visitors_r0); - ("method_index", _visitors_r1); - ("method_ty", _visitors_r2); - ] + fun env -> + fun _visitors_fobj -> + fun _visitors_fmethod_index -> + fun _visitors_fmethod_ty -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = self#visit_int env _visitors_fmethod_index in + let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in + self#visit_inline_record env "Object" + [ + ("obj", _visitors_r0); + ("method_index", _visitors_r1); + ("method_ty", _visitors_r2); + ] method visit_target : _ -> target -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 + | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 + | Object + { + obj = _visitors_fobj; + method_index = _visitors_fmethod_index; + method_ty = _visitors_fmethod_ty; + } -> + self#visit_Object env _visitors_fobj _visitors_fmethod_index + _visitors_fmethod_ty method visit_FixedArray_copy : _ -> _ -> _ -> S.t = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = self#visit_tid env _visitors_fsrc_tid in - let _visitors_r1 = self#visit_tid env _visitors_fdst_tid in - self#visit_inline_record env "FixedArray_copy" - [ ("src_tid", _visitors_r0); ("dst_tid", _visitors_r1) ] + fun env -> + fun _visitors_fsrc_tid -> + fun _visitors_fdst_tid -> + let _visitors_r0 = self#visit_tid env _visitors_fsrc_tid in + let _visitors_r1 = self#visit_tid env _visitors_fdst_tid in + self#visit_inline_record env "FixedArray_copy" + [ ("src_tid", _visitors_r0); ("dst_tid", _visitors_r1) ] method visit_FixedArray_fill : _ -> _ -> S.t = - fun env _visitors_ftid -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - self#visit_inline_record env "FixedArray_fill" - [ ("tid", _visitors_r0) ] + fun env -> + fun _visitors_ftid -> + let _visitors_r0 = self#visit_tid env _visitors_ftid in + self#visit_inline_record env "FixedArray_fill" + [ ("tid", _visitors_r0) ] + + method visit_Char_to_string : _ -> S.t = + fun env -> self#visit_inline_tuple env "Char_to_string" [] method visit_intrinsic : _ -> intrinsic -> S.t = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid + fun env -> + fun _visitors_this -> + match _visitors_this with + | FixedArray_copy + { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> + self#visit_FixedArray_copy env _visitors_fsrc_tid + _visitors_fdst_tid + | FixedArray_fill { tid = _visitors_ftid } -> + self#visit_FixedArray_fill env _visitors_ftid + | Char_to_string -> self#visit_Char_to_string env method visit_Levent : _ -> lambda -> location -> S.t = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Levent" - [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Levent" + [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Lallocate : _ -> aggregate -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - self#visit_inline_tuple env "Lallocate" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_aggregate env _visitors_c0 in + self#visit_inline_tuple env "Lallocate" [ _visitors_r0 ] method visit_Lclosure : _ -> closure -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - self#visit_inline_tuple env "Lclosure" [ _visitors_r0 ] - - method visit_Lget_field : _ -> lambda -> _ -> int -> aggregate_kind -> S.t + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_closure env _visitors_c0 in + self#visit_inline_tuple env "Lclosure" [ _visitors_r0 ] + + method visit_Lget_raw_func : _ -> address -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_address env _visitors_c0 in + self#visit_inline_tuple env "Lget_raw_func" [ _visitors_r0 ] + + method visit_Lget_field : _ -> lambda -> _ -> int -> get_field_kind -> S.t = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = self#visit_tid env _visitors_ftid in - let _visitors_r2 = self#visit_int env _visitors_findex in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - self#visit_inline_record env "Lget_field" - [ - ("obj", _visitors_r0); - ("tid", _visitors_r1); - ("index", _visitors_r2); - ("kind", _visitors_r3); - ] + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = self#visit_tid env _visitors_ftid in + let _visitors_r2 = self#visit_int env _visitors_findex in + let _visitors_r3 = + self#visit_get_field_kind env _visitors_fkind + in + self#visit_inline_record env "Lget_field" + [ + ("obj", _visitors_r0); + ("tid", _visitors_r1); + ("index", _visitors_r2); + ("kind", _visitors_r3); + ] method visit_Lclosure_field : _ -> lambda -> _ -> int -> S.t = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = self#visit_tid env _visitors_ftid in - let _visitors_r2 = self#visit_int env _visitors_findex in - self#visit_inline_record env "Lclosure_field" - [ - ("obj", _visitors_r0); - ("tid", _visitors_r1); - ("index", _visitors_r2); - ] - - method visit_Lset_field - : _ -> lambda -> lambda -> _ -> int -> aggregate_kind -> S.t = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = self#visit_lambda env _visitors_ffield in - let _visitors_r2 = self#visit_tid env _visitors_ftid in - let _visitors_r3 = self#visit_int env _visitors_findex in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - self#visit_inline_record env "Lset_field" - [ - ("obj", _visitors_r0); - ("field", _visitors_r1); - ("tid", _visitors_r2); - ("index", _visitors_r3); - ("kind", _visitors_r4); - ] + fun env -> + fun _visitors_fobj -> + fun _visitors_ftid -> + fun _visitors_findex -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = self#visit_tid env _visitors_ftid in + let _visitors_r2 = self#visit_int env _visitors_findex in + self#visit_inline_record env "Lclosure_field" + [ + ("obj", _visitors_r0); + ("tid", _visitors_r1); + ("index", _visitors_r2); + ] + + method visit_Lset_field : + _ -> lambda -> lambda -> _ -> int -> set_field_kind -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_ffield -> + fun _visitors_ftid -> + fun _visitors_findex -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = self#visit_lambda env _visitors_ffield in + let _visitors_r2 = self#visit_tid env _visitors_ftid in + let _visitors_r3 = self#visit_int env _visitors_findex in + let _visitors_r4 = + self#visit_set_field_kind env _visitors_fkind + in + self#visit_inline_record env "Lset_field" + [ + ("obj", _visitors_r0); + ("field", _visitors_r1); + ("tid", _visitors_r2); + ("index", _visitors_r3); + ("kind", _visitors_r4); + ] method visit_Lmake_array : _ -> _ -> _ -> lambda list -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_make_array_kind env _visitors_fkind in - let _visitors_r2 = - self#visit_list self#visit_lambda env _visitors_felems - in - self#visit_inline_record env "Lmake_array" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("elems", _visitors_r2); - ] - - method visit_Larray_get_item - : _ -> _ -> _ -> lambda -> lambda -> bool -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fneed_non_null_cast -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_array_get_kind env _visitors_fkind in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - self#visit_bool env _visitors_fneed_non_null_cast - in - self#visit_inline_record env "Larray_get_item" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("arr", _visitors_r2); - ("index", _visitors_r3); - ("need_non_null_cast", _visitors_r4); - ] - - method visit_Larray_set_item - : _ -> _ -> _ -> lambda -> lambda -> lambda option -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_array_set_kind env _visitors_fkind in - let _visitors_r2 = self#visit_lambda env _visitors_farr in - let _visitors_r3 = self#visit_lambda env _visitors_findex in - let _visitors_r4 = - self#visit_option self#visit_lambda env _visitors_fitem - in - self#visit_inline_record env "Larray_set_item" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("arr", _visitors_r2); - ("index", _visitors_r3); - ("item", _visitors_r4); - ] - - method visit_Lapply - : _ -> target -> intrinsic option -> lambda list -> S.t = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - self#visit_option self#visit_intrinsic env _visitors_fprim - in - let _visitors_r2 = - self#visit_list self#visit_lambda env _visitors_fargs - in - self#visit_inline_record env "Lapply" - [ - ("fn", _visitors_r0); - ("prim", _visitors_r1); - ("args", _visitors_r2); - ] - - method visit_Lstub_call - : _ -> func_stubs -> lambda list -> ltype list -> ltype option -> S.t + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_felems -> + let _visitors_r0 = self#visit_tid env _visitors_ftid in + let _visitors_r1 = + self#visit_make_array_kind env _visitors_fkind + in + let _visitors_r2 = + self#visit_list self#visit_lambda env _visitors_felems + in + self#visit_inline_record env "Lmake_array" + [ + ("tid", _visitors_r0); + ("kind", _visitors_r1); + ("elems", _visitors_r2); + ] + + method visit_Larray_get_item : _ -> _ -> _ -> lambda -> lambda -> _ -> S.t = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - self#visit_list self#visit_lambda env _visitors_fargs - in - let _visitors_r2 = - self#visit_list self#visit_ltype env _visitors_fparams_ty - in - let _visitors_r3 = - self#visit_option self#visit_ltype env _visitors_freturn_ty - in - self#visit_inline_record env "Lstub_call" - [ - ("fn", _visitors_r0); - ("args", _visitors_r1); - ("params_ty", _visitors_r2); - ("return_ty", _visitors_r3); - ] + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fextra -> + let _visitors_r0 = self#visit_tid env _visitors_ftid in + let _visitors_r1 = + self#visit_array_get_kind env _visitors_fkind + in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = + self#visit_get_item_extra env _visitors_fextra + in + self#visit_inline_record env "Larray_get_item" + [ + ("tid", _visitors_r0); + ("kind", _visitors_r1); + ("arr", _visitors_r2); + ("index", _visitors_r3); + ("extra", _visitors_r4); + ] + + method visit_Larray_set_item : + _ -> _ -> _ -> lambda -> lambda -> lambda option -> S.t = + fun env -> + fun _visitors_ftid -> + fun _visitors_fkind -> + fun _visitors_farr -> + fun _visitors_findex -> + fun _visitors_fitem -> + let _visitors_r0 = self#visit_tid env _visitors_ftid in + let _visitors_r1 = + self#visit_array_set_kind env _visitors_fkind + in + let _visitors_r2 = self#visit_lambda env _visitors_farr in + let _visitors_r3 = self#visit_lambda env _visitors_findex in + let _visitors_r4 = + self#visit_option self#visit_lambda env _visitors_fitem + in + self#visit_inline_record env "Larray_set_item" + [ + ("tid", _visitors_r0); + ("kind", _visitors_r1); + ("arr", _visitors_r2); + ("index", _visitors_r3); + ("item", _visitors_r4); + ] + + method visit_Lapply : + _ -> target -> intrinsic option -> lambda list -> S.t = + fun env -> + fun _visitors_ffn -> + fun _visitors_fprim -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_target env _visitors_ffn in + let _visitors_r1 = + self#visit_option self#visit_intrinsic env _visitors_fprim + in + let _visitors_r2 = + self#visit_list self#visit_lambda env _visitors_fargs + in + self#visit_inline_record env "Lapply" + [ + ("fn", _visitors_r0); + ("prim", _visitors_r1); + ("args", _visitors_r2); + ] + + method visit_Lstub_call : + _ -> func_stubs -> lambda list -> ltype list -> ltype option -> S.t = + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in + let _visitors_r1 = + self#visit_list self#visit_lambda env _visitors_fargs + in + let _visitors_r2 = + self#visit_list self#visit_ltype env _visitors_fparams_ty + in + let _visitors_r3 = + self#visit_option self#visit_ltype env _visitors_freturn_ty + in + self#visit_inline_record env "Lstub_call" + [ + ("fn", _visitors_r0); + ("args", _visitors_r1); + ("params_ty", _visitors_r2); + ("return_ty", _visitors_r3); + ] method visit_Lconst : _ -> constant -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - self#visit_inline_tuple env "Lconst" [ _visitors_r0 ] - - method visit_Lloop - : _ -> binder list -> lambda -> lambda list -> label -> ltype -> S.t = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - self#visit_list self#visit_lambda env _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lloop" - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("args", _visitors_r2); - ("label", _visitors_r3); - ("type_", _visitors_r4); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_constant env _visitors_c0 in + self#visit_inline_tuple env "Lconst" [ _visitors_r0 ] + + method visit_Lloop : + _ -> binder list -> lambda -> lambda list -> label -> ltype -> S.t = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_ftype_ -> + let _visitors_r0 = + self#visit_list self#visit_binder env _visitors_fparams + in + let _visitors_r1 = self#visit_lambda env _visitors_fbody in + let _visitors_r2 = + self#visit_list self#visit_lambda env _visitors_fargs + in + let _visitors_r3 = self#visit_label env _visitors_flabel in + let _visitors_r4 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lloop" + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("args", _visitors_r2); + ("label", _visitors_r3); + ("type_", _visitors_r4); + ] method visit_Lif : _ -> lambda -> lambda -> lambda -> ltype -> S.t = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lif" - [ - ("pred", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("type_", _visitors_r3); - ] + fun env -> + fun _visitors_fpred -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fpred in + let _visitors_r1 = self#visit_lambda env _visitors_fifso in + let _visitors_r2 = self#visit_lambda env _visitors_fifnot in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lif" + [ + ("pred", _visitors_r0); + ("ifso", _visitors_r1); + ("ifnot", _visitors_r2); + ("type_", _visitors_r3); + ] method visit_Llet : _ -> binder -> lambda -> lambda -> S.t = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - self#visit_inline_record env "Llet" - [ - ("name", _visitors_r0); ("e", _visitors_r1); ("body", _visitors_r2); - ] + fun env -> + fun _visitors_fname -> + fun _visitors_fe -> + fun _visitors_fbody -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + self#visit_inline_record env "Llet" + [ + ("name", _visitors_r0); + ("e", _visitors_r1); + ("body", _visitors_r2); + ] method visit_Lletrec : _ -> binder list -> closure list -> lambda -> S.t = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_fnames - in - let _visitors_r1 = - self#visit_list self#visit_closure env _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - self#visit_inline_record env "Lletrec" - [ - ("names", _visitors_r0); - ("fns", _visitors_r1); - ("body", _visitors_r2); - ] + fun env -> + fun _visitors_fnames -> + fun _visitors_ffns -> + fun _visitors_fbody -> + let _visitors_r0 = + self#visit_list self#visit_binder env _visitors_fnames + in + let _visitors_r1 = + self#visit_list self#visit_closure env _visitors_ffns + in + let _visitors_r2 = self#visit_lambda env _visitors_fbody in + self#visit_inline_record env "Lletrec" + [ + ("names", _visitors_r0); + ("fns", _visitors_r1); + ("body", _visitors_r2); + ] method visit_Lprim : _ -> prim -> lambda list -> S.t = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - self#visit_list self#visit_lambda env _visitors_fargs - in - self#visit_inline_record env "Lprim" - [ ("fn", _visitors_r0); ("args", _visitors_r1) ] - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - self#visit_inline_record env "Lsequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("expr1_type_", _visitors_r2); - ] - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - ltype list -> - S.t = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - self#visit_list self#visit_binder env _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = self#visit_join_kind env _visitors_fkind in - let _visitors_r5 = - self#visit_list self#visit_ltype env _visitors_ftype_ - in - self#visit_inline_record env "Ljoinlet" - [ - ("name", _visitors_r0); - ("params", _visitors_r1); - ("e", _visitors_r2); - ("body", _visitors_r3); - ("kind", _visitors_r4); - ("type_", _visitors_r5); - ] + fun env -> + fun _visitors_ffn -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_prim env _visitors_ffn in + let _visitors_r1 = + self#visit_list self#visit_lambda env _visitors_fargs + in + self#visit_inline_record env "Lprim" + [ ("fn", _visitors_r0); ("args", _visitors_r1) ] + + method visit_Lsequence : _ -> lambda list -> lambda -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + let _visitors_r0 = + self#visit_list self#visit_lambda env _visitors_fexprs + in + let _visitors_r1 = self#visit_lambda env _visitors_flast_expr in + self#visit_inline_record env "Lsequence" + [ ("exprs", _visitors_r0); ("last_expr", _visitors_r1) ] + + method visit_Ljoinlet : + _ -> + join -> + binder list -> + lambda -> + lambda -> + join_kind -> + ltype list -> + S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_fe -> + fun _visitors_fbody -> + fun _visitors_fkind -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + self#visit_list self#visit_binder env _visitors_fparams + in + let _visitors_r2 = self#visit_lambda env _visitors_fe in + let _visitors_r3 = self#visit_lambda env _visitors_fbody in + let _visitors_r4 = self#visit_join_kind env _visitors_fkind in + let _visitors_r5 = + self#visit_list self#visit_ltype env _visitors_ftype_ + in + self#visit_inline_record env "Ljoinlet" + [ + ("name", _visitors_r0); + ("params", _visitors_r1); + ("e", _visitors_r2); + ("body", _visitors_r3); + ("kind", _visitors_r4); + ("type_", _visitors_r5); + ] method visit_Ljoinapply : _ -> join -> lambda list -> S.t = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - self#visit_list self#visit_lambda env _visitors_fargs - in - self#visit_inline_record env "Ljoinapply" - [ ("name", _visitors_r0); ("args", _visitors_r1) ] + fun env -> + fun _visitors_fname -> + fun _visitors_fargs -> + let _visitors_r0 = self#visit_join env _visitors_fname in + let _visitors_r1 = + self#visit_list self#visit_lambda env _visitors_fargs + in + self#visit_inline_record env "Ljoinapply" + [ ("name", _visitors_r0); ("args", _visitors_r1) ] method visit_Lbreak : _ -> lambda option -> label -> S.t = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - self#visit_option self#visit_lambda env _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - self#visit_inline_record env "Lbreak" - [ ("arg", _visitors_r0); ("label", _visitors_r1) ] + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + let _visitors_r0 = + self#visit_option self#visit_lambda env _visitors_farg + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + self#visit_inline_record env "Lbreak" + [ ("arg", _visitors_r0); ("label", _visitors_r1) ] method visit_Lcontinue : _ -> lambda list -> label -> S.t = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - self#visit_list self#visit_lambda env _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - self#visit_inline_record env "Lcontinue" - [ ("args", _visitors_r0); ("label", _visitors_r1) ] + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + let _visitors_r0 = + self#visit_list self#visit_lambda env _visitors_fargs + in + let _visitors_r1 = self#visit_label env _visitors_flabel in + self#visit_inline_record env "Lcontinue" + [ ("args", _visitors_r0); ("label", _visitors_r1) ] method visit_Lreturn : _ -> lambda -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - self#visit_inline_tuple env "Lreturn" [ _visitors_r0 ] - - method visit_Lswitch - : _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lswitch" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Lswitchint - : _ -> var -> (int * lambda) list -> lambda -> ltype -> S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_int env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lswitchint" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Lswitchstring - : _ -> lambda -> (string * lambda) list -> lambda -> ltype -> S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_string env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lswitchstring" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_lambda env _visitors_c0 in + self#visit_inline_tuple env "Lreturn" [ _visitors_r0 ] + + method visit_Lswitch : + _ -> var -> (constr_tag * lambda) list -> lambda -> ltype -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lswitch" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("type_", _visitors_r3); + ] + + method visit_Lswitchint : + _ -> var -> (int * lambda) list -> lambda -> ltype -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_var env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_int env _visitors_c0 in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lswitchint" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("type_", _visitors_r3); + ] + + method visit_Lswitchstring : + _ -> lambda -> (string * lambda) list -> lambda -> ltype -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_string env _visitors_c0 in + let _visitors_r1 = self#visit_lambda env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcases + in + let _visitors_r2 = self#visit_lambda env _visitors_fdefault in + let _visitors_r3 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lswitchstring" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("type_", _visitors_r3); + ] method visit_Lvar : _ -> var -> S.t = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - self#visit_inline_record env "Lvar" [ ("var", _visitors_r0) ] + fun env -> + fun _visitors_fvar -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + self#visit_inline_record env "Lvar" [ ("var", _visitors_r0) ] method visit_Lassign : _ -> var -> lambda -> S.t = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - self#visit_inline_record env "Lassign" - [ ("var", _visitors_r0); ("e", _visitors_r1) ] + fun env -> + fun _visitors_fvar -> + fun _visitors_fe -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_lambda env _visitors_fe in + self#visit_inline_record env "Lassign" + [ ("var", _visitors_r0); ("e", _visitors_r1) ] method visit_Lcatch : _ -> lambda -> lambda -> ltype -> S.t = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lcatch" - [ - ("body", _visitors_r0); - ("on_exception", _visitors_r1); - ("type_", _visitors_r2); - ] + fun env -> + fun _visitors_fbody -> + fun _visitors_fon_exception -> + fun _visitors_ftype_ -> + let _visitors_r0 = self#visit_lambda env _visitors_fbody in + let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in + let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in + self#visit_inline_record env "Lcatch" + [ + ("body", _visitors_r0); + ("on_exception", _visitors_r1); + ("type_", _visitors_r2); + ] method visit_Lcast : _ -> lambda -> ltype -> S.t = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - self#visit_inline_record env "Lcast" - [ ("expr", _visitors_r0); ("target_type", _visitors_r1) ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftarget_type -> + let _visitors_r0 = self#visit_lambda env _visitors_fexpr in + let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in + self#visit_inline_record env "Lcast" + [ ("expr", _visitors_r0); ("target_type", _visitors_r1) ] method visit_lambda : _ -> lambda -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - need_non_null_cast = _visitors_fneed_non_null_cast; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fneed_non_null_cast - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type + fun env -> + fun _visitors_this -> + match _visitors_this with + | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Levent env _visitors_fexpr _visitors_floc_ + | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 + | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 + | Lget_raw_func _visitors_c0 -> + self#visit_Lget_raw_func env _visitors_c0 + | Lget_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lget_field env _visitors_fobj _visitors_ftid + _visitors_findex _visitors_fkind + | Lclosure_field + { + obj = _visitors_fobj; + tid = _visitors_ftid; + index = _visitors_findex; + } -> + self#visit_Lclosure_field env _visitors_fobj _visitors_ftid + _visitors_findex + | Lset_field + { + obj = _visitors_fobj; + field = _visitors_ffield; + tid = _visitors_ftid; + index = _visitors_findex; + kind = _visitors_fkind; + } -> + self#visit_Lset_field env _visitors_fobj _visitors_ffield + _visitors_ftid _visitors_findex _visitors_fkind + | Lmake_array + { + tid = _visitors_ftid; + kind = _visitors_fkind; + elems = _visitors_felems; + } -> + self#visit_Lmake_array env _visitors_ftid _visitors_fkind + _visitors_felems + | Larray_get_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + extra = _visitors_fextra; + } -> + self#visit_Larray_get_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fextra + | Larray_set_item + { + tid = _visitors_ftid; + kind = _visitors_fkind; + arr = _visitors_farr; + index = _visitors_findex; + item = _visitors_fitem; + } -> + self#visit_Larray_set_item env _visitors_ftid _visitors_fkind + _visitors_farr _visitors_findex _visitors_fitem + | Lapply + { + fn = _visitors_ffn; + prim = _visitors_fprim; + args = _visitors_fargs; + } -> + self#visit_Lapply env _visitors_ffn _visitors_fprim + _visitors_fargs + | Lstub_call + { + fn = _visitors_ffn; + args = _visitors_fargs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + } -> + self#visit_Lstub_call env _visitors_ffn _visitors_fargs + _visitors_fparams_ty _visitors_freturn_ty + | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 + | Lloop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + type_ = _visitors_ftype_; + } -> + self#visit_Lloop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_ftype_ + | Lif + { + pred = _visitors_fpred; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + type_ = _visitors_ftype_; + } -> + self#visit_Lif env _visitors_fpred _visitors_fifso + _visitors_fifnot _visitors_ftype_ + | Llet + { + name = _visitors_fname; + e = _visitors_fe; + body = _visitors_fbody; + } -> + self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody + | Lletrec + { + names = _visitors_fnames; + fns = _visitors_ffns; + body = _visitors_fbody; + } -> + self#visit_Lletrec env _visitors_fnames _visitors_ffns + _visitors_fbody + | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> + self#visit_Lprim env _visitors_ffn _visitors_fargs + | Lsequence + { exprs = _visitors_fexprs; last_expr = _visitors_flast_expr } -> + self#visit_Lsequence env _visitors_fexprs _visitors_flast_expr + | Ljoinlet + { + name = _visitors_fname; + params = _visitors_fparams; + e = _visitors_fe; + body = _visitors_fbody; + kind = _visitors_fkind; + type_ = _visitors_ftype_; + } -> + self#visit_Ljoinlet env _visitors_fname _visitors_fparams + _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ + | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> + self#visit_Ljoinapply env _visitors_fname _visitors_fargs + | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> + self#visit_Lbreak env _visitors_farg _visitors_flabel + | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> + self#visit_Lcontinue env _visitors_fargs _visitors_flabel + | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 + | Lswitch + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitch env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchint + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchint env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lswitchstring + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + type_ = _visitors_ftype_; + } -> + self#visit_Lswitchstring env _visitors_fobj _visitors_fcases + _visitors_fdefault _visitors_ftype_ + | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar + | Lassign { var = _visitors_fvar; e = _visitors_fe } -> + self#visit_Lassign env _visitors_fvar _visitors_fe + | Lcatch + { + body = _visitors_fbody; + on_exception = _visitors_fon_exception; + type_ = _visitors_ftype_; + } -> + self#visit_Lcatch env _visitors_fbody _visitors_fon_exception + _visitors_ftype_ + | Lcast + { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } + -> + self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type end [@@@VISITORS.END] @@ -2723,16 +3158,17 @@ let sexp = super#visit_inline_record env ctor (Basic_lst.fold_right fields [] predicate) - method! visit_Levent (_ : 'a) e loc_ : S.t = - if !Basic_config.show_loc then - let e = self#visit_lambda () e in - let loc_ = self#visit_location () loc_ in - (List - (List.cons - (Atom "Levent" : S.t) - (List.cons (e : S.t) ([ loc_ ] : S.t list))) - : S.t) - else self#visit_lambda () e + method! visit_Levent (_ : 'a) e loc_ = + (if !Basic_config.show_loc then + let e = self#visit_lambda () e in + let loc_ = self#visit_location () loc_ in + (List + (List.cons + (Atom "Levent" : S.t) + (List.cons (e : S.t) ([ loc_ ] : S.t list))) + : S.t) + else self#visit_lambda () e + : S.t) method! visit_Lprim env prim args = let args = Basic_lst.map args (fun x -> self#visit_lambda env x) in @@ -2772,12 +3208,13 @@ let sexp = let cont = self#visit_lambda env lam in let r = List.fold_left - (fun acc (name, e) -> - let e = self#visit_lambda env e in - (List - (List.cons (sexp_of_binder name : S.t) ([ e ] : S.t list)) - : S.t) - :: acc) + (fun acc -> + fun (name, e) -> + let e = self#visit_lambda env e in + (List + (List.cons (sexp_of_binder name : S.t) ([ e ] : S.t list)) + : S.t) + :: acc) [] r in (List @@ -2788,27 +3225,28 @@ let sexp = in aux body [ (name, e) ] - method! visit_Lsequence env expr1 expr2 _ = - let rec aux lam r = + method! visit_Lsequence env exprs last_expr = + let rec aux lam (r : lambda list) = match lam with | Levent { expr; loc_ = _ } when not !Basic_config.show_loc -> aux expr r - | Lsequence { expr1; expr2 } -> aux expr2 (expr1 :: r) + | Lsequence { exprs; last_expr } -> + aux last_expr (List.rev_append exprs r) | _ -> let cont = self#visit_lambda env lam in let r = List.fold_left - (fun acc a -> self#visit_lambda env a :: acc) + (fun acc -> fun a -> self#visit_lambda env a :: acc) [ cont ] r in (List (List.cons (Atom "Lsequence" : S.t) (r : S.t list)) : S.t) in - aux expr2 [ expr1 ] + aux last_expr (List.rev exprs) method! visit_Ljoinlet env name params e body kind _type_ = let name = Join.sexp_of_t name in let params = - (fun x__006_ -> Moon_sexp_conv.sexp_of_list sexp_of_var x__006_) params + (fun x__015_ -> Moon_sexp_conv.sexp_of_list sexp_of_var x__015_) params in let e = self#visit_lambda env e in let body = self#visit_lambda env body in diff --git a/src/clam1.ml b/src/clam1.ml deleted file mode 100644 index 081a2bb..0000000 --- a/src/clam1.ml +++ /dev/null @@ -1,3212 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Tid = Basic_ty_ident -module Lst = Basic_lst - -type constant = Constant.t - -include struct - let _ = fun (_ : constant) -> () - let sexp_of_constant = (Constant.sexp_of_t : constant -> S.t) - let _ = sexp_of_constant -end - -type constr_tag = Tag.t - -include struct - let _ = fun (_ : constr_tag) -> () - let sexp_of_constr_tag = (Tag.sexp_of_t : constr_tag -> S.t) - let _ = sexp_of_constr_tag -end - -type prim = Primitive.prim - -include struct - let _ = fun (_ : prim) -> () - let sexp_of_prim = (Primitive.sexp_of_prim : prim -> S.t) - let _ = sexp_of_prim -end - -type ltype = Ltype.t - -include struct - let _ = fun (_ : ltype) -> () - let sexp_of_ltype = (Ltype.sexp_of_t : ltype -> S.t) - let _ = sexp_of_ltype -end - -type func_stubs = Stub_type.t - -include struct - let _ = fun (_ : func_stubs) -> () - let sexp_of_func_stubs = (Stub_type.sexp_of_t : func_stubs -> S.t) - let _ = sexp_of_func_stubs -end - -module Ident = Clam1_ident - -type location = Loc.t - -include struct - let _ = fun (_ : location) -> () - let sexp_of_location = (Loc.sexp_of_t : location -> S.t) - let _ = sexp_of_location -end - -type binder = Ident.t - -include struct - let _ = fun (_ : binder) -> () - let sexp_of_binder = (Ident.sexp_of_t : binder -> S.t) - let _ = sexp_of_binder -end - -type var = Ident.t - -include struct - let _ = fun (_ : var) -> () - let sexp_of_var = (Ident.sexp_of_t : var -> S.t) - let _ = sexp_of_var -end - -type address = Basic_fn_address.t - -include struct - let _ = fun (_ : address) -> () - let sexp_of_address = (Basic_fn_address.sexp_of_t : address -> S.t) - let _ = sexp_of_address -end - -type join = Join.t - -include struct - let _ = fun (_ : join) -> () - let sexp_of_join = (Join.sexp_of_t : join -> S.t) - let _ = sexp_of_join -end - -type label = Label.t - -include struct - let _ = fun (_ : label) -> () - let sexp_of_label = (Label.sexp_of_t : label -> S.t) - let _ = sexp_of_label -end - -type type_defs = Ltype.type_defs - -include struct - let _ = fun (_ : type_defs) -> () - let sexp_of_type_defs = (Ltype.sexp_of_type_defs : type_defs -> S.t) - let _ = sexp_of_type_defs -end - -type tid = Tid.t - -include struct - let _ = fun (_ : tid) -> () - let sexp_of_tid = (Tid.sexp_of_t : tid -> S.t) - let _ = sexp_of_tid -end - -type fn_kind = Top_pub of string | Top_private - -include struct - let _ = fun (_ : fn_kind) -> () - - let sexp_of_fn_kind = - (function - | Top_pub arg0__001_ -> - let res0__002_ = Moon_sexp_conv.sexp_of_string arg0__001_ in - S.List [ S.Atom "Top_pub"; res0__002_ ] - | Top_private -> S.Atom "Top_private" - : fn_kind -> S.t) - - let _ = sexp_of_fn_kind -end - -type join_kind = Tail_join | Nontail_join - -include struct - let _ = fun (_ : join_kind) -> () - - let sexp_of_join_kind = - (function - | Tail_join -> S.Atom "Tail_join" | Nontail_join -> S.Atom "Nontail_join" - : join_kind -> S.t) - - let _ = sexp_of_join_kind -end - -type aggregate_kind = Tuple | Struct | Enum of { tag : constr_tag } - -include struct - let _ = fun (_ : aggregate_kind) -> () - - let sexp_of_aggregate_kind = - (function - | Tuple -> S.Atom "Tuple" - | Struct -> S.Atom "Struct" - | Enum { tag = tag__004_ } -> - let bnds__003_ = ([] : _ Stdlib.List.t) in - let bnds__003_ = - let arg__005_ = sexp_of_constr_tag tag__004_ in - (S.List [ S.Atom "tag"; arg__005_ ] :: bnds__003_ : _ Stdlib.List.t) - in - S.List (S.Atom "Enum" :: bnds__003_) - : aggregate_kind -> S.t) - - let _ = sexp_of_aggregate_kind -end - -type closure_address = - | Normal of address - | Well_known_mut_rec - | Object of address list - -let sexp_of_closure_address addr = - match addr with - | Normal addr -> S.List [ sexp_of_address addr ] - | Well_known_mut_rec -> S.List [] - | Object methods -> S.List (Atom "Object" :: Lst.map methods sexp_of_address) - -class ['a] mapbase = - object - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_prim : 'a -> Primitive.prim -> Primitive.prim = fun _ e -> e - method visit_constr_tag : 'a -> constr_tag -> constr_tag = fun _ e -> e - method visit_binder : 'a -> binder -> binder = fun _ e -> e - method visit_address : 'a -> address -> address = fun _ e -> e - method visit_join : 'a -> join -> join = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_ltype : 'a -> ltype -> ltype = fun _ e -> e - - method visit_return_type : 'a -> Ltype.return_type -> Ltype.return_type = - fun _ e -> e - - method private visit_func_stubs : 'a -> func_stubs -> func_stubs = - fun _ e -> e - - method private visit_aggregate_kind : 'a -> aggregate_kind -> aggregate_kind - = - fun _ e -> e - - method private visit_closure_address - : 'a -> closure_address -> closure_address = - fun _ e -> e - end - -class ['a] iterbase = - object - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_prim : 'a -> Primitive.prim -> unit = fun _ _ -> () - method visit_constr_tag : 'a -> constr_tag -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () - method visit_address : 'a -> address -> unit = fun _ _ -> () - method visit_join : 'a -> join -> unit = fun _ _ -> () - method visit_label : 'a -> label -> unit = fun _ _ -> () - method visit_ltype : 'a -> ltype -> unit = fun _ _ -> () - method visit_return_type : 'a -> Ltype.return_type -> unit = fun _ _ -> () - method private visit_func_stubs : 'a -> func_stubs -> unit = fun _ _ -> () - - method private visit_aggregate_kind : 'a -> aggregate_kind -> unit = - fun _ _ -> () - - method private visit_closure_address : 'a -> closure_address -> unit = - fun _ _ -> () - end - -class virtual ['a] sexpbase = - object - inherit [_] Sexp_visitors.sexp - - method visit_location : 'a -> location -> S.t = - fun _ loc -> sexp_of_location loc - - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x - - method visit_prim : 'a -> Primitive.prim -> S.t = - fun _ x -> Primitive.sexp_of_prim x - - method visit_constr_tag : 'a -> constr_tag -> S.t = - fun _ x -> sexp_of_constr_tag x - - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x - - method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x - - method visit_address : 'a -> address -> S.t = fun _ x -> sexp_of_address x - method visit_join : 'a -> join -> S.t = fun _ x -> sexp_of_join x - method visit_label : 'a -> label -> S.t = fun _ x -> sexp_of_label x - method visit_fn_kind : 'a -> fn_kind -> S.t = fun _ x -> sexp_of_fn_kind x - method visit_ltype : 'a -> ltype -> S.t = fun _ x -> sexp_of_ltype x - - method visit_return_type : 'a -> Ltype.return_type -> S.t = - fun _ x -> Ltype.sexp_of_return_type x - - method visit_join_kind : 'a -> join_kind -> S.t = - fun _ x -> sexp_of_join_kind x - - method visit_type_defs : 'a -> type_defs -> S.t = - fun _ x -> sexp_of_type_defs x - - method visit_tid : 'a -> tid -> S.t = fun _ x -> sexp_of_tid x - - method private visit_func_stubs : 'a -> func_stubs -> S.t = - fun _ x -> sexp_of_func_stubs x - - method private visit_aggregate_kind : 'a -> aggregate_kind -> S.t = - fun _ x -> sexp_of_aggregate_kind x - - method private visit_closure_address : 'a -> closure_address -> S.t = - fun _ x -> sexp_of_closure_address x - - method private visit_make_array_kind - : 'a -> Primitive.make_array_kind -> S.t = - fun _ x -> Primitive.sexp_of_make_array_kind x - - method private visit_array_get_kind : 'a -> Primitive.array_get_kind -> S.t - = - fun _ x -> Primitive.sexp_of_array_get_kind x - - method private visit_array_set_kind : 'a -> Primitive.array_set_kind -> S.t - = - fun _ x -> Primitive.sexp_of_array_set_kind x - end - -type fn = { - params : binder list; - body : lambda; - return_type_ : Ltype.return_type; -} - -and top_func_item = { binder : address; fn_kind_ : fn_kind; fn : fn } - -and prog = { - fns : top_func_item list; - main : lambda option; - init : lambda; - globals : (binder * constant option) list; - type_defs : type_defs; -} - -and closure = { - captures : var list; - address : closure_address; - tid : (tid[@visitors.opaque]); -} - -and aggregate = { - kind : aggregate_kind; - tid : (tid[@visitors.opaque]); - fields : value list; -} - -and target = - | Dynamic of var - | StaticFn of address - | Object of { obj : var; method_index : int; method_ty : ltype } - -and intrinsic = - | FixedArray_copy of { - src_tid : (tid[@visitors.opaque]); - dst_tid : (tid[@visitors.opaque]); - } - | FixedArray_fill of { tid : (tid[@visitors.opaque]) } - -and value = Vvar of var | Vconst of constant - -and lambda = - | Levent of { expr : lambda; loc_ : location } - | Lallocate of aggregate - | Lclosure of closure - | Lget_field of { - obj : var; - tid : (tid[@visitors.opaque]); - index : int; - kind : aggregate_kind; - } - | Lclosure_field of { obj : var; tid : (tid[@visitors.opaque]); index : int } - | Lset_field of { - obj : var; - field : value; - tid : (tid[@visitors.opaque]); - index : int; - kind : aggregate_kind; - } - | Lmake_array of { - tid : (tid[@visitors.opaque]); - kind : (Primitive.make_array_kind[@visitors.opaque]); - elems : value list; - } - | Larray_get_item of { - tid : (tid[@visitors.opaque]); - kind : (Primitive.array_get_kind[@visitors.opaque]); - arr : value; - index : value; - } - | Larray_set_item of { - tid : (tid[@visitors.opaque]); - kind : (Primitive.array_set_kind[@visitors.opaque]); - arr : value; - index : value; - item : value option; - } - | Lapply of { fn : target; prim : intrinsic option; args : value list } - | Lstub_call of { - fn : func_stubs; - args : value list; - params_ty : ltype list; - return_ty : ltype option; - } - | Lconst of constant - | Lloop of { - params : binder list; - body : lambda; - args : value list; - label : label; - type_ : Ltype.return_type; - } - | Lif of { - pred : lambda; - ifso : lambda; - ifnot : lambda; - type_ : Ltype.return_type; - } - | Llet of { name : binder; e : lambda; body : lambda } - | Lletrec of { names : binder list; fns : closure list; body : lambda } - | Llet_multi of { names : binder list; e : lambda; body : lambda } - | Lprim of { fn : prim; args : value list } - | Lsequence of { expr1 : lambda; expr2 : lambda; expr1_type_ : ltype } - | Ljoinlet of { - name : join; - params : binder list; - e : lambda; - body : lambda; - kind : join_kind; - type_ : Ltype.return_type; - } - | Ljoinapply of { name : join; args : value list } - | Lbreak of { arg : value option; label : label } - | Lcontinue of { args : value list; label : label } - | Lreturn of lambda - | Lswitch of { - obj : var; - cases : (constr_tag * lambda) list; - default : lambda; - type_ : Ltype.return_type; - } - | Lswitchint of { - obj : var; - cases : (int * lambda) list; - default : lambda; - type_ : Ltype.return_type; - } - | Lswitchstring of { - obj : var; - cases : (string * lambda) list; - default : lambda; - type_ : Ltype.return_type; - } - | Lvar of { var : var } - | Lassign of { var : var; e : lambda } - | Lcatch of { body : lambda; on_exception : lambda; type_ : ltype } - | Lcast of { expr : lambda; target_type : ltype } - | Lmake_multi_result of { - value : value; - tag : constr_tag; - type_ : Ltype.return_type; - } - | Lhandle_error of { - obj : lambda; - ok_branch : binder * lambda; - err_branch : binder * lambda; - type_ : Ltype.return_type; - } - -include struct - [@@@ocaml.warning "-4-26-27"] - [@@@VISITORS.BEGIN] - - class virtual ['self] iter = - object (self : 'self) - inherit [_] iterbase - - method visit_fn : _ -> fn -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - self#visit_return_type env _visitors_this.return_type_ - in - () - - method visit_top_func_item : _ -> top_func_item -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.fn_kind_ - in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - () - - method visit_prog : _ -> prog -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_top_func_item env)) - _visitors_this.fns - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_lambda env) t - | None -> ()) - _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (fun _visitors_this -> ()) t - | None -> ()) - _visitors_c1 - in - ())) - _visitors_this.globals - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.type_defs - in - () - - method visit_closure : _ -> closure -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_var env)) - _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_this.tid in - () - - method visit_aggregate : _ -> aggregate -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.tid in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_this.fields - in - () - - method visit_Dynamic : _ -> var -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - () - - method visit_StaticFn : _ -> address -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - () - - method visit_Object : _ -> var -> int -> ltype -> unit = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fmethod_index - in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - () - - method visit_target : _ -> target -> unit = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty - - method visit_FixedArray_copy : _ -> _ -> _ -> unit = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fsrc_tid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fdst_tid in - () - - method visit_FixedArray_fill : _ -> _ -> unit = - fun env _visitors_ftid -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - () - - method visit_intrinsic : _ -> intrinsic -> unit = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid - - method visit_Vvar : _ -> var -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - () - - method visit_Vconst : _ -> constant -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - () - - method visit_value : _ -> value -> unit = - fun env _visitors_this -> - match _visitors_this with - | Vvar _visitors_c0 -> self#visit_Vvar env _visitors_c0 - | Vconst _visitors_c0 -> self#visit_Vconst env _visitors_c0 - - method visit_Levent : _ -> lambda -> location -> unit = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Lallocate : _ -> aggregate -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - () - - method visit_Lclosure : _ -> closure -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - () - - method visit_Lget_field : _ -> var -> _ -> int -> aggregate_kind -> unit = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - () - - method visit_Lclosure_field : _ -> var -> _ -> int -> unit = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_findex in - () - - method visit_Lset_field - : _ -> var -> value -> _ -> int -> aggregate_kind -> unit = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_value env _visitors_ffield in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_findex in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - () - - method visit_Lmake_array : _ -> _ -> _ -> value list -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_felems - in - () - - method visit_Larray_get_item : _ -> _ -> _ -> value -> value -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - () - - method visit_Larray_set_item - : _ -> _ -> _ -> value -> value -> value option -> unit = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_ftid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_value env) t - | None -> ()) - _visitors_fitem - in - () - - method visit_Lapply - : _ -> target -> intrinsic option -> value list -> unit = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_intrinsic env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - () - - method visit_Lstub_call - : _ -> func_stubs -> value list -> ltype list -> ltype option -> unit - = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_ltype env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_ltype env) t - | None -> ()) - _visitors_freturn_ty - in - () - - method visit_Lconst : _ -> constant -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - () - - method visit_Lloop - : _ -> - binder list -> - lambda -> - value list -> - label -> - Ltype.return_type -> - unit = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Lif - : _ -> lambda -> lambda -> lambda -> Ltype.return_type -> unit = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Llet : _ -> binder -> lambda -> lambda -> unit = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - () - - method visit_Lletrec : _ -> binder list -> closure list -> lambda -> unit - = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_closure env)) - _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - () - - method visit_Llet_multi : _ -> binder list -> lambda -> lambda -> unit = - fun env _visitors_fnames _visitors_fe _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - () - - method visit_Lprim : _ -> prim -> value list -> unit = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - () - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - () - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - Ltype.return_type -> - unit = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r5 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Ljoinapply : _ -> join -> value list -> unit = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - () - - method visit_Lbreak : _ -> value option -> label -> unit = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_value env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - () - - method visit_Lcontinue : _ -> value list -> label -> unit = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - () - - method visit_Lreturn : _ -> lambda -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - () - - method visit_Lswitch - : _ -> - var -> - (constr_tag * lambda) list -> - lambda -> - Ltype.return_type -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Lswitchint - : _ -> - var -> - (int * lambda) list -> - lambda -> - Ltype.return_type -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Lswitchstring - : _ -> - var -> - (string * lambda) list -> - lambda -> - Ltype.return_type -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Lvar : _ -> var -> unit = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - () - - method visit_Lassign : _ -> var -> lambda -> unit = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - () - - method visit_Lcatch : _ -> lambda -> lambda -> ltype -> unit = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - () - - method visit_Lcast : _ -> lambda -> ltype -> unit = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - () - - method visit_Lmake_multi_result - : _ -> value -> constr_tag -> Ltype.return_type -> unit = - fun env _visitors_fvalue _visitors_ftag _visitors_ftype_ -> - let _visitors_r0 = self#visit_value env _visitors_fvalue in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_Lhandle_error - : _ -> - lambda -> - binder * lambda -> - binder * lambda -> - Ltype.return_type -> - unit = - fun env _visitors_fobj _visitors_fok_branch _visitors_ferr_branch - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ()) - _visitors_fok_branch - in - let _visitors_r2 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - ()) - _visitors_ferr_branch - in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - () - - method visit_lambda : _ -> lambda -> unit = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Llet_multi - { - names = _visitors_fnames; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet_multi env _visitors_fnames _visitors_fe - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type - | Lmake_multi_result - { - value = _visitors_fvalue; - tag = _visitors_ftag; - type_ = _visitors_ftype_; - } -> - self#visit_Lmake_multi_result env _visitors_fvalue _visitors_ftag - _visitors_ftype_ - | Lhandle_error - { - obj = _visitors_fobj; - ok_branch = _visitors_fok_branch; - err_branch = _visitors_ferr_branch; - type_ = _visitors_ftype_; - } -> - self#visit_Lhandle_error env _visitors_fobj _visitors_fok_branch - _visitors_ferr_branch _visitors_ftype_ - end - - [@@@VISITORS.END] -end - -include struct - [@@@ocaml.warning "-4-26-27"] - [@@@VISITORS.BEGIN] - - class virtual ['self] map = - object (self : 'self) - inherit [_] mapbase - - method visit_fn : _ -> fn -> fn = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - self#visit_return_type env _visitors_this.return_type_ - in - { - params = _visitors_r0; - body = _visitors_r1; - return_type_ = _visitors_r2; - } - - method visit_top_func_item : _ -> top_func_item -> top_func_item = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.fn_kind_ - in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - { binder = _visitors_r0; fn_kind_ = _visitors_r1; fn = _visitors_r2 } - - method visit_prog : _ -> prog -> prog = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_top_func_item env)) - _visitors_this.fns - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_lambda env) t) - | None -> None) - _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some ((fun _visitors_this -> _visitors_this) t) - | None -> None) - _visitors_c1 - in - (_visitors_r0, _visitors_r1))) - _visitors_this.globals - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.type_defs - in - { - fns = _visitors_r0; - main = _visitors_r1; - init = _visitors_r2; - globals = _visitors_r3; - type_defs = _visitors_r4; - } - - method visit_closure : _ -> closure -> closure = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_var env)) - _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.tid - in - { - captures = _visitors_r0; - address = _visitors_r1; - tid = _visitors_r2; - } - - method visit_aggregate : _ -> aggregate -> aggregate = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.tid - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_this.fields - in - { kind = _visitors_r0; tid = _visitors_r1; fields = _visitors_r2 } - - method visit_Dynamic : _ -> var -> target = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - Dynamic _visitors_r0 - - method visit_StaticFn : _ -> address -> target = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - StaticFn _visitors_r0 - - method visit_Object : _ -> var -> int -> ltype -> target = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fmethod_index - in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - Object - { - obj = _visitors_r0; - method_index = _visitors_r1; - method_ty = _visitors_r2; - } - - method visit_target : _ -> target -> target = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty - - method visit_FixedArray_copy : _ -> _ -> _ -> intrinsic = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fsrc_tid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fdst_tid - in - FixedArray_copy { src_tid = _visitors_r0; dst_tid = _visitors_r1 } - - method visit_FixedArray_fill : _ -> _ -> intrinsic = - fun env _visitors_ftid -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - FixedArray_fill { tid = _visitors_r0 } - - method visit_intrinsic : _ -> intrinsic -> intrinsic = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid - - method visit_Vvar : _ -> var -> value = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - Vvar _visitors_r0 - - method visit_Vconst : _ -> constant -> value = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Vconst _visitors_r0 - - method visit_value : _ -> value -> value = - fun env _visitors_this -> - match _visitors_this with - | Vvar _visitors_c0 -> self#visit_Vvar env _visitors_c0 - | Vconst _visitors_c0 -> self#visit_Vconst env _visitors_c0 - - method visit_Levent : _ -> lambda -> location -> lambda = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Levent { expr = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Lallocate : _ -> aggregate -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - Lallocate _visitors_r0 - - method visit_Lclosure : _ -> closure -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - Lclosure _visitors_r0 - - method visit_Lget_field : _ -> var -> _ -> int -> aggregate_kind -> lambda - = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - Lget_field - { - obj = _visitors_r0; - tid = _visitors_r1; - index = _visitors_r2; - kind = _visitors_r3; - } - - method visit_Lclosure_field : _ -> var -> _ -> int -> lambda = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - Lclosure_field - { obj = _visitors_r0; tid = _visitors_r1; index = _visitors_r2 } - - method visit_Lset_field - : _ -> var -> value -> _ -> int -> aggregate_kind -> lambda = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_value env _visitors_ffield in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_findex - in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - Lset_field - { - obj = _visitors_r0; - field = _visitors_r1; - tid = _visitors_r2; - index = _visitors_r3; - kind = _visitors_r4; - } - - method visit_Lmake_array : _ -> _ -> _ -> value list -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_felems - in - Lmake_array - { tid = _visitors_r0; kind = _visitors_r1; elems = _visitors_r2 } - - method visit_Larray_get_item : _ -> _ -> _ -> value -> value -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - Larray_get_item - { - tid = _visitors_r0; - kind = _visitors_r1; - arr = _visitors_r2; - index = _visitors_r3; - } - - method visit_Larray_set_item - : _ -> _ -> _ -> value -> value -> value option -> lambda = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_ftid - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_value env) t) - | None -> None) - _visitors_fitem - in - Larray_set_item - { - tid = _visitors_r0; - kind = _visitors_r1; - arr = _visitors_r2; - index = _visitors_r3; - item = _visitors_r4; - } - - method visit_Lapply - : _ -> target -> intrinsic option -> value list -> lambda = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_intrinsic env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - Lapply { fn = _visitors_r0; prim = _visitors_r1; args = _visitors_r2 } - - method visit_Lstub_call - : _ -> - func_stubs -> - value list -> - ltype list -> - ltype option -> - lambda = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_ltype env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_ltype env) t) - | None -> None) - _visitors_freturn_ty - in - Lstub_call - { - fn = _visitors_r0; - args = _visitors_r1; - params_ty = _visitors_r2; - return_ty = _visitors_r3; - } - - method visit_Lconst : _ -> constant -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Lconst _visitors_r0 - - method visit_Lloop - : _ -> - binder list -> - lambda -> - value list -> - label -> - Ltype.return_type -> - lambda = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_return_type env _visitors_ftype_ in - Lloop - { - params = _visitors_r0; - body = _visitors_r1; - args = _visitors_r2; - label = _visitors_r3; - type_ = _visitors_r4; - } - - method visit_Lif - : _ -> lambda -> lambda -> lambda -> Ltype.return_type -> lambda = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - Lif - { - pred = _visitors_r0; - ifso = _visitors_r1; - ifnot = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Llet : _ -> binder -> lambda -> lambda -> lambda = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - Llet { name = _visitors_r0; e = _visitors_r1; body = _visitors_r2 } - - method visit_Lletrec - : _ -> binder list -> closure list -> lambda -> lambda = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_closure env)) - _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - Lletrec - { names = _visitors_r0; fns = _visitors_r1; body = _visitors_r2 } - - method visit_Llet_multi : _ -> binder list -> lambda -> lambda -> lambda = - fun env _visitors_fnames _visitors_fe _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fnames - in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - Llet_multi - { names = _visitors_r0; e = _visitors_r1; body = _visitors_r2 } - - method visit_Lprim : _ -> prim -> value list -> lambda = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - Lprim { fn = _visitors_r0; args = _visitors_r1 } - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> lambda = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - Lsequence - { - expr1 = _visitors_r0; - expr2 = _visitors_r1; - expr1_type_ = _visitors_r2; - } - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - Ltype.return_type -> - lambda = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_binder env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r5 = self#visit_return_type env _visitors_ftype_ in - Ljoinlet - { - name = _visitors_r0; - params = _visitors_r1; - e = _visitors_r2; - body = _visitors_r3; - kind = _visitors_r4; - type_ = _visitors_r5; - } - - method visit_Ljoinapply : _ -> join -> value list -> lambda = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - Ljoinapply { name = _visitors_r0; args = _visitors_r1 } - - method visit_Lbreak : _ -> value option -> label -> lambda = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_value env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - Lbreak { arg = _visitors_r0; label = _visitors_r1 } - - method visit_Lcontinue : _ -> value list -> label -> lambda = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_value env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - Lcontinue { args = _visitors_r0; label = _visitors_r1 } - - method visit_Lreturn : _ -> lambda -> lambda = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - Lreturn _visitors_r0 - - method visit_Lswitch - : _ -> - var -> - (constr_tag * lambda) list -> - lambda -> - Ltype.return_type -> - lambda = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - Lswitch - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Lswitchint - : _ -> - var -> - (int * lambda) list -> - lambda -> - Ltype.return_type -> - lambda = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - Lswitchint - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Lswitchstring - : _ -> - var -> - (string * lambda) list -> - lambda -> - Ltype.return_type -> - lambda = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - Lswitchstring - { - obj = _visitors_r0; - cases = _visitors_r1; - default = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_Lvar : _ -> var -> lambda = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - Lvar { var = _visitors_r0 } - - method visit_Lassign : _ -> var -> lambda -> lambda = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - Lassign { var = _visitors_r0; e = _visitors_r1 } - - method visit_Lcatch : _ -> lambda -> lambda -> ltype -> lambda = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - Lcatch - { - body = _visitors_r0; - on_exception = _visitors_r1; - type_ = _visitors_r2; - } - - method visit_Lcast : _ -> lambda -> ltype -> lambda = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - Lcast { expr = _visitors_r0; target_type = _visitors_r1 } - - method visit_Lmake_multi_result - : _ -> value -> constr_tag -> Ltype.return_type -> lambda = - fun env _visitors_fvalue _visitors_ftag _visitors_ftype_ -> - let _visitors_r0 = self#visit_value env _visitors_fvalue in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_return_type env _visitors_ftype_ in - Lmake_multi_result - { value = _visitors_r0; tag = _visitors_r1; type_ = _visitors_r2 } - - method visit_Lhandle_error - : _ -> - lambda -> - binder * lambda -> - binder * lambda -> - Ltype.return_type -> - lambda = - fun env _visitors_fobj _visitors_fok_branch _visitors_ferr_branch - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1)) - _visitors_fok_branch - in - let _visitors_r2 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - (_visitors_r0, _visitors_r1)) - _visitors_ferr_branch - in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - Lhandle_error - { - obj = _visitors_r0; - ok_branch = _visitors_r1; - err_branch = _visitors_r2; - type_ = _visitors_r3; - } - - method visit_lambda : _ -> lambda -> lambda = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Llet_multi - { - names = _visitors_fnames; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet_multi env _visitors_fnames _visitors_fe - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type - | Lmake_multi_result - { - value = _visitors_fvalue; - tag = _visitors_ftag; - type_ = _visitors_ftype_; - } -> - self#visit_Lmake_multi_result env _visitors_fvalue _visitors_ftag - _visitors_ftype_ - | Lhandle_error - { - obj = _visitors_fobj; - ok_branch = _visitors_fok_branch; - err_branch = _visitors_ferr_branch; - type_ = _visitors_ftype_; - } -> - self#visit_Lhandle_error env _visitors_fobj _visitors_fok_branch - _visitors_ferr_branch _visitors_ftype_ - end - - [@@@VISITORS.END] -end - -include struct - [@@@ocaml.warning "-4-26-27"] - [@@@VISITORS.BEGIN] - - class virtual ['self] sexp = - object (self : 'self) - inherit [_] sexpbase - - method visit_fn : _ -> fn -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_this.params - in - let _visitors_r1 = self#visit_lambda env _visitors_this.body in - let _visitors_r2 = - self#visit_return_type env _visitors_this.return_type_ - in - self#visit_record env - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("return_type_", _visitors_r2); - ] - - method visit_top_func_item : _ -> top_func_item -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_address env _visitors_this.binder in - let _visitors_r1 = self#visit_fn_kind env _visitors_this.fn_kind_ in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - self#visit_record env - [ - ("binder", _visitors_r0); - ("fn_kind_", _visitors_r1); - ("fn", _visitors_r2); - ] - - method visit_prog : _ -> prog -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_top_func_item env _visitors_this.fns - in - let _visitors_r1 = - self#visit_option self#visit_lambda env _visitors_this.main - in - let _visitors_r2 = self#visit_lambda env _visitors_this.init in - let _visitors_r3 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = - self#visit_option self#visit_constant env _visitors_c1 - in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_this.globals - in - let _visitors_r4 = - self#visit_type_defs env _visitors_this.type_defs - in - self#visit_record env - [ - ("fns", _visitors_r0); - ("main", _visitors_r1); - ("init", _visitors_r2); - ("globals", _visitors_r3); - ("type_defs", _visitors_r4); - ] - - method visit_closure : _ -> closure -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_var env _visitors_this.captures - in - let _visitors_r1 = - self#visit_closure_address env _visitors_this.address - in - let _visitors_r2 = self#visit_tid env _visitors_this.tid in - self#visit_record env - [ - ("captures", _visitors_r0); - ("address", _visitors_r1); - ("tid", _visitors_r2); - ] - - method visit_aggregate : _ -> aggregate -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_aggregate_kind env _visitors_this.kind - in - let _visitors_r1 = self#visit_tid env _visitors_this.tid in - let _visitors_r2 = - self#visit_list self#visit_value env _visitors_this.fields - in - self#visit_record env - [ - ("kind", _visitors_r0); - ("tid", _visitors_r1); - ("fields", _visitors_r2); - ] - - method visit_Dynamic : _ -> var -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - self#visit_inline_tuple env "Dynamic" [ _visitors_r0 ] - - method visit_StaticFn : _ -> address -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_address env _visitors_c0 in - self#visit_inline_tuple env "StaticFn" [ _visitors_r0 ] - - method visit_Object : _ -> var -> int -> ltype -> S.t = - fun env _visitors_fobj _visitors_fmethod_index _visitors_fmethod_ty -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_int env _visitors_fmethod_index in - let _visitors_r2 = self#visit_ltype env _visitors_fmethod_ty in - self#visit_inline_record env "Object" - [ - ("obj", _visitors_r0); - ("method_index", _visitors_r1); - ("method_ty", _visitors_r2); - ] - - method visit_target : _ -> target -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Dynamic _visitors_c0 -> self#visit_Dynamic env _visitors_c0 - | StaticFn _visitors_c0 -> self#visit_StaticFn env _visitors_c0 - | Object - { - obj = _visitors_fobj; - method_index = _visitors_fmethod_index; - method_ty = _visitors_fmethod_ty; - } -> - self#visit_Object env _visitors_fobj _visitors_fmethod_index - _visitors_fmethod_ty - - method visit_FixedArray_copy : _ -> _ -> _ -> S.t = - fun env _visitors_fsrc_tid _visitors_fdst_tid -> - let _visitors_r0 = self#visit_tid env _visitors_fsrc_tid in - let _visitors_r1 = self#visit_tid env _visitors_fdst_tid in - self#visit_inline_record env "FixedArray_copy" - [ ("src_tid", _visitors_r0); ("dst_tid", _visitors_r1) ] - - method visit_FixedArray_fill : _ -> _ -> S.t = - fun env _visitors_ftid -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - self#visit_inline_record env "FixedArray_fill" - [ ("tid", _visitors_r0) ] - - method visit_intrinsic : _ -> intrinsic -> S.t = - fun env _visitors_this -> - match _visitors_this with - | FixedArray_copy - { src_tid = _visitors_fsrc_tid; dst_tid = _visitors_fdst_tid } -> - self#visit_FixedArray_copy env _visitors_fsrc_tid - _visitors_fdst_tid - | FixedArray_fill { tid = _visitors_ftid } -> - self#visit_FixedArray_fill env _visitors_ftid - - method visit_Vvar : _ -> var -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - self#visit_inline_tuple env "Vvar" [ _visitors_r0 ] - - method visit_Vconst : _ -> constant -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - self#visit_inline_tuple env "Vconst" [ _visitors_r0 ] - - method visit_value : _ -> value -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Vvar _visitors_c0 -> self#visit_Vvar env _visitors_c0 - | Vconst _visitors_c0 -> self#visit_Vconst env _visitors_c0 - - method visit_Levent : _ -> lambda -> location -> S.t = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Levent" - [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Lallocate : _ -> aggregate -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_aggregate env _visitors_c0 in - self#visit_inline_tuple env "Lallocate" [ _visitors_r0 ] - - method visit_Lclosure : _ -> closure -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_closure env _visitors_c0 in - self#visit_inline_tuple env "Lclosure" [ _visitors_r0 ] - - method visit_Lget_field : _ -> var -> _ -> int -> aggregate_kind -> S.t = - fun env _visitors_fobj _visitors_ftid _visitors_findex _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_tid env _visitors_ftid in - let _visitors_r2 = self#visit_int env _visitors_findex in - let _visitors_r3 = self#visit_aggregate_kind env _visitors_fkind in - self#visit_inline_record env "Lget_field" - [ - ("obj", _visitors_r0); - ("tid", _visitors_r1); - ("index", _visitors_r2); - ("kind", _visitors_r3); - ] - - method visit_Lclosure_field : _ -> var -> _ -> int -> S.t = - fun env _visitors_fobj _visitors_ftid _visitors_findex -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_tid env _visitors_ftid in - let _visitors_r2 = self#visit_int env _visitors_findex in - self#visit_inline_record env "Lclosure_field" - [ - ("obj", _visitors_r0); - ("tid", _visitors_r1); - ("index", _visitors_r2); - ] - - method visit_Lset_field - : _ -> var -> value -> _ -> int -> aggregate_kind -> S.t = - fun env _visitors_fobj _visitors_ffield _visitors_ftid _visitors_findex - _visitors_fkind -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = self#visit_value env _visitors_ffield in - let _visitors_r2 = self#visit_tid env _visitors_ftid in - let _visitors_r3 = self#visit_int env _visitors_findex in - let _visitors_r4 = self#visit_aggregate_kind env _visitors_fkind in - self#visit_inline_record env "Lset_field" - [ - ("obj", _visitors_r0); - ("field", _visitors_r1); - ("tid", _visitors_r2); - ("index", _visitors_r3); - ("kind", _visitors_r4); - ] - - method visit_Lmake_array : _ -> _ -> _ -> value list -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_felems -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_make_array_kind env _visitors_fkind in - let _visitors_r2 = - self#visit_list self#visit_value env _visitors_felems - in - self#visit_inline_record env "Lmake_array" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("elems", _visitors_r2); - ] - - method visit_Larray_get_item : _ -> _ -> _ -> value -> value -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_array_get_kind env _visitors_fkind in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - self#visit_inline_record env "Larray_get_item" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("arr", _visitors_r2); - ("index", _visitors_r3); - ] - - method visit_Larray_set_item - : _ -> _ -> _ -> value -> value -> value option -> S.t = - fun env _visitors_ftid _visitors_fkind _visitors_farr _visitors_findex - _visitors_fitem -> - let _visitors_r0 = self#visit_tid env _visitors_ftid in - let _visitors_r1 = self#visit_array_set_kind env _visitors_fkind in - let _visitors_r2 = self#visit_value env _visitors_farr in - let _visitors_r3 = self#visit_value env _visitors_findex in - let _visitors_r4 = - self#visit_option self#visit_value env _visitors_fitem - in - self#visit_inline_record env "Larray_set_item" - [ - ("tid", _visitors_r0); - ("kind", _visitors_r1); - ("arr", _visitors_r2); - ("index", _visitors_r3); - ("item", _visitors_r4); - ] - - method visit_Lapply : _ -> target -> intrinsic option -> value list -> S.t - = - fun env _visitors_ffn _visitors_fprim _visitors_fargs -> - let _visitors_r0 = self#visit_target env _visitors_ffn in - let _visitors_r1 = - self#visit_option self#visit_intrinsic env _visitors_fprim - in - let _visitors_r2 = - self#visit_list self#visit_value env _visitors_fargs - in - self#visit_inline_record env "Lapply" - [ - ("fn", _visitors_r0); - ("prim", _visitors_r1); - ("args", _visitors_r2); - ] - - method visit_Lstub_call - : _ -> func_stubs -> value list -> ltype list -> ltype option -> S.t = - fun env _visitors_ffn _visitors_fargs _visitors_fparams_ty - _visitors_freturn_ty -> - let _visitors_r0 = self#visit_func_stubs env _visitors_ffn in - let _visitors_r1 = - self#visit_list self#visit_value env _visitors_fargs - in - let _visitors_r2 = - self#visit_list self#visit_ltype env _visitors_fparams_ty - in - let _visitors_r3 = - self#visit_option self#visit_ltype env _visitors_freturn_ty - in - self#visit_inline_record env "Lstub_call" - [ - ("fn", _visitors_r0); - ("args", _visitors_r1); - ("params_ty", _visitors_r2); - ("return_ty", _visitors_r3); - ] - - method visit_Lconst : _ -> constant -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - self#visit_inline_tuple env "Lconst" [ _visitors_r0 ] - - method visit_Lloop - : _ -> - binder list -> - lambda -> - value list -> - label -> - Ltype.return_type -> - S.t = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_ftype_ -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_fparams - in - let _visitors_r1 = self#visit_lambda env _visitors_fbody in - let _visitors_r2 = - self#visit_list self#visit_value env _visitors_fargs - in - let _visitors_r3 = self#visit_label env _visitors_flabel in - let _visitors_r4 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lloop" - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("args", _visitors_r2); - ("label", _visitors_r3); - ("type_", _visitors_r4); - ] - - method visit_Lif - : _ -> lambda -> lambda -> lambda -> Ltype.return_type -> S.t = - fun env _visitors_fpred _visitors_fifso _visitors_fifnot - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fpred in - let _visitors_r1 = self#visit_lambda env _visitors_fifso in - let _visitors_r2 = self#visit_lambda env _visitors_fifnot in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lif" - [ - ("pred", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Llet : _ -> binder -> lambda -> lambda -> S.t = - fun env _visitors_fname _visitors_fe _visitors_fbody -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - self#visit_inline_record env "Llet" - [ - ("name", _visitors_r0); ("e", _visitors_r1); ("body", _visitors_r2); - ] - - method visit_Lletrec : _ -> binder list -> closure list -> lambda -> S.t = - fun env _visitors_fnames _visitors_ffns _visitors_fbody -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_fnames - in - let _visitors_r1 = - self#visit_list self#visit_closure env _visitors_ffns - in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - self#visit_inline_record env "Lletrec" - [ - ("names", _visitors_r0); - ("fns", _visitors_r1); - ("body", _visitors_r2); - ] - - method visit_Llet_multi : _ -> binder list -> lambda -> lambda -> S.t = - fun env _visitors_fnames _visitors_fe _visitors_fbody -> - let _visitors_r0 = - self#visit_list self#visit_binder env _visitors_fnames - in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - let _visitors_r2 = self#visit_lambda env _visitors_fbody in - self#visit_inline_record env "Llet_multi" - [ - ("names", _visitors_r0); - ("e", _visitors_r1); - ("body", _visitors_r2); - ] - - method visit_Lprim : _ -> prim -> value list -> S.t = - fun env _visitors_ffn _visitors_fargs -> - let _visitors_r0 = self#visit_prim env _visitors_ffn in - let _visitors_r1 = - self#visit_list self#visit_value env _visitors_fargs - in - self#visit_inline_record env "Lprim" - [ ("fn", _visitors_r0); ("args", _visitors_r1) ] - - method visit_Lsequence : _ -> lambda -> lambda -> ltype -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fexpr1_type_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr1 in - let _visitors_r1 = self#visit_lambda env _visitors_fexpr2 in - let _visitors_r2 = self#visit_ltype env _visitors_fexpr1_type_ in - self#visit_inline_record env "Lsequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("expr1_type_", _visitors_r2); - ] - - method visit_Ljoinlet - : _ -> - join -> - binder list -> - lambda -> - lambda -> - join_kind -> - Ltype.return_type -> - S.t = - fun env _visitors_fname _visitors_fparams _visitors_fe _visitors_fbody - _visitors_fkind _visitors_ftype_ -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - self#visit_list self#visit_binder env _visitors_fparams - in - let _visitors_r2 = self#visit_lambda env _visitors_fe in - let _visitors_r3 = self#visit_lambda env _visitors_fbody in - let _visitors_r4 = self#visit_join_kind env _visitors_fkind in - let _visitors_r5 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Ljoinlet" - [ - ("name", _visitors_r0); - ("params", _visitors_r1); - ("e", _visitors_r2); - ("body", _visitors_r3); - ("kind", _visitors_r4); - ("type_", _visitors_r5); - ] - - method visit_Ljoinapply : _ -> join -> value list -> S.t = - fun env _visitors_fname _visitors_fargs -> - let _visitors_r0 = self#visit_join env _visitors_fname in - let _visitors_r1 = - self#visit_list self#visit_value env _visitors_fargs - in - self#visit_inline_record env "Ljoinapply" - [ ("name", _visitors_r0); ("args", _visitors_r1) ] - - method visit_Lbreak : _ -> value option -> label -> S.t = - fun env _visitors_farg _visitors_flabel -> - let _visitors_r0 = - self#visit_option self#visit_value env _visitors_farg - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - self#visit_inline_record env "Lbreak" - [ ("arg", _visitors_r0); ("label", _visitors_r1) ] - - method visit_Lcontinue : _ -> value list -> label -> S.t = - fun env _visitors_fargs _visitors_flabel -> - let _visitors_r0 = - self#visit_list self#visit_value env _visitors_fargs - in - let _visitors_r1 = self#visit_label env _visitors_flabel in - self#visit_inline_record env "Lcontinue" - [ ("args", _visitors_r0); ("label", _visitors_r1) ] - - method visit_Lreturn : _ -> lambda -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_lambda env _visitors_c0 in - self#visit_inline_tuple env "Lreturn" [ _visitors_r0 ] - - method visit_Lswitch - : _ -> - var -> - (constr_tag * lambda) list -> - lambda -> - Ltype.return_type -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lswitch" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Lswitchint - : _ -> - var -> - (int * lambda) list -> - lambda -> - Ltype.return_type -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_int env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lswitchint" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Lswitchstring - : _ -> - var -> - (string * lambda) list -> - lambda -> - Ltype.return_type -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_ftype_ -> - let _visitors_r0 = self#visit_var env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_string env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_lambda env _visitors_fdefault in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lswitchstring" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_Lvar : _ -> var -> S.t = - fun env _visitors_fvar -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - self#visit_inline_record env "Lvar" [ ("var", _visitors_r0) ] - - method visit_Lassign : _ -> var -> lambda -> S.t = - fun env _visitors_fvar _visitors_fe -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_lambda env _visitors_fe in - self#visit_inline_record env "Lassign" - [ ("var", _visitors_r0); ("e", _visitors_r1) ] - - method visit_Lcatch : _ -> lambda -> lambda -> ltype -> S.t = - fun env _visitors_fbody _visitors_fon_exception _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fbody in - let _visitors_r1 = self#visit_lambda env _visitors_fon_exception in - let _visitors_r2 = self#visit_ltype env _visitors_ftype_ in - self#visit_inline_record env "Lcatch" - [ - ("body", _visitors_r0); - ("on_exception", _visitors_r1); - ("type_", _visitors_r2); - ] - - method visit_Lcast : _ -> lambda -> ltype -> S.t = - fun env _visitors_fexpr _visitors_ftarget_type -> - let _visitors_r0 = self#visit_lambda env _visitors_fexpr in - let _visitors_r1 = self#visit_ltype env _visitors_ftarget_type in - self#visit_inline_record env "Lcast" - [ ("expr", _visitors_r0); ("target_type", _visitors_r1) ] - - method visit_Lmake_multi_result - : _ -> value -> constr_tag -> Ltype.return_type -> S.t = - fun env _visitors_fvalue _visitors_ftag _visitors_ftype_ -> - let _visitors_r0 = self#visit_value env _visitors_fvalue in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lmake_multi_result" - [ - ("value", _visitors_r0); - ("tag", _visitors_r1); - ("type_", _visitors_r2); - ] - - method visit_Lhandle_error - : _ -> - lambda -> - binder * lambda -> - binder * lambda -> - Ltype.return_type -> - S.t = - fun env _visitors_fobj _visitors_fok_branch _visitors_ferr_branch - _visitors_ftype_ -> - let _visitors_r0 = self#visit_lambda env _visitors_fobj in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - _visitors_fok_branch - in - let _visitors_r2 = - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_lambda env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - _visitors_ferr_branch - in - let _visitors_r3 = self#visit_return_type env _visitors_ftype_ in - self#visit_inline_record env "Lhandle_error" - [ - ("obj", _visitors_r0); - ("ok_branch", _visitors_r1); - ("err_branch", _visitors_r2); - ("type_", _visitors_r3); - ] - - method visit_lambda : _ -> lambda -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Levent { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Levent env _visitors_fexpr _visitors_floc_ - | Lallocate _visitors_c0 -> self#visit_Lallocate env _visitors_c0 - | Lclosure _visitors_c0 -> self#visit_Lclosure env _visitors_c0 - | Lget_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lget_field env _visitors_fobj _visitors_ftid - _visitors_findex _visitors_fkind - | Lclosure_field - { - obj = _visitors_fobj; - tid = _visitors_ftid; - index = _visitors_findex; - } -> - self#visit_Lclosure_field env _visitors_fobj _visitors_ftid - _visitors_findex - | Lset_field - { - obj = _visitors_fobj; - field = _visitors_ffield; - tid = _visitors_ftid; - index = _visitors_findex; - kind = _visitors_fkind; - } -> - self#visit_Lset_field env _visitors_fobj _visitors_ffield - _visitors_ftid _visitors_findex _visitors_fkind - | Lmake_array - { - tid = _visitors_ftid; - kind = _visitors_fkind; - elems = _visitors_felems; - } -> - self#visit_Lmake_array env _visitors_ftid _visitors_fkind - _visitors_felems - | Larray_get_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - } -> - self#visit_Larray_get_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex - | Larray_set_item - { - tid = _visitors_ftid; - kind = _visitors_fkind; - arr = _visitors_farr; - index = _visitors_findex; - item = _visitors_fitem; - } -> - self#visit_Larray_set_item env _visitors_ftid _visitors_fkind - _visitors_farr _visitors_findex _visitors_fitem - | Lapply - { - fn = _visitors_ffn; - prim = _visitors_fprim; - args = _visitors_fargs; - } -> - self#visit_Lapply env _visitors_ffn _visitors_fprim - _visitors_fargs - | Lstub_call - { - fn = _visitors_ffn; - args = _visitors_fargs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - } -> - self#visit_Lstub_call env _visitors_ffn _visitors_fargs - _visitors_fparams_ty _visitors_freturn_ty - | Lconst _visitors_c0 -> self#visit_Lconst env _visitors_c0 - | Lloop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - type_ = _visitors_ftype_; - } -> - self#visit_Lloop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_ftype_ - | Lif - { - pred = _visitors_fpred; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - type_ = _visitors_ftype_; - } -> - self#visit_Lif env _visitors_fpred _visitors_fifso - _visitors_fifnot _visitors_ftype_ - | Llet - { - name = _visitors_fname; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet env _visitors_fname _visitors_fe _visitors_fbody - | Lletrec - { - names = _visitors_fnames; - fns = _visitors_ffns; - body = _visitors_fbody; - } -> - self#visit_Lletrec env _visitors_fnames _visitors_ffns - _visitors_fbody - | Llet_multi - { - names = _visitors_fnames; - e = _visitors_fe; - body = _visitors_fbody; - } -> - self#visit_Llet_multi env _visitors_fnames _visitors_fe - _visitors_fbody - | Lprim { fn = _visitors_ffn; args = _visitors_fargs } -> - self#visit_Lprim env _visitors_ffn _visitors_fargs - | Lsequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - expr1_type_ = _visitors_fexpr1_type_; - } -> - self#visit_Lsequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fexpr1_type_ - | Ljoinlet - { - name = _visitors_fname; - params = _visitors_fparams; - e = _visitors_fe; - body = _visitors_fbody; - kind = _visitors_fkind; - type_ = _visitors_ftype_; - } -> - self#visit_Ljoinlet env _visitors_fname _visitors_fparams - _visitors_fe _visitors_fbody _visitors_fkind _visitors_ftype_ - | Ljoinapply { name = _visitors_fname; args = _visitors_fargs } -> - self#visit_Ljoinapply env _visitors_fname _visitors_fargs - | Lbreak { arg = _visitors_farg; label = _visitors_flabel } -> - self#visit_Lbreak env _visitors_farg _visitors_flabel - | Lcontinue { args = _visitors_fargs; label = _visitors_flabel } -> - self#visit_Lcontinue env _visitors_fargs _visitors_flabel - | Lreturn _visitors_c0 -> self#visit_Lreturn env _visitors_c0 - | Lswitch - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitch env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchint - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchint env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lswitchstring - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - type_ = _visitors_ftype_; - } -> - self#visit_Lswitchstring env _visitors_fobj _visitors_fcases - _visitors_fdefault _visitors_ftype_ - | Lvar { var = _visitors_fvar } -> self#visit_Lvar env _visitors_fvar - | Lassign { var = _visitors_fvar; e = _visitors_fe } -> - self#visit_Lassign env _visitors_fvar _visitors_fe - | Lcatch - { - body = _visitors_fbody; - on_exception = _visitors_fon_exception; - type_ = _visitors_ftype_; - } -> - self#visit_Lcatch env _visitors_fbody _visitors_fon_exception - _visitors_ftype_ - | Lcast - { expr = _visitors_fexpr; target_type = _visitors_ftarget_type } - -> - self#visit_Lcast env _visitors_fexpr _visitors_ftarget_type - | Lmake_multi_result - { - value = _visitors_fvalue; - tag = _visitors_ftag; - type_ = _visitors_ftype_; - } -> - self#visit_Lmake_multi_result env _visitors_fvalue _visitors_ftag - _visitors_ftype_ - | Lhandle_error - { - obj = _visitors_fobj; - ok_branch = _visitors_fok_branch; - err_branch = _visitors_ferr_branch; - type_ = _visitors_ftype_; - } -> - self#visit_Lhandle_error env _visitors_fobj _visitors_fok_branch - _visitors_ferr_branch _visitors_ftype_ - end - - [@@@VISITORS.END] -end - -include struct - let _ = fun (_ : fn) -> () - let _ = fun (_ : top_func_item) -> () - let _ = fun (_ : prog) -> () - let _ = fun (_ : closure) -> () - let _ = fun (_ : aggregate) -> () - let _ = fun (_ : target) -> () - let _ = fun (_ : intrinsic) -> () - let _ = fun (_ : value) -> () - let _ = fun (_ : lambda) -> () -end - -let sexp = - object (self) - inherit [_] sexp as super - - method! visit_value ctx v = - match v with - | Vvar v -> sexp_of_var v - | Vconst c -> self#visit_constant ctx c - - method! visit_Lconst env c = self#visit_constant env c - - method! visit_inline_record env ctor fields = - let predicate field acc = - match (ctor, field) with - | "Ljoinapply", ("param_names", _) -> acc - | _, ("loc_", _) -> acc - | _, ("continue_block", S.List []) -> acc - | _, ("type_", S.List (t :: [])) -> ("type_", t) :: acc - | _ -> field :: acc - in - super#visit_inline_record env ctor - (Basic_lst.fold_right fields [] predicate) - - method! visit_Levent (_ : 'a) e loc_ : S.t = - if !Basic_config.show_loc then - let e = self#visit_lambda () e in - let loc_ = self#visit_location () loc_ in - (List - (List.cons - (Atom "Levent" : S.t) - (List.cons (e : S.t) ([ loc_ ] : S.t list))) - : S.t) - else self#visit_lambda () e - - method! visit_Lprim env prim args = - let args = Basic_lst.map args (fun x -> self#visit_value env x) in - (List (List.cons (sexp_of_prim prim : S.t) (args : S.t list)) : S.t) - - method! visit_Lvar _ v = sexp_of_var v - - method! visit_Lapply env fn prim args = - let fn = self#visit_target () fn in - let args = Basic_lst.map args (fun x -> self#visit_value () x) in - match prim with - | None -> - (List - (List.cons - (Atom "Lapply" : S.t) - (List.cons (fn : S.t) ([ List (args : S.t list) ] : S.t list))) - : S.t) - | Some p -> - let prim = self#visit_intrinsic env p in - (List - (List.cons - (Atom "Lapply" : S.t) - (List.cons - (fn : S.t) - (List.cons - (prim : S.t) - ([ List (args : S.t list) ] : S.t list)))) - : S.t) - - method! visit_Llet env name e body = - let rec aux lam r = - match lam with - | Levent { expr; loc_ = _ } when not !Basic_config.show_loc -> - aux expr r - | Llet { name; e; body } -> aux body ((name, e) :: r) - | _ -> - let cont = self#visit_lambda env lam in - let r = - List.fold_left - (fun acc (name, e) -> - let e = self#visit_lambda env e in - (List - (List.cons (sexp_of_binder name : S.t) ([ e ] : S.t list)) - : S.t) - :: acc) - [] r - in - (List - (List.cons - (Atom "Llet" : S.t) - (List.cons (List (r : S.t list) : S.t) ([ cont ] : S.t list))) - : S.t) - in - aux body [ (name, e) ] - - method! visit_Lsequence env expr1 expr2 _ = - let rec aux lam r = - match lam with - | Levent { expr; loc_ = _ } when not !Basic_config.show_loc -> - aux expr r - | Lsequence { expr1; expr2 } -> aux expr2 (expr1 :: r) - | _ -> - let cont = self#visit_lambda env lam in - let r = - List.fold_left - (fun acc a -> self#visit_lambda env a :: acc) - [ cont ] r - in - (List (List.cons (Atom "Lsequence" : S.t) (r : S.t list)) : S.t) - in - aux expr2 [ expr1 ] - - method! visit_Ljoinlet env name params e body kind _type_ = - let name = Join.sexp_of_t name in - let params = - (fun x__006_ -> Moon_sexp_conv.sexp_of_list sexp_of_var x__006_) params - in - let e = self#visit_lambda env e in - let body = self#visit_lambda env body in - match kind with - | Tail_join -> - (List - (List.cons - (Atom "Ljoinlet" : S.t) - (List.cons - (name : S.t) - (List.cons - (params : S.t) - (List.cons (e : S.t) ([ body ] : S.t list))))) - : S.t) - | Nontail_join -> - (List - (List.cons - (Atom "Ljoinlet_nontail" : S.t) - (List.cons - (name : S.t) - (List.cons - (params : S.t) - (List.cons (e : S.t) ([ body ] : S.t list))))) - : S.t) - - method! visit_Lbreak env arg label = - let label = Label.sexp_of_t label in - match arg with - | None -> - (List (List.cons (Atom "Lbreak" : S.t) ([ label ] : S.t list)) : S.t) - | Some arg -> - let arg = self#visit_value env arg in - (List - (List.cons - (Atom "Lbreak" : S.t) - (List.cons (label : S.t) ([ arg ] : S.t list))) - : S.t) - - method! visit_Lcontinue env args label = - let label = Label.sexp_of_t label in - let args = Basic_lst.map args (fun x -> self#visit_value env x) in - (List - (List.cons - (Atom "Lcontinue" : S.t) - (List.cons (label : S.t) (args : S.t list))) - : S.t) - - method! visit_fn env fn = - let params = Lst.map fn.params (fun p -> self#visit_binder env p) in - let body = self#visit_lambda env fn.body in - let return_type_ = - match fn.return_type_ with - | Ret_single t -> self#visit_ltype env t - | ret -> self#visit_return_type env ret - in - (List - (List.cons - (List - (List.cons - (Atom "params" : S.t) - ([ List (params : S.t list) ] : S.t list)) - : S.t) - (List.cons - (List (List.cons (Atom "body" : S.t) ([ body ] : S.t list)) - : S.t) - ([ - List - (List.cons - (Atom "return_type_" : S.t) - ([ return_type_ ] : S.t list)); - ] - : S.t list))) - : S.t) - end - -let sexp_of_prog prog = sexp#visit_prog () prog - -let event ~(loc_ : location) (expr : lambda) = - if (not !Basic_config.debug) || Basic_prelude.phys_equal loc_ Loc.no_location - then expr - else Levent { loc_; expr } diff --git a/src/clam1_ident.ml b/src/clam1_ident.ml index 27fdc65..5926e89 100644 --- a/src/clam1_ident.ml +++ b/src/clam1_ident.ml @@ -39,35 +39,36 @@ module Key = struct let _ = fun (_ : t) -> () let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Pdot _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = hsv in - Qual_ident.hash_fold_t hsv _ir.qual_name - in - hsv - | Pident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - hsv - in - hsv - | Pmutable_ident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - hsv - in - hsv + (fun hsv -> + fun arg -> + match arg with + | Pdot _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Qual_ident.hash_fold_t hsv _ir.qual_name + in + hsv + | Pident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + hsv + in + hsv + | Pmutable_ident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + hsv + in + hsv : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -112,31 +113,34 @@ module Key = struct | Pmutable_ident { name; stamp; ty = _ } -> name ^ "!" ^ string_of_int stamp | Pdot q -> Qual_ident.string_of_t q.qual_name - let sexp_of_t (x : t) : S.t = - let ty = - match x with - | Pdot { ty; _ } | Pident { ty; _ } | Pmutable_ident { ty; _ } -> - Ltype.sexp_of_t ty - in - List [ Atom (to_string x); Atom ":"; ty ] + let sexp_of_t (x : t) = + (let ty = + match x with + | Pdot { ty; _ } | Pident { ty; _ } | Pmutable_ident { ty; _ } -> + Ltype.sexp_of_t ty + in + List [ Atom (to_string x); Atom ":"; ty ] + : S.t) end include Key -let of_qual_ident (qual_name : Qual_ident.t) ~ty : t = Pdot { qual_name; ty } +let of_qual_ident (qual_name : Qual_ident.t) ~ty = (Pdot { qual_name; ty } : t) -let of_core_ident (x : Core_ident.t) ~ty : t = - match x with - | Pdot qual_name -> Pdot { qual_name; ty } - | Plocal_method _ -> assert false - | Pident { stamp; name } -> Pident { stamp; name; ty } - | Pmutable_ident { stamp; name } -> Pmutable_ident { stamp; name; ty } +let of_core_ident (x : Core_ident.t) ~ty = + (match x with + | Pdot qual_name -> Pdot { qual_name; ty } + | Plocal_method _ -> assert false + | Pident { stamp; name } -> Pident { stamp; name; ty } + | Pmutable_ident { stamp; name } -> Pmutable_ident { stamp; name; ty } + : t) let to_wasm_name (x : t) = match x with | Pident { name; stamp; ty = _ } | Pmutable_ident { name; stamp; ty = _ } -> let name = Strutil.mangle_wasm_name name in - Stdlib.String.concat "" [ "$"; name; "/"; Int.to_string stamp ] + (Stdlib.String.concat "" + [ "$"; name; "/"; Int.to_string stamp ] [@merlin.hide]) | Pdot { qual_name; ty = _ } -> Qual_ident.to_wasm_name qual_name let fresh name ~ty = Pident { name; stamp = Uuid.next (); ty } @@ -176,33 +180,35 @@ module Map = struct let bal = Map_gen.bal let height = Map_gen.height - let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - - let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) + let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + + let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -238,77 +244,79 @@ module Map = struct let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x - let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) + let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } - let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - - let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) + let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + + let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -319,10 +327,12 @@ module Map = struct (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty - let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) + + let of_array xs = + Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) end module Set = struct @@ -366,111 +376,134 @@ module Set = struct let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] - let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> - No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> - No { result with l = Set_gen.internal_join l v result.l }) - - let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - - let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - - let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - - let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - - let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) + let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + + let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + + let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + + let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + + let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + + let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + + let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -488,8 +521,8 @@ module Set = struct Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t - let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params + let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) @@ -531,6 +564,7 @@ module Hash = struct let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array + let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -543,26 +577,28 @@ module Hash = struct if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -602,22 +638,24 @@ module Hash = struct Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) - let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) + let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -626,6 +664,7 @@ module Hash = struct | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -656,13 +695,13 @@ module Hash = struct let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -670,7 +709,7 @@ module Hash = struct let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = @@ -727,29 +766,31 @@ module Hashset = struct done; tbl - let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - - let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then - Hashset_gen.resize key_index h; - key + let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + + let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/clam1_of_core.ml b/src/clam1_of_core.ml deleted file mode 100644 index 0ee0ca1..0000000 --- a/src/clam1_of_core.ml +++ /dev/null @@ -1,1356 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Ident = Clam1_ident -module Fn_address = Basic_fn_address -module Tid = Basic_ty_ident -module Ident_hashset = Basic_core_ident.Hashset -module Lst = Basic_lst -module Core_ident = Basic_core_ident -module Qual_ident = Basic_qual_ident - -type binds = Clam1.top_func_item list - -let base = ref Loc.no_location -let binds_init : binds ref = ref [] -let new_top (x : Clam1.top_func_item) = binds_init := x :: !binds_init -let clam_unit : Clam1.lambda = Lconst (C_int { v = 0l; repr = None }) -let local_non_well_knowns : Core_ident.Hashset.t = Core_ident.Hashset.create 17 - -let fix_var = - object - inherit [_] Clam1.map - - method! visit_var (self, replace) var = - if Ident.equal var self then replace else var - end - -let fix_single_var ~self ~replace body = - fix_var#visit_lambda (self, replace) body - -let transl_params ~mtype_defs ~type_defs (params : Mcore.param list) : - Ident.t list = - Lst.map params (fun { binder; ty } -> - Ident.of_core_ident binder - ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty)) - -let transl_ident (id : Core_ident.t) ~(addr_tbl : Addr_table.t) ~mtype_defs - ~type_defs mty : Ident.t = - match Addr_table.find_opt addr_tbl id with - | Some (Toplevel { name_as_closure = Some id; _ }) -> id - | Some (Toplevel fn_info) -> ( - let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in - match[@warning "-fragile-match"] id with - | Pdot qual_name -> - let id = - Ident.of_qual_ident ~ty - (Qual_ident.map qual_name ~f:(fun name : Stdlib.String.t -> - name ^ ".clo")) - in - fn_info.name_as_closure <- Some id; - id - | _ -> assert false) - | Some (Local (_addr, ty)) -> Ident.of_core_ident ~ty id - | None -> - let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in - Ident.of_core_ident ~ty id - -let rec transl_expr ~name_hint ~mtype_defs ~addr_tbl ~type_defs ~object_methods - (x : Mcore.expr) : Clam1.lambda = - let transl_type mtype = - Transl_mtype.mtype_to_ltype mtype ~type_defs ~mtype_defs - [@@inline] - in - let transl_type_as_named_exn mtype = - match transl_type mtype with - | Ref_lazy_init { tid } | Ltype.Ref { tid } | Ref_nullable { tid } -> tid - | Ref_bytes -> Ltype.tid_bytes - | _ -> assert false - [@@inline] - in - let transl_constr_type tag mtype = - Transl_mtype.constr_to_ltype ~tag mtype - [@@inline] - in - let go x = - transl_expr ~name_hint ~mtype_defs ~addr_tbl ~type_defs ~object_methods x - [@@inline] - in - let bind (rhs : Mcore.expr) cont : Clam1.lambda = - match rhs with - | Cexpr_var { id; ty; _ } -> - let ty = transl_type ty in - cont (Ident.of_core_ident ~ty id) - | _ -> - let ty = transl_type (Mcore.type_of_expr rhs) in - let name = Ident.fresh ~ty "*bind" in - Llet { name; e = go rhs; body = cont name } - [@@inline] - in - let to_value (rhs : Mcore.expr) (cont : Clam1.value -> _) : Clam1.lambda = - match rhs with - | Cexpr_var { id = (Pident _ | Pdot _ | Plocal_method _) as id; ty; _ } -> - cont (Vvar (transl_ident ~addr_tbl ~mtype_defs ~type_defs id ty)) - | Cexpr_const { c; _ } -> cont (Vconst c) - | _ -> - let name_hint = - match rhs with - | Cexpr_constr { constr; _ } -> constr.constr_name.name - | Cexpr_tuple _ -> "tuple" - | Cexpr_field { accessor = Label { label_name }; _ } -> label_name - | _ -> "tmp" - in - let ty = transl_type (Mcore.type_of_expr rhs) in - let name = Ident.fresh name_hint ~ty in - Llet { name; e = go rhs; body = cont (Vvar name) } - [@@inline] - in - let rec expr_list_to_value (exprs : Mcore.expr list) - (cont : Clam1.value list -> _) = - match exprs with - | [] -> cont [] - | expr :: exprs -> - to_value expr (fun value -> - expr_list_to_value exprs (fun values -> cont (value :: values))) - in - let append_name_hint new_name : Stdlib.String.t = - name_hint ^ "." ^ Core_ident.base_name new_name - [@@inline] - in - let handle_abstract_closure_type ~(name : Core_ident.t option) (fn : Mcore.fn) - (address : Fn_address.t) : Tid.t = - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body) - in - let sig_ : Ltype.fn_sig = - { params = Lst.map params Ident.get_type; ret = return_type_ } - in - let abs_closure_tid = - match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl sig_ with - | Some tid -> tid - | None -> - let tid = - Name_mangle.make_type_name - (T_func - { - params = Lst.map fn.params (fun p -> p.ty); - return = Mcore.type_of_expr fn.body; - }) - in - Ltype.FnSigHash.add type_defs.fn_sig_tbl sig_ tid; - Tid.Hash.add type_defs.defs tid - (Ltype.Ref_closure_abstract { fn_sig = sig_ }); - tid - in - let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in - (match name with - | Some name -> - Addr_table.add_local_fn_addr_and_type addr_tbl name address - abs_closure_ty - | None -> ()); - abs_closure_tid - in - let expr : Clam1.lambda = - match x with - | Cexpr_const { c; ty = _ } -> Lconst c - | Cexpr_unit _ -> clam_unit - | Cexpr_var { id; ty; prim = _ } -> - let var = transl_ident id ty ~addr_tbl ~mtype_defs ~type_defs in - Lvar { var } - | Cexpr_prim { prim = Psequand; args = [ lhs; rhs ]; ty = _ } -> - Lif - { - pred = go lhs; - ifso = go rhs; - ifnot = Lconst (C_bool false); - type_ = Ret_single I32_Bool; - } - | Cexpr_prim { prim = Psequor; args = [ lhs; rhs ]; ty = _ } -> - Lif - { - pred = go lhs; - ifso = Lconst (C_bool true); - ifnot = go rhs; - type_ = Ret_single I32_Bool; - } - | Cexpr_prim { prim = Pcatch; args = [ body; on_exception ]; ty } -> - Lcatch - { - body = go body; - on_exception = go on_exception; - type_ = transl_type ty; - } - | Cexpr_prim { prim; args; ty } -> ( - let make_prim fn = - expr_list_to_value args (fun args -> Clam1.Lprim { fn; args }) - [@@inline] - in - match prim with - | Parray_make -> - let arr_type = - let tid = Mtype.get_constr_tid_exn ty in - match Mtype.Id_hash.find_opt mtype_defs.defs tid with - | Some (Record { fields = arr_field :: _ }) -> - arr_field.field_type - | _ -> assert false - in - let fixed_array = - Mcore.prim - (Pfixedarray_make { kind = EverySingleElem }) - args ~ty:arr_type - in - let vec_tid = transl_type_as_named_exn ty in - to_value fixed_array (fun fixed_arr_value -> - Lallocate - { - kind = Struct; - tid = vec_tid; - fields = - [ - fixed_arr_value; - Vconst - (C_int - { - v = Int32.of_int (List.length args); - repr = None; - }); - ]; - }) - | Pfixedarray_length -> - let arr_type = Mcore.type_of_expr (List.hd args) in - if arr_type = T_bytes then make_prim Pbyteslength - else make_prim Pfixedarray_length - | Pfixedarray_make { kind } -> - if ty = T_bytes && kind = LenAndInit then make_prim Pmakebytes - else - expr_list_to_value args (fun elems -> - Lmake_array { kind; tid = transl_type_as_named_exn ty; elems }) - | Pfixedarray_get_item { kind } -> - let arr_type = Mcore.type_of_expr (List.hd args) in - if arr_type = T_bytes then make_prim Pgetbytesitem - else - let tid = transl_type_as_named_exn arr_type in - expr_list_to_value args (fun args -> - match[@warning "-fragile-match"] args with - | [ arr; index ] -> Larray_get_item { tid; arr; index; kind } - | _ -> assert false) - | Pfixedarray_set_item { set_kind } -> - let arr_type = Mcore.type_of_expr (List.hd args) in - if arr_type = T_bytes then make_prim Psetbytesitem - else - expr_list_to_value args (fun args -> - let arr, index, item = - match args with - | [ arr; index ] -> (arr, index, None) - | [ arr; index; item ] -> (arr, index, Some item) - | _ -> assert false - in - Larray_set_item - { - arr; - index; - item; - tid = transl_type_as_named_exn arr_type; - kind = set_kind; - }) - | Prefeq -> - let mty = Mcore.type_of_expr (List.hd args) in - let lty = transl_type mty in - make_prim - (match lty with - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char -> - Pcomparison { operator = Eq; operand_type = I32 } - | U32 -> Pcomparison { operator = Eq; operand_type = U32 } - | I64 -> Pcomparison { operator = Eq; operand_type = I64 } - | U64 -> Pcomparison { operator = Eq; operand_type = U64 } - | F32 -> Pcomparison { operator = Eq; operand_type = F32 } - | F64 -> Pcomparison { operator = Eq; operand_type = F64 } - | Ref _ | Ref_lazy_init _ | Ref_nullable _ | Ref_extern - | Ref_string | Ref_bytes | Ref_func | Ref_any -> - Prefeq) - | Pcast _ -> ( - match[@warning "-fragile-match"] args with - | arg :: [] -> Lcast { expr = go arg; target_type = transl_type ty } - | _ -> assert false) - | Penum_field { index; tag } -> - let tid = - Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) - in - expr_list_to_value args (fun args -> - match[@warning "-fragile-match"] args with - | Clam1.Vvar obj :: [] -> - let tag = Tag.of_core_tag mtype_defs.ext_tags tag in - Lget_field { kind = Enum { tag }; obj; index; tid } - | _ -> assert false) - | Pset_enum_field { index; tag } -> - let tid = - Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) - in - expr_list_to_value args (fun args -> - match[@warning "-fragile-match"] args with - | [ Clam1.Vvar obj; field ] -> - let tag = Tag.of_core_tag mtype_defs.ext_tags tag in - Lset_field { kind = Enum { tag }; obj; field; index; tid } - | _ -> assert false) - | Pmake_value_or_error { tag } -> ( - let tag = Tag.of_core_tag_no_ext tag in - match[@warning "-fragile-match"] args with - | arg :: [] -> - to_value arg (fun argv -> - Lmake_multi_result - { - value = argv; - tag; - type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs - ~mtype_defs ty; - }) - | _ -> assert false) - | Pcall_object_method { method_index; _ } -> ( - let method_ty = - transl_type - (T_func - { params = Lst.map args Mcore.type_of_expr; return = ty }) - in - match[@warning "-fragile-match"] args with - | self :: args -> - bind self (fun obj -> - expr_list_to_value args (fun args -> - Lapply - { - fn = Object { obj; method_index; method_ty }; - args; - prim = None; - })) - | _ -> assert false) - | _ -> make_prim prim) - | Cexpr_let { name; rhs; body; ty = _ } -> - let ty_rhs = Mcore.type_of_expr rhs in - let name = Ident.of_core_ident ~ty:(transl_type ty_rhs) name in - Llet { name; e = go rhs; body = go body } - | Cexpr_letfn { name; fn; body; kind; ty } -> ( - match kind with - | Nonrec -> - let name_hint = append_name_hint name in - let address = - Fn_address.fresh (name_hint ^ ".fn" : Stdlib.String.t) - in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~object_methods ~address - ~name_hint ~mtype_defs ~self:None ~abs_closure_tid fn - in - let body = go body in - let name = Ident.of_core_ident name ~ty in - Llet { name; e = Lclosure closure; body } - else - let tuple, binder = - well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~name_hint ~address ~self:name ~is_rec:false - fn - in - let body = go body in - Llet { name = binder; e = tuple; body } - | Rec -> - let name_hint = append_name_hint name in - let address = - Fn_address.fresh (name_hint ^ ".fn" : Stdlib.String.t) - in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~object_methods ~name_hint - ~mtype_defs ~self:(Some name) ~address ~abs_closure_tid fn - in - let body = go body in - let name = Ident.of_core_ident name ~ty in - Llet { name; e = Lclosure closure; body } - else - let tuple, binder = - well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~name_hint ~address ~self:name ~is_rec:true fn - in - let body = go body in - Llet { name = binder; e = tuple; body } - | Tail_join | Nontail_join -> - let name = Join.of_core_ident name in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let join_body = go fn.body in - let body = go body in - let kind : Clam1.join_kind = - match kind with - | Tail_join -> Tail_join - | Nontail_join -> Nontail_join - | _ -> assert false - in - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty - in - Ljoinlet { name; params; e = join_body; body; kind; type_ }) - | Cexpr_function { func; ty = _ } -> - let address = Fn_address.fresh (name_hint ^ ".fn" : Stdlib.String.t) in - let abs_closure_tid = - handle_abstract_closure_type ~name:None func address - in - let closure, _ = - closure_of_fn ~addr_tbl ~type_defs ~mtype_defs ~object_methods - ~name_hint ~address ~self:None ~abs_closure_tid func - in - Lclosure closure - | Cexpr_apply { func; args; kind = Join; ty = _; prim = _ } -> - let name = Join.of_core_ident func in - expr_list_to_value args (fun args -> Ljoinapply { name; args }) - | Cexpr_apply - { func; args = core_args; kind = Normal { func_ty }; ty = _; prim } -> - expr_list_to_value core_args (fun args -> - match Addr_table.find_opt addr_tbl func with - | Some (Toplevel { addr; _ }) -> - let prim : Clam1.intrinsic option = - match prim with - | Some (Pintrinsic FixedArray_copy) -> ( - match core_args with - | dst :: _ :: src :: _ -> - let dst_tid = - transl_type_as_named_exn (Mcore.type_of_expr dst) - in - let src_tid = - transl_type_as_named_exn (Mcore.type_of_expr src) - in - Some (FixedArray_copy { src_tid; dst_tid }) - | _ -> assert false) - | Some (Pintrinsic FixedArray_fill) -> ( - match core_args with - | arr :: _ -> - let arr_tid = - transl_type_as_named_exn (Mcore.type_of_expr arr) - in - Some (FixedArray_fill { tid = arr_tid }) - | _ -> assert false) - | Some - (Pintrinsic - ( Char_to_string | F64_to_string | String_substring - | FixedArray_join | FixedArray_iter | FixedArray_iteri - | FixedArray_map | FixedArray_fold_left | Iter_map - | Iter_iter | Iter_from_array | Iter_take | Iter_reduce - | Iter_flat_map | Iter_repeat | Iter_filter - | Iter_concat | Array_length | Array_get - | Array_unsafe_get | Array_set | Array_unsafe_set )) -> - None - | Some _ -> assert false - | None -> None - in - Lapply { fn = StaticFn addr; args; prim } - | Some (Local (addr, self_ty)) -> - let self = Ident.of_core_ident func ~ty:self_ty in - Lapply - { fn = StaticFn addr; args = Vvar self :: args; prim = None } - | None -> - let fn = Ident.of_core_ident ~ty:(transl_type func_ty) func in - Lapply { fn = Dynamic fn; args; prim = None }) - | Cexpr_object { self; methods_key; ty = _ } -> - let ({ trait; type_ } : Object_util.object_key) = methods_key in - let tid = Tid.concrete_object_type ~trait ~type_name:type_ in - let methods = Object_util.Hash.find_exn object_methods methods_key in - bind self (fun self -> - Lclosure { tid; address = Object methods; captures = [ self ] }) - | Cexpr_letrec { bindings; body; ty = _ } -> - let addresses = - Lst.map bindings (fun (name, fn) -> - let address = - Fn_address.fresh - (append_name_hint name ^ ".fn" : Stdlib.String.t) - in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - (address, Some abs_closure_tid) - else - let ty = Ltype.Ref { tid = Tid.capture_of_function address } in - Addr_table.add_local_fn_addr_and_type addr_tbl name address ty; - (address, None)) - in - let fns, names = - Lst.split_map2 bindings addresses - (fun (name, fn) (address, abs_closure_tid_opt) -> - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = Option.get abs_closure_tid_opt in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~mtype_defs ~object_methods - ~address ~name_hint:(append_name_hint name) - ~self:(Some name) ~abs_closure_tid fn - in - let self = Ident.of_core_ident name ~ty in - (closure, self) - else - well_known_closure_of_mut_rec_fn ~addr_tbl ~type_defs - ~mtype_defs ~object_methods ~address - ~name_hint:(append_name_hint name) ~self:name fn) - in - Lletrec { names; fns; body = go body } - | Cexpr_constr { constr = _; tag; args; ty } -> - let tid = transl_constr_type tag ty in - expr_list_to_value args (fun fields -> - Lallocate { tid; fields; kind = Enum { tag } }) - | Cexpr_tuple { exprs; ty } -> - let tid = transl_type_as_named_exn ty in - expr_list_to_value exprs (fun fields -> - Lallocate { tid; fields; kind = Tuple }) - | Cexpr_record { fields; ty } -> - if fields = [] then clam_unit - else - let args = Lst.map fields (fun { expr; _ } -> expr) in - let tid = transl_type_as_named_exn ty in - expr_list_to_value args (fun fields -> - Lallocate { tid; fields; kind = Struct }) - | Cexpr_record_update { record; fields; fields_num; ty } -> - let t = transl_type_as_named_exn ty in - let ty_fields = - Ltype_util.get_fields t type_defs.defs |> Array.of_list - in - bind record (fun record_id -> - let rec set_new_fields (prev_fields_rev : Clam1.value list) i = - if i >= fields_num then - Clam1.Lallocate - { tid = t; kind = Struct; fields = List.rev prev_fields_rev } - else - match Lst.find_first fields (fun { pos; _ } -> pos = i) with - | Some { expr; _ } -> - to_value expr (fun v -> - set_new_fields (v :: prev_fields_rev) (i + 1)) - | None -> - let ty_field = ty_fields.(i) in - let tmp = - Ident.fresh ("field_" ^ string_of_int i) ~ty:ty_field - in - Llet - { - name = tmp; - e = - Lget_field - { - kind = Struct; - obj = record_id; - tid = t; - index = i; - }; - body = - set_new_fields (Vvar tmp :: prev_fields_rev) (i + 1); - } - in - set_new_fields [] 0) - | Cexpr_field { record; accessor; pos; ty = _ } -> - to_value record (fun obj -> - let t = transl_type_as_named_exn (Mcore.type_of_expr record) in - match[@warning "-fragile-match"] obj with - | Clam1.Vvar obj -> - let kind : Clam1.aggregate_kind = - match accessor with - | Newtype -> assert false - | Label _ -> Struct - | Index _ -> Tuple - in - Lget_field { kind; obj; index = pos; tid = t } - | _ -> assert false) - | Cexpr_mutate { record; label = _; field; pos; ty = _ } -> - let t = transl_type_as_named_exn (Mcore.type_of_expr record) in - to_value record (fun record -> - to_value field (fun field -> - match[@warning "-fragile-match"] record with - | Clam1.Vvar obj -> - Lset_field - { kind = Struct; obj; field; index = pos; tid = t } - | _ -> assert false)) - | Cexpr_array { exprs; ty } -> - expr_list_to_value exprs (fun elems -> - Lmake_array - { - kind = EverySingleElem; - tid = transl_type_as_named_exn ty; - elems; - }) - | Cexpr_assign { var; expr; ty = _ } -> - let var = - Ident.of_core_ident var ~ty:(transl_type (Mcore.type_of_expr expr)) - in - Lassign { var; e = go expr } - | Cexpr_sequence { expr1; expr2; ty = _ } -> - Lsequence - { - expr1 = go expr1; - expr2 = go expr2; - expr1_type_ = transl_type (Mcore.type_of_expr expr1); - } - | Cexpr_if { cond; ifso; ifnot; ty } -> ( - let pred = go cond in - let ifso = go ifso in - match ifnot with - | Some ifnot -> - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty - in - Lif { pred; ifso; ifnot = go ifnot; type_ } - | None -> - Lif { pred; ifso; ifnot = clam_unit; type_ = Ret_single I32_Unit }) - | Cexpr_handle_error { obj; handle_kind; ty } -> - let e = go obj in - let ok_lty, err_lty = - match - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr obj) - with - | Ret_error { ok_ty; err_ty } -> (ok_ty, err_ty) - | Ret_single _ -> assert false - in - let ok_var = Ident.fresh ~ty:ok_lty "*ok" in - let ok_branch : Clam1.lambda = - match handle_kind with - | To_result -> - let tag = Tag.of_core_tag_no_ext Builtin.constr_ok.cs_tag in - let tid = transl_constr_type tag ty in - Lallocate { kind = Enum { tag }; tid; fields = [ Vvar ok_var ] } - | Joinapply _ | Return_err _ -> Lvar { var = ok_var } - in - let err_var = Ident.fresh ~ty:err_lty "*err" in - let err_branch : Clam1.lambda = - match handle_kind with - | To_result -> - let tag = Tag.of_core_tag_no_ext Builtin.constr_err.cs_tag in - let tid = transl_constr_type tag ty in - Lallocate { kind = Enum { tag }; tid; fields = [ Vvar err_var ] } - | Joinapply err_join -> - Ljoinapply - { name = Join.of_core_ident err_join; args = [ Vvar err_var ] } - | Return_err { ok_ty = ctx_ok_ty } -> - let ctx_ok_ty = - Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ctx_ok_ty - in - let tag = Tag.of_core_tag_no_ext Builtin.constr_err.cs_tag in - Lreturn - (Lmake_multi_result - { - value = Vvar err_var; - tag; - type_ = Ret_error { ok_ty = ctx_ok_ty; err_ty = err_lty }; - }) - in - Lhandle_error - { - obj = e; - ok_branch = (ok_var, ok_branch); - err_branch = (err_var, err_branch); - type_ = Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty; - } - | Cexpr_switch_constr { obj; cases; default; ty } -> - let obj_ty = Mcore.type_of_expr obj in - bind obj (fun obj_id -> - let transl_action tag binder body : Clam1.lambda = - match binder with - | None -> go body - | Some binder -> - let constr_tid = transl_constr_type tag obj_ty in - let constr_ty : Ltype.t = Ref { tid = constr_tid } in - Clam1.Llet - { - name = Ident.of_core_ident binder ~ty:constr_ty; - e = - Lcast - { - expr = Lvar { var = obj_id }; - target_type = constr_ty; - }; - body = go body; - } - [@@inline] - in - let cases, default = - Lst.fold_right cases - ([], Option.map go default) - (fun (tag, binder, action) (cases, default) -> - let action = transl_action tag binder action in - match default with - | Some _ -> ((tag, action) :: cases, default) - | None -> (cases, Some action)) - in - match (cases, default) with - | [], Some default -> default - | [], None -> Lprim { fn = Praise; args = [] } - | _ :: _, None -> assert false - | _, Some default -> - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty - in - Lswitch { obj = obj_id; cases; default; type_ }) - | Cexpr_switch_constant { obj; cases; default; ty } -> - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty - in - bind obj (fun obj -> - match cases with - | (C_string _, _) :: _ -> - let cases = - Lst.map cases (fun (c, action) -> - match c with - | C_string s -> (s, go action) - | _ -> assert false) - in - Lswitchstring { obj; cases; default = go default; type_ } - | (C_int _, _) :: _ -> - let cases = - Lst.map cases (fun (c, action) -> - match c with - | C_int { v; repr = _ } -> (Int32.to_int v, go action) - | _ -> assert false) - in - Lswitchint { obj; cases; default = go default; type_ } - | (c, _) :: _ -> - let default = go default in - let equal = - match c with - | C_char _ -> Primitive.equal_char - | C_int _ -> Primitive.equal_int - | C_int64 _ -> Primitive.equal_int64 - | C_uint _ -> Primitive.equal_uint - | C_uint64 _ -> Primitive.equal_uint64 - | C_float _ -> Primitive.equal_float - | C_double _ -> Primitive.equal_float64 - | C_bool _ -> Primitive.equal_bool - | C_bigint _ -> assert false - | C_string _ -> assert false - | C_bytes _ -> assert false - in - Lst.fold_right cases default (fun (c, action) rest -> - let pred : Clam1.lambda = - Lprim { fn = equal; args = [ Vvar obj; Vconst c ] } - in - Lif { pred; ifso = go action; ifnot = rest; type_ }) - | [] -> go default) - | Cexpr_loop { params; body; args; label; ty } -> - let params = transl_params ~mtype_defs ~type_defs params in - let body = go body in - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ty - in - expr_list_to_value args (fun args -> - Lloop { params; body; args; label; type_ }) - | Cexpr_break { arg; label; ty = _ } -> ( - match arg with - | None -> Lbreak { arg = None; label } - | Some arg -> to_value arg (fun arg -> Lbreak { arg = Some arg; label }) - ) - | Cexpr_continue { args; label; ty = _ } -> - expr_list_to_value args (fun args -> Lcontinue { args; label }) - | Cexpr_return { expr; return_kind; ty = _ } -> ( - match return_kind with - | Single_value -> Lreturn (go expr) - | Error_result { is_error; return_ty } -> - let tag = - Tag.of_core_tag_no_ext - (if is_error then Builtin.constr_err.cs_tag - else Builtin.constr_ok.cs_tag) - in - let type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs - return_ty - in - to_value expr (fun value -> - Lreturn (Lmake_multi_result { value; tag; type_ }))) - in - if !Basic_config.debug then - let expr_loc = Mcore.loc_of_expr x in - Clam1.event ~loc_:(Rloc.to_loc ~base:!base expr_loc) expr - else expr - -and closure_of_fn ~mtype_defs ~addr_tbl ~type_defs ~object_methods ~name_hint - ~(address : Fn_address.t) ~(self : Core_ident.t option) - ~(abs_closure_tid : Tid.t) (fn : Mcore.fn) : Clam1.closure * Ltype.t = - let exclude = - match self with - | Some self -> Core_ident.Set.singleton self - | None -> Core_ident.Set.empty - in - let fvs = - Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body) - in - let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in - match (fvs, self) with - | [], None -> - let env_id = Ident.fresh ~ty:abs_closure_ty "*env" in - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let fn : Clam1.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - ( { captures = fvs; address = Normal address; tid = abs_closure_tid }, - abs_closure_ty ) - | _ -> - let closure_cap_tid = Tid.capture_of_function address in - let closure_type_def = - Ltype.Ref_closure - { - fn_sig_tid = abs_closure_tid; - captures = Lst.map fvs Ident.get_type; - } - in - let closure_ty = Ltype.Ref { tid = closure_cap_tid } in - Tid.Hash.add type_defs.defs closure_cap_tid closure_type_def; - let env_id = - match self with - | Some self -> Ident.of_core_ident self ~ty:abs_closure_ty - | None -> Ident.fresh ~ty:abs_closure_ty "*env" - in - let casted_env_id = Ident.fresh ~ty:closure_ty "*casted_env" in - let env = Clam1.Lvar { var = env_id } in - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body_with_captures = - Lst.fold_left_with_offset fvs body 0 (fun fv rest index -> - let rhs = - Clam1.Lclosure_field - { obj = casted_env_id; index; tid = closure_cap_tid } - in - Clam1.Llet { name = fv; e = rhs; body = rest }) - in - let body : Clam1.lambda = - Llet - { - name = casted_env_id; - e = Lcast { expr = env; target_type = closure_ty }; - body = body_with_captures; - } - in - let fn : Clam1.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - ( { captures = fvs; address = Normal address; tid = closure_cap_tid }, - abs_closure_ty ) - -and well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs ~object_methods - ~name_hint ~(address : Fn_address.t) ~(self : Core_ident.t) ~(is_rec : bool) - (fn : Mcore.fn) : Clam1.lambda * Ident.t = - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body) - in - let exclude = - if is_rec then Core_ident.Set.singleton self else Core_ident.Set.empty - in - let fvs = - Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let insert_let_self_for_recursive_case self rhs ty body = - if is_rec then - let self = Ident.of_core_ident ~ty self in - Clam1.Llet { name = self; e = rhs; body } - else body - [@@inline] - in - let update_type_table ty = - Addr_table.add_local_fn_addr_and_type addr_tbl self address ty - [@@inline] - in - match fvs with - | [] -> - let env = Ident.fresh ~ty:I32_Unit "*env" in - Addr_table.add_local_fn_addr_and_type addr_tbl self address I32_Unit; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - insert_let_self_for_recursive_case self clam_unit I32_Unit body - in - let fn : Clam1.fn = { params = env :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - (clam_unit, Ident.of_core_ident ~ty:I32_Unit self) - | fv :: [] -> - let fv_ty = Ident.get_type fv in - let fv_var = Clam1.Lvar { var = fv } in - update_type_table fv_ty; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - if is_rec then - let self = Ident.of_core_ident ~ty:I32_Unit self in - fix_single_var ~self ~replace:fv body - else body - in - let fn : Clam1.fn = { params = fv :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - (fv_var, Ident.of_core_ident self ~ty:fv_ty) - | _ :: _ :: _ -> - let ty_tuple_def = - Ltype.Ref_struct - { fields = Lst.map fvs (fun id -> (Ident.get_type id, false)) } - in - let ty_tuple_tid = Tid.capture_of_function address in - Basic_ty_ident.Hash.add type_defs.defs ty_tuple_tid ty_tuple_def; - let ty_tuple = Ltype.Ref { tid = ty_tuple_tid } in - let env_id = Ident.fresh ~ty:ty_tuple "*env" in - let env = Clam1.Lvar { var = env_id } in - update_type_table ty_tuple; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - Lst.fold_left_with_offset fvs body 0 (fun fv rest i -> - let rhs = - Clam1.Lget_field - { kind = Tuple; obj = env_id; index = i; tid = ty_tuple_tid } - in - Clam1.Llet { name = fv; e = rhs; body = rest }) - in - let body = insert_let_self_for_recursive_case self env ty_tuple body in - let fn : Clam1.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - ( Lallocate - { - tid = ty_tuple_tid; - fields = Lst.map fvs (fun fv -> Clam1.Vvar fv); - kind = Struct; - }, - Ident.of_core_ident ~ty:ty_tuple self ) - -and well_known_closure_of_mut_rec_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~self ~name_hint ~address (fn : Mcore.fn) : - Clam1.closure * Ident.t = - let fvs = - Core_ident.Map.fold - (Mcore_util.free_vars ~exclude:(Core_ident.Set.singleton self) fn) - [] - (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body) - in - let tid = Tid.capture_of_function address in - let closure_type = - Ltype.Ref_late_init_struct { fields = Lst.map fvs Ident.get_type } - in - Tid.Hash.add type_defs.defs tid closure_type; - let name_hint = - (name_hint ^ "." ^ Core_ident.base_name self : Stdlib.String.t) - in - let ty : Ltype.t = Ref { tid } in - let self = Ident.of_core_ident ~ty self in - let body = - transl_expr ~mtype_defs ~addr_tbl ~type_defs ~name_hint ~object_methods - fn.body - in - let env_id = Ident.fresh ~ty "*env" in - let body = - Lst.fold_left_with_offset fvs body 0 (fun fv rest i -> - let rhs = - Clam1.Lget_field { obj = env_id; index = i; tid; kind = Tuple } - in - Clam1.Llet { name = fv; e = rhs; body = rest }) - in - let body = fix_single_var ~self ~replace:env_id body in - let fn : Clam1.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam1.Top_private; fn }; - ({ captures = fvs; address = Well_known_mut_rec; tid }, self) - -let make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods - (fn_address : Fn_address.t) params - (body : [ `Clam1 of Clam1.lambda | `Core of Mcore.expr ]) return_type_ - ~export_info_ : Clam1.top_func_item = - let fn_kind_ = - match export_info_ with - | Some export_name -> Clam1.Top_pub export_name - | None -> Clam1.Top_private - in - let fn_body = - match body with - | `Core body -> - transl_expr ~addr_tbl ~type_defs - ~name_hint:(Fn_address.to_string fn_address) - ~mtype_defs ~object_methods body - | `Clam1 body -> body - in - { - binder = fn_address; - fn_kind_; - fn = { params; body = fn_body; return_type_ }; - } - -let make_top_closure_item (addr : Fn_address.t) (params : Ident.t list) - (return_type_ : Ltype.return_type) ~(closure_ty : Ltype.t) : - Clam1.top_func_item = - let closure_address = Fn_address.make_closure_wrapper addr in - let closure_body = - let args = Lst.map params (fun p -> Clam1.Vvar p) in - Clam1.Lapply { fn = Clam1.StaticFn addr; args; prim = None } - in - let env_id = Ident.fresh ~ty:closure_ty "*env" in - { - binder = closure_address; - fn_kind_ = Top_private; - fn = { params = env_id :: params; body = closure_body; return_type_ }; - } - -let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods - ~abstract_obj_tid ~concrete_obj_tid ~self_lty ~trait - ({ method_id; method_prim; method_ty } : Object_util.object_method_item) = - let params_ty, ret_ty = - match method_ty with - | T_func { params; return } -> (params, return) - | T_char | T_bool | T_int | T_uint | T_unit | T_byte | T_string | T_bytes - | T_tuple _ | T_fixedarray _ | T_trait _ | T_constr _ | T_int64 | T_uint64 - | T_float | T_double | T_any _ | T_optimized_option _ | T_maybe_uninit _ - | T_error_value_result _ -> - assert false - in - match[@warning "-fragile-match"] params_ty with - | self_ty :: params_ty -> ( - let self_id = Core_ident.fresh "*self" in - let params_id = Lst.map params_ty (fun _ -> Core_ident.fresh "*param") in - let body = - let args = - Mcore.var ~prim:None ~ty:self_ty self_id - :: Lst.map2 params_id params_ty (fun id ty -> - Mcore.var ~prim:None ~ty id) - in - match method_prim with - | Some (Pintrinsic _) | None -> - Mcore.apply ~prim:method_prim ~ty:ret_ty - ~kind:(Normal { func_ty = method_ty }) - method_id args - | Some prim -> Mcore.prim ~ty:ret_ty prim args - in - let body = - transl_expr ~name_hint:"" ~mtype_defs ~addr_tbl ~type_defs - ~object_methods body - in - let self_id = Ident.of_core_ident ~ty:self_lty self_id in - let obj_ty : Ltype.t = Ref { tid = abstract_obj_tid } in - let obj_id = Ident.fresh ~ty:obj_ty "*obj" in - let casted_obj_ty : Ltype.t = Ref { tid = concrete_obj_tid } in - let casted_obj_id = Ident.fresh ~ty:casted_obj_ty "*casted_obj" in - let body : Clam1.lambda = - Llet - { - name = casted_obj_id; - e = - Lcast - { expr = Lvar { var = obj_id }; target_type = casted_obj_ty }; - body = - Llet - { - name = self_id; - e = - Lclosure_field - { obj = casted_obj_id; tid = concrete_obj_tid; index = 0 }; - body; - }; - } - in - let fn : Clam1.fn = - { - params = - obj_id - :: Lst.map2 params_ty params_id (fun ty id -> - let ty = - Transl_mtype.mtype_to_ltype ~type_defs ~mtype_defs ty - in - Ident.of_core_ident ~ty id); - return_type_ = - Transl_mtype.mtype_to_ltype_return ~type_defs ~mtype_defs ret_ty; - body; - } - in - match[@warning "-fragile-match"] method_id with - | Pdot qual_name -> - let addr = Fn_address.make_object_wrapper qual_name ~trait in - new_top { binder = addr; fn_kind_ = Top_private; fn }; - addr - | _ -> assert false) - | _ -> assert false - -let transl_top_func ~(mtype_defs : Mtype.defs) ~(addr_tbl : Addr_table.t) - ~type_defs ~object_methods (func : Mcore.fn) (binder : Core_ident.t) is_pub_ - = - match[@warning "-fragile-match"] Addr_table.find_exn addr_tbl binder with - | Toplevel { addr; params; return; _ } -> - let fn_item = - make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods addr - params (`Core func.body) return ~export_info_:is_pub_ - in - new_top fn_item - | _ -> assert false - -let sequence (a : Clam1.lambda) (b : Clam1.lambda) ~expr1_type_ = - if Basic_prelude.phys_equal (Clam1_util.no_located b) clam_unit then a - else if Basic_prelude.phys_equal (Clam1_util.no_located a) clam_unit then b - else Lsequence { expr1 = a; expr2 = b; expr1_type_ } - -type translate_result = { - globals : (Ident.t * Constant.t option) list; - init : Clam1.lambda; - test : Clam1.lambda; -} - -let transl_top_item ~(mtype_defs : Mtype.defs) ~(addr_tbl : Addr_table.t) - ~(type_defs : Ltype.type_defs_with_context) ~object_methods - (top : Mcore.top_item) (acc : translate_result) : translate_result = - match top with - | Ctop_expr { expr; loc_ } -> - let name_hint = "*init*" in - base := loc_; - let clam_expr = - transl_expr ~mtype_defs ~name_hint ~addr_tbl ~type_defs ~object_methods - expr - in - let expr1_type_ = - Transl_mtype.mtype_to_ltype (Mcore.type_of_expr expr) ~type_defs - ~mtype_defs - in - { acc with init = sequence clam_expr acc.init ~expr1_type_ } - | Ctop_let { binder; expr; is_pub_ = _; loc_ } -> ( - base := loc_; - match expr with - | Cexpr_function { func; ty = _ } -> - transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func - binder None; - acc - | _ -> ( - let ty = Mcore.type_of_expr expr in - let name = - Ident.of_core_ident - ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty) - binder - in - let expr = - transl_expr ~name_hint:(Ident.to_string name) ~mtype_defs ~addr_tbl - ~type_defs ~object_methods expr - in - match Clam1_util.no_located expr with - | Lconst - ((C_bool _ | C_char _ | C_int _ | C_int64 _ | C_double _) as c) -> - { acc with globals = (name, Some c) :: acc.globals } - | _ -> - { - acc with - globals = (name, None) :: acc.globals; - init = Llet { name; e = expr; body = acc.init }; - })) - | Ctop_fn { binder; func; export_info_; loc_ } -> - base := loc_; - transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func - binder export_info_; - acc - | Ctop_stub { binder; func_stubs; params_ty; return_ty; export_info_; loc_ } - -> ( - base := loc_; - match[@warning "-fragile-match"] Addr_table.find_exn addr_tbl binder with - | Toplevel { addr; params; return; _ } -> - let params_ltype = - Lst.map2 params params_ty (fun id ty : Ltype.t -> - if Mtype.is_func ty then Ref_extern else Ident.get_type id) - in - let return_ltype = - match return_ty with - | None -> None - | Some _ -> ( - match[@warning "-fragile-match"] return with - | Ret_single return_ltype -> Some return_ltype - | _ -> assert false) - in - let rec make_body args_rev params params_ty : Clam1.lambda = - match (params, params_ty) with - | [], [] -> - let args = List.rev args_rev in - Levent - { - expr = - Lstub_call - { - fn = func_stubs; - args; - params_ty = params_ltype; - return_ty = return_ltype; - }; - loc_; - } - | param :: params, ty :: params_ty -> - if Mtype.is_func ty then - let tmp = Ident.fresh "extern" ~ty:(Ident.get_type param) in - Llet - { - name = tmp; - e = - Lprim - { fn = Pclosure_to_extern_ref; args = [ Vvar param ] }; - body = make_body (Vvar tmp :: args_rev) params params_ty; - } - else make_body (Vvar param :: args_rev) params params_ty - | _ -> assert false - in - let body : Clam1.lambda = make_body [] params params_ty in - let fn_item = - make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods - addr params (`Clam1 body) return ~export_info_ - in - new_top fn_item; - acc - | _ -> assert false) - -let collect_top_func ~type_defs ~mtype_defs (item : Mcore.top_item) - ~(addr_tbl : Addr_table.t) = - match item with - | Ctop_expr _ -> () - | Ctop_let { binder; expr = Cexpr_function { func; _ } } - | Ctop_fn { binder; func; _ } -> - let return = - Transl_mtype.mtype_to_ltype_return ~mtype_defs ~type_defs - (Mcore.type_of_expr func.body) - in - let params = transl_params ~mtype_defs func.params ~type_defs in - Addr_table.add_toplevel_fn addr_tbl binder ~params ~return - | Ctop_stub { binder; params_ty; return_ty; _ } -> - let params = - Lst.map params_ty (fun ty -> - Ident.fresh "*param" - ~ty:(Transl_mtype.mtype_to_ltype ty ~type_defs ~mtype_defs)) - in - let return_ltype = - match return_ty with - | Some return_ty -> - Transl_mtype.mtype_to_ltype ~type_defs ~mtype_defs return_ty - | None -> I32_Unit - in - Addr_table.add_toplevel_fn addr_tbl binder ~params - ~return:(Ret_single return_ltype) - | Ctop_let _ -> () - -let non_well_knowns_obj = - object - inherit [_] Mcore.Iter.iter - - method! visit_Cexpr_var (ctx : Core_ident.Hashset.t) id _ty _prim _loc = - Core_ident.Hashset.add ctx id - end - -let collect_local_non_well_knowns (ctx : Core_ident.Hashset.t) (prog : Mcore.t) - = - Lst.iter prog.body (non_well_knowns_obj#visit_top_item ctx); - match prog.main with - | None -> () - | Some (main, _) -> non_well_knowns_obj#visit_expr ctx main - -let transl_prog ({ body; main; types; object_methods = _ } as prog : Mcore.t) : - Clam1.prog = - binds_init := []; - Ident_hashset.reset local_non_well_knowns; - let type_defs = Transl_mtype.transl_mtype_defs types in - collect_local_non_well_knowns local_non_well_knowns prog; - let addr_tbl = Addr_table.create 17 in - Lst.iter body (collect_top_func ~type_defs ~mtype_defs:types ~addr_tbl); - let object_methods = Object_util.Hash.create 17 in - Object_util.Hash.iter2 prog.object_methods - (fun obj_key { self_ty; methods } -> - let ({ trait; type_ } : Object_util.object_key) = obj_key in - let abstract_obj_tid = Tid.of_type_path trait in - let concrete_obj_tid = Tid.concrete_object_type ~trait ~type_name:type_ in - let self_lty = - Transl_mtype.mtype_to_ltype ~type_defs ~mtype_defs:types self_ty - in - Tid.Hash.add type_defs.defs concrete_obj_tid - (Ref_closure { fn_sig_tid = abstract_obj_tid; captures = [ self_lty ] }); - let addrs = - Lst.map methods - (make_object_wrapper ~type_defs ~mtype_defs:types ~addr_tbl - ~object_methods ~abstract_obj_tid ~concrete_obj_tid ~self_lty - ~trait) - in - Object_util.Hash.add object_methods obj_key addrs); - (match main with - | Some (main, loc_) -> - collect_top_func ~type_defs ~mtype_defs:types - (Ctop_expr { expr = main; loc_ }) - ~addr_tbl - | None -> ()); - let acc = { globals = []; init = clam_unit; test = clam_unit } in - let main = - match main with - | None -> None - | Some (main, loc_) -> - base := loc_; - Some - (transl_expr ~mtype_defs:types ~name_hint:"*main*" ~addr_tbl - ~type_defs ~object_methods main) - in - let { globals; init; test } = - List.fold_right - (transl_top_item ~mtype_defs:types ~addr_tbl ~type_defs ~object_methods) - body acc - in - let start = sequence init test ~expr1_type_:I32_Unit in - let globals, init, fns = - Addr_table.fold addr_tbl (globals, start, !binds_init) - (fun _fn_binder fn_info (globals, start, fns) -> - match fn_info with - | Toplevel { name_as_closure = Some name; params; return; addr } -> ( - let closure_ty : Ltype.t = - match Ident.get_type name with - | Ref_any -> - let sig_ : Ltype.fn_sig = - { params = Lst.map params Ident.get_type; ret = return } - in - Ref - { tid = Ltype.FnSigHash.find_exn type_defs.fn_sig_tbl sig_ } - | ty -> ty - in - let closure_item = - make_top_closure_item addr params return ~closure_ty - in - let address = closure_item.binder in - match[@warning "-fragile-match"] closure_ty with - | Ref { tid } -> - let fn_closure = - Clam1.Lclosure - { captures = []; address = Normal address; tid } - in - ( (name, None) :: globals, - Clam1.Llet { name; e = fn_closure; body = start }, - closure_item :: fns ) - | _ -> assert false) - | Toplevel { name_as_closure = None; _ } | Local _ -> - (globals, start, fns)) - in - { fns; init; main; globals; type_defs = type_defs.defs } diff --git a/src/clam1_util.ml b/src/clam1_util.ml deleted file mode 100644 index aba1fb9..0000000 --- a/src/clam1_util.ml +++ /dev/null @@ -1,45 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -let loc_of_lambda : Clam1.lambda -> Loc.t option = function - | Levent { loc_; _ } -> Some loc_ - | Lallocate _ | Lclosure _ | Lget_field _ | Lclosure_field _ | Lset_field _ - | Lmake_array _ | Larray_get_item _ | Larray_set_item _ | Lapply _ - | Lstub_call _ | Lconst _ | Lif _ | Llet _ | Lletrec _ | Llet_multi _ - | Lprim _ | Lsequence _ | Ljoinlet _ | Ljoinapply _ | Lbreak _ | Lcontinue _ - | Lswitch _ | Lswitchint _ | Lswitchstring _ | Lvar _ | Lassign _ | Lcatch _ - | Lcast _ | Lmake_multi_result _ | Lhandle_error _ | Lloop _ | Lreturn _ -> - None - -let rec no_located : Clam1.lambda -> Clam1.lambda = function - | Levent { expr; _ } -> no_located expr - | expr -> expr - -let rec tail_of_expr (expr : Clam1.lambda) : Clam1.lambda = - match expr with - | Levent { expr = body; _ } - | Llet { body; _ } - | Llet_multi { body; _ } - | Lletrec { body; _ } - | Ljoinlet { body; _ } - | Lsequence { expr2 = body; _ } -> - tail_of_expr body - | Lallocate _ | Lclosure _ | Lget_field _ | Lclosure_field _ | Lset_field _ - | Lmake_array _ | Larray_get_item _ | Larray_set_item _ | Lapply _ - | Lstub_call _ | Lconst _ | Lif _ | Lprim _ | Ljoinapply _ | Lbreak _ - | Lcontinue _ | Lswitch _ | Lswitchint _ | Lswitchstring _ | Lvar _ - | Lassign _ | Lcatch _ | Lcast _ | Lmake_multi_result _ | Lhandle_error _ - | Lloop _ | Lreturn _ -> - expr diff --git a/src/clam_ident.ml b/src/clam_ident.ml index 23c0e26..d83793c 100644 --- a/src/clam_ident.ml +++ b/src/clam_ident.ml @@ -40,35 +40,36 @@ module Key = struct let _ = fun (_ : t) -> () let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Pdot _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = hsv in - Qual_ident.hash_fold_t hsv _ir.qual_name - in - hsv - | Pident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - hsv - in - hsv - | Pmutable_ident _ir -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.stamp - in - hsv - in - hsv + (fun hsv -> + fun arg -> + match arg with + | Pdot _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Qual_ident.hash_fold_t hsv _ir.qual_name + in + hsv + | Pident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + hsv + in + hsv + | Pmutable_ident _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.stamp + in + hsv + in + hsv : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -113,29 +114,32 @@ module Key = struct | Pmutable_ident { name; stamp; ty = _ } -> name ^ "!" ^ string_of_int stamp | Pdot q -> Qual_ident.string_of_t q.qual_name - let sexp_of_t (x : t) : S.t = - let ty = - match x with - | Pdot { ty; _ } | Pident { ty; _ } | Pmutable_ident { ty; _ } -> - Ltype.sexp_of_t ty - in - List [ Atom (to_string x); Atom ":"; ty ] + let sexp_of_t (x : t) = + (let ty = + match x with + | Pdot { ty; _ } | Pident { ty; _ } | Pmutable_ident { ty; _ } -> + Ltype.sexp_of_t ty + in + List [ Atom (to_string x); Atom ":"; ty ] + : S.t) end include Key -let of_core_ident (x : Core_ident.t) ~ty : t = - match x with - | Pdot qual_name -> Pdot { qual_name; ty } - | Plocal_method _ -> assert false - | Pident { stamp; name } -> Pident { stamp; name; ty } - | Pmutable_ident { stamp; name } -> Pmutable_ident { stamp; name; ty } +let of_core_ident (x : Core_ident.t) ~ty = + (match x with + | Pdot qual_name -> Pdot { qual_name; ty } + | Plocal_method _ -> assert false + | Pident { stamp; name } -> Pident { stamp; name; ty } + | Pmutable_ident { stamp; name } -> Pmutable_ident { stamp; name; ty } + : t) let to_wasm_name (x : t) = match x with | Pident { name; stamp; ty = _ } | Pmutable_ident { name; stamp; ty = _ } -> let name = Strutil.mangle_wasm_name name in - Stdlib.String.concat "" [ "$"; name; "/"; Int.to_string stamp ] + (Stdlib.String.concat "" + [ "$"; name; "/"; Int.to_string stamp ] [@merlin.hide]) | Pdot { qual_name; ty = _ } -> Qual_ident.to_wasm_name qual_name let fresh name ~ty = Pident { name; stamp = Uuid.next (); ty } @@ -175,33 +179,35 @@ module Map = struct let bal = Map_gen.bal let height = Map_gen.height - let rec add (tree : _ Map_gen.t as 'a) x data : 'a = - match tree with - | Empty -> singleton x data - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x data - else if c < 0 then Map_gen.unsafe_two_elements x data k v - else Map_gen.unsafe_two_elements k v x data - | Node { l; k; v; r; h } -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x data l r h - else if c < 0 then bal (add l x data) k v r - else bal l k v (add r x data) - - let rec adjust (tree : _ Map_gen.t as 'a) x replace : 'a = - match tree with - | Empty -> singleton x (replace None) - | Leaf { k; v } -> - let c = Key.compare x k in - if c = 0 then singleton x (replace (Some v)) - else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v - else Map_gen.unsafe_two_elements k v x (replace None) - | Node ({ l; k; r; _ } as tree) -> - let c = Key.compare x k in - if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h - else if c < 0 then bal (adjust l x replace) k tree.v r - else bal l k tree.v (adjust r x replace) + let rec add (tree : _ Map_gen.t as 'a) x data = + (match tree with + | Empty -> singleton x data + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x data + else if c < 0 then Map_gen.unsafe_two_elements x data k v + else Map_gen.unsafe_two_elements k v x data + | Node { l; k; v; r; h } -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x data l r h + else if c < 0 then bal (add l x data) k v r + else bal l k v (add r x data) + : 'a) + + let rec adjust (tree : _ Map_gen.t as 'a) x replace = + (match tree with + | Empty -> singleton x (replace None) + | Leaf { k; v } -> + let c = Key.compare x k in + if c = 0 then singleton x (replace (Some v)) + else if c < 0 then Map_gen.unsafe_two_elements x (replace None) k v + else Map_gen.unsafe_two_elements k v x (replace None) + | Node ({ l; k; r; _ } as tree) -> + let c = Key.compare x k in + if c = 0 then Map_gen.unsafe_node x (replace (Some tree.v)) l r tree.h + else if c < 0 then bal (adjust l x replace) k tree.v r + else bal l k tree.v (adjust r x replace) + : 'a) let rec find_exn (tree : _ Map_gen.t) x = match tree with @@ -237,77 +243,79 @@ module Map = struct let c = Key.compare x k in c = 0 || mem (if c < 0 then l else r) x - let rec remove (tree : _ Map_gen.t as 'a) x : 'a = - match tree with - | Empty -> empty - | Leaf leaf -> if Key.equal x leaf.k then empty else tree - | Node { l; k; v; r; _ } -> - let c = Key.compare x k in - if c = 0 then Map_gen.merge l r - else if c < 0 then bal (remove l x) k v r - else bal l k v (remove r x) + let rec remove (tree : _ Map_gen.t as 'a) x = + (match tree with + | Empty -> empty + | Leaf leaf -> if Key.equal x leaf.k then empty else tree + | Node { l; k; v; r; _ } -> + let c = Key.compare x k in + if c = 0 then Map_gen.merge l r + else if c < 0 then bal (remove l x) k v r + else bal l k v (remove r x) + : 'a) type 'a split = | Yes of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t; v : 'a } | No of { l : (key, 'a) Map_gen.t; r : (key, 'a) Map_gen.t } - let rec split (tree : (key, 'a) Map_gen.t) x : 'a split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf leaf -> - let c = Key.compare x leaf.k in - if c = 0 then Yes { l = empty; v = leaf.v; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; k; v; r; _ } -> ( - let c = Key.compare x k in - if c = 0 then Yes { l; v; r } - else if c < 0 then - match split l x with - | Yes result -> Yes { result with r = Map_gen.join result.r k v r } - | No result -> No { result with r = Map_gen.join result.r k v r } - else - match split r x with - | Yes result -> Yes { result with l = Map_gen.join l k v result.l } - | No result -> No { result with l = Map_gen.join l k v result.l }) - - let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail : - _ Map_gen.t = - match s1 with - | Empty -> s2 - | Leaf ({ k; _ } as l1) -> ( - match s2 with - | Empty -> s1 - | Leaf l2 -> - let c = Key.compare k l2.k in - if c = 0 then raise_notrace (fail k l1.v l2.v) - else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v - else Map_gen.unsafe_two_elements l2.k l2.v k l1.v - | Node _ -> - adjust s2 k (fun data -> - match data with - | None -> l1.v - | Some s2v -> raise_notrace (fail k l1.v s2v))) - | Node ({ k; _ } as xs1) -> ( - if xs1.h >= height s2 then - match split s2 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn xs1.l l fail) - k xs1.v - (disjoint_merge_exn xs1.r r fail) - | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) - else - match[@warning "-fragile-match"] s2 with - | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( - match split s1 k with - | No { l; r } -> - Map_gen.join - (disjoint_merge_exn l s2.l fail) - k s2.v - (disjoint_merge_exn r s2.r fail) - | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) - | _ -> assert false) + let rec split (tree : (key, 'a) Map_gen.t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf leaf -> + let c = Key.compare x leaf.k in + if c = 0 then Yes { l = empty; v = leaf.v; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; k; v; r; _ } -> ( + let c = Key.compare x k in + if c = 0 then Yes { l; v; r } + else if c < 0 then + match split l x with + | Yes result -> Yes { result with r = Map_gen.join result.r k v r } + | No result -> No { result with r = Map_gen.join result.r k v r } + else + match split r x with + | Yes result -> Yes { result with l = Map_gen.join l k v result.l } + | No result -> No { result with l = Map_gen.join l k v result.l }) + : 'a split) + + let rec disjoint_merge_exn (s1 : _ Map_gen.t) (s2 : _ Map_gen.t) fail = + (match s1 with + | Empty -> s2 + | Leaf ({ k; _ } as l1) -> ( + match s2 with + | Empty -> s1 + | Leaf l2 -> + let c = Key.compare k l2.k in + if c = 0 then raise_notrace (fail k l1.v l2.v) + else if c < 0 then Map_gen.unsafe_two_elements l1.k l1.v l2.k l2.v + else Map_gen.unsafe_two_elements l2.k l2.v k l1.v + | Node _ -> + adjust s2 k (fun data -> + match data with + | None -> l1.v + | Some s2v -> raise_notrace (fail k l1.v s2v))) + | Node ({ k; _ } as xs1) -> ( + if xs1.h >= height s2 then + match split s2 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn xs1.l l fail) + k xs1.v + (disjoint_merge_exn xs1.r r fail) + | Yes { v = s2v; _ } -> raise_notrace (fail k xs1.v s2v) + else + match[@warning "-fragile-match"] s2 with + | (Node ({ k; _ } as s2) : _ Map_gen.t) -> ( + match split s1 k with + | No { l; r } -> + Map_gen.join + (disjoint_merge_exn l s2.l fail) + k s2.v + (disjoint_merge_exn r s2.r fail) + | Yes { v = s1v; _ } -> raise_notrace (fail k s1v s2.v)) + | _ -> assert false) + : _ Map_gen.t) let sexp_of_t f map = Moon_sexp_conv.sexp_of_list @@ -318,10 +326,12 @@ module Map = struct (bindings map) let add_list (xs : _ list) init = - Lst.fold_left xs init (fun acc (k, v) -> add acc k v) + Lst.fold_left xs init (fun acc -> fun (k, v) -> add acc k v) let of_list xs = add_list xs empty - let of_array xs = Arr.fold_left xs empty (fun acc (k, v) -> add acc k v) + + let of_array xs = + Arr.fold_left xs empty (fun acc -> fun (k, v) -> add acc k v) end module Set = struct @@ -365,111 +375,134 @@ module Set = struct let split_pres (x : split) = match x with Yes _ -> true | No _ -> false [@@inline] - let rec split (tree : t) x : split = - match tree with - | Empty -> No { l = empty; r = empty } - | Leaf v -> - let c = Key.compare x v in - if c = 0 then Yes { l = empty; r = empty } - else if c < 0 then No { l = empty; r = tree } - else No { l = tree; r = empty } - | Node { l; v; r; _ } -> ( - let c = Key.compare x v in - if c = 0 then Yes { l; r } - else if c < 0 then - match split l x with - | Yes result -> - Yes { result with r = Set_gen.internal_join result.r v r } - | No result -> - No { result with r = Set_gen.internal_join result.r v r } - else - match split r x with - | Yes result -> - Yes { result with l = Set_gen.internal_join l v result.l } - | No result -> - No { result with l = Set_gen.internal_join l v result.l }) - - let rec add (tree : t) x : t = - match tree with - | Empty -> singleton x - | Leaf v -> - let c = Key.compare x v in - if c = 0 then tree - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | Node { l; v; r; _ } as t -> - let c = Key.compare x v in - if c = 0 then t - else if c < 0 then Set_gen.bal (add l x) v r - else Set_gen.bal l v (add r x) - - let rec union (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, t | t, Empty -> t - | Node _, Leaf v2 -> add s1 v2 - | Leaf v1, Node _ -> add s2 v1 - | Leaf x, Leaf v -> - let c = Key.compare x v in - if c = 0 then s1 - else if c < 0 then Set_gen.unsafe_two_elements x v - else Set_gen.unsafe_two_elements v x - | ( Node { l = l1; v = v1; r = r1; h = h1 }, - Node { l = l2; v = v2; r = r2; h = h2 } ) -> - if h1 >= h2 then - let split_result = split s2 v1 in - Set_gen.internal_join - (union l1 (split_l split_result)) - v1 - (union r1 (split_r split_result)) - else - let split_result = split s1 v2 in - Set_gen.internal_join - (union (split_l split_result) l2) - v2 - (union (split_r split_result) r2) - - let rec inter (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ | _, Empty -> empty - | Leaf v, _ -> if mem s2 v then s1 else empty - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_join - (inter s1.l (split_l result)) - v - (inter s1.r (split_r result)) - else - Set_gen.internal_concat - (inter s1.l (split_l result)) - (inter s1.r (split_r result)) - - let rec diff (s1 : t) (s2 : t) : t = - match (s1, s2) with - | Empty, _ -> empty - | t1, Empty -> t1 - | Leaf v, _ -> if mem s2 v then empty else s1 - | Node ({ v; _ } as s1), _ -> - let result = split s2 v in - if split_pres result then - Set_gen.internal_concat - (diff s1.l (split_l result)) - (diff s1.r (split_r result)) - else - Set_gen.internal_join - (diff s1.l (split_l result)) - v - (diff s1.r (split_r result)) - - let rec remove (tree : t) (x : elt) : t = - match tree with - | Empty -> empty - | Leaf v -> if Key.equal x v then empty else tree - | Node { l; v; r; _ } -> - let c = Key.compare x v in - if c = 0 then Set_gen.internal_merge l r - else if c < 0 then Set_gen.bal (remove l x) v r - else Set_gen.bal l v (remove r x) + let rec split (tree : t) x = + (match tree with + | Empty -> No { l = empty; r = empty } + | Leaf v -> + let c = Key.compare x v in + if c = 0 then Yes { l = empty; r = empty } + else if c < 0 then No { l = empty; r = tree } + else No { l = tree; r = empty } + | Node { l; v; r; _ } -> ( + let c = Key.compare x v in + if c = 0 then Yes { l; r } + else if c < 0 then + match split l x with + | Yes result -> + Yes { result with r = Set_gen.internal_join result.r v r } + | No result -> + No { result with r = Set_gen.internal_join result.r v r } + else + match split r x with + | Yes result -> + Yes { result with l = Set_gen.internal_join l v result.l } + | No result -> + No { result with l = Set_gen.internal_join l v result.l }) + : split) + + let rec add (tree : t) x = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } as t -> + let c = Key.compare x v in + if c = 0 then t + else if c < 0 then Set_gen.bal (add l x) v r + else Set_gen.bal l v (add r x) + : t) + + let rec check_add (tree : t) ~(duplicate_flag : bool ref) (x : elt) = + (match tree with + | Empty -> singleton x + | Leaf v -> + let c = Key.compare x v in + if c = 0 then ( + duplicate_flag := true; + tree) + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then tree + else if c < 0 then Set_gen.bal (check_add l ~duplicate_flag x) v r + else Set_gen.bal l v (check_add r ~duplicate_flag x) + : t) + + let rec union (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, t | t, Empty -> t + | Node _, Leaf v2 -> add s1 v2 + | Leaf v1, Node _ -> add s2 v1 + | Leaf x, Leaf v -> + let c = Key.compare x v in + if c = 0 then s1 + else if c < 0 then Set_gen.unsafe_two_elements x v + else Set_gen.unsafe_two_elements v x + | ( Node { l = l1; v = v1; r = r1; h = h1 }, + Node { l = l2; v = v2; r = r2; h = h2 } ) -> + if h1 >= h2 then + let split_result = split s2 v1 in + Set_gen.internal_join + (union l1 (split_l split_result)) + v1 + (union r1 (split_r split_result)) + else + let split_result = split s1 v2 in + Set_gen.internal_join + (union (split_l split_result) l2) + v2 + (union (split_r split_result) r2) + : t) + + let rec inter (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ | _, Empty -> empty + | Leaf v, _ -> if mem s2 v then s1 else empty + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_join + (inter s1.l (split_l result)) + v + (inter s1.r (split_r result)) + else + Set_gen.internal_concat + (inter s1.l (split_l result)) + (inter s1.r (split_r result)) + : t) + + let rec diff (s1 : t) (s2 : t) = + (match (s1, s2) with + | Empty, _ -> empty + | t1, Empty -> t1 + | Leaf v, _ -> if mem s2 v then empty else s1 + | Node ({ v; _ } as s1), _ -> + let result = split s2 v in + if split_pres result then + Set_gen.internal_concat + (diff s1.l (split_l result)) + (diff s1.r (split_r result)) + else + Set_gen.internal_join + (diff s1.l (split_l result)) + v + (diff s1.r (split_r result)) + : t) + + let rec remove (tree : t) (x : elt) = + (match tree with + | Empty -> empty + | Leaf v -> if Key.equal x v then empty else tree + | Node { l; v; r; _ } -> + let c = Key.compare x v in + if c = 0 then Set_gen.internal_merge l r + else if c < 0 then Set_gen.bal (remove l x) v r + else Set_gen.bal l v (remove r x) + : t) let of_list l = match l with @@ -487,8 +520,8 @@ module Set = struct Set_gen.check t; Set_gen.is_ordered ~cmp:Key.compare t - let add_list (env : t) params : t = - List.fold_left (fun env e -> add env e) env params + let add_list (env : t) params = + (List.fold_left (fun env -> fun e -> add env e) env params : t) let sexp_of_t t = Moon_sexp_conv.sexp_of_list Key.sexp_of_t (to_list t) @@ -530,6 +563,7 @@ module Hash = struct let to_list_with = Hash_gen.to_list_with let to_list = Hash_gen.to_list let to_array = Hash_gen.to_array + let to_array_map = Hash_gen.to_array_map let to_array_filter_map = Hash_gen.to_array_filter_map let fold = Hash_gen.fold let length = Hash_gen.length @@ -542,26 +576,28 @@ module Hash = struct if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h let add_or_update (h : 'a t) (key : key) ~update:(modf : 'a -> 'a) - (default : 'a) : 'a = - let rec find_bucket (bucketlist : _ bucket) : 'a option = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then ( - let data = modf rhs.data in - rhs.data <- data; - Some data) - else find_bucket rhs.next - | Empty -> None - in - let i = key_index h key in - let h_data = h.data in - match find_bucket h_data.!(i) with - | Some data -> data - | None -> - h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - default + (default : 'a) = + (let rec find_bucket (bucketlist : _ bucket) = + (match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then ( + let data = modf rhs.data in + rhs.data <- data; + Some data) + else find_bucket rhs.next + | Empty -> None + : 'a option) + in + let i = key_index h key in + let h_data = h.data in + match find_bucket h_data.!(i) with + | Some data -> data + | None -> + h_data.!(i) <- Cons { key; data = default; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; + default + : 'a) let remove (h : _ t) key = let i = key_index h key in @@ -601,22 +637,24 @@ module Hash = struct Hash_gen.small_bucket_default equal_key key default h.data.!(key_index h key) - let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) : v = - let rec find_bucket h_data i (bucketlist : _ bucket) = - match bucketlist with - | Cons rhs -> - if equal_key rhs.key key then rhs.data - else find_bucket h_data i rhs.next - | Empty -> - let data = update key in - h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hash_gen.resize key_index h; - data - in - let i = key_index h key in - let h_data = h.data in - find_bucket h_data i h_data.!(i) + let find_or_update (type v) (h : v t) (key : key) ~(update : key -> v) = + (let rec find_bucket h_data i (bucketlist : _ bucket) = + match bucketlist with + | Cons rhs -> + if equal_key rhs.key key then rhs.data + else find_bucket h_data i rhs.next + | Empty -> + let data = update key in + h_data.!(i) <- Hash_gen.Cons { key; data; next = h_data.!(i) }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hash_gen.resize key_index h; + data + in + let i = key_index h key in + let h_data = h.data in + find_bucket h_data i h_data.!(i) + : v) let find_all (h : _ t) key = let rec find_in_bucket (bucketlist : _ bucket) = @@ -625,6 +663,7 @@ module Hash = struct | Cons rhs -> if equal_key key rhs.key then rhs.data :: find_in_bucket rhs.next else find_in_bucket rhs.next + [@@tail_mod_cons] in find_in_bucket h.data.!(key_index h key) @@ -655,13 +694,13 @@ module Hash = struct let of_list2 ks vs = let len = List.length ks in let map = create len in - List.iter2 (fun k v -> add map k v) ks vs; + List.iter2 (fun k -> fun v -> add map k v) ks vs; map let of_list_map kvs f = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun kv -> + Lst.iter kvs ~f:(fun kv -> let k, v = f kv in add map k v); map @@ -669,7 +708,7 @@ module Hash = struct let of_list kvs = let len = List.length kvs in let map = create len in - Lst.iter kvs (fun (k, v) -> add map k v); + Lst.iter kvs ~f:(fun (k, v) -> add map k v); map let sexp_of_t (type a) (cb : a -> _) (x : a t) = @@ -726,29 +765,31 @@ module Hashset = struct done; tbl - let check_add (h : _ Hashset_gen.t) key : bool = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; - true) - else false - - let find_or_add (h : _ Hashset_gen.t) key : key = - let i = key_index h key in - let h_data = h.data in - let old_bucket = h_data.!(i) in - match Hashset_gen.small_bucket_find equal_key key old_bucket with - | Some key0 -> key0 - | None -> - h_data.!(i) <- Cons { key; next = old_bucket }; - h.size <- h.size + 1; - if h.size > Array.length h_data lsl 1 then - Hashset_gen.resize key_index h; - key + let check_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + if not (Hashset_gen.small_bucket_mem equal_key key old_bucket) then ( + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then Hashset_gen.resize key_index h; + true) + else false + : bool) + + let find_or_add (h : _ Hashset_gen.t) key = + (let i = key_index h key in + let h_data = h.data in + let old_bucket = h_data.!(i) in + match Hashset_gen.small_bucket_find equal_key key old_bucket with + | Some key0 -> key0 + | None -> + h_data.!(i) <- Cons { key; next = old_bucket }; + h.size <- h.size + 1; + if h.size > Array.length h_data lsl 1 then + Hashset_gen.resize key_index h; + key + : key) let mem (h : _ Hashset_gen.t) key = Hashset_gen.small_bucket_mem equal_key key h.data.!(key_index h key) diff --git a/src/clam_of_core.ml b/src/clam_of_core.ml index 6bf69bd..f8a1ff5 100644 --- a/src/clam_of_core.ml +++ b/src/clam_of_core.ml @@ -43,944 +43,1033 @@ let fix_var = let fix_single_var ~self ~replace body = fix_var#visit_lambda (self, replace) body -let transl_params ~mtype_defs ~type_defs (params : Mcore.param list) : - Ident.t list = - Lst.map params (fun { binder; ty } -> - Ident.of_core_ident binder - ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty)) +let transl_params ~mtype_defs ~type_defs (params : Mcore.param list) = + (Lst.map params (fun { binder; ty } -> + Ident.of_core_ident binder + ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty)) + : Ident.t list) let transl_ident (id : Core_ident.t) ~(addr_tbl : Addr_table.t) ~mtype_defs - ~type_defs mty : Ident.t = - match Addr_table.find_opt addr_tbl id with - | Some (Toplevel { name_as_closure = Some id; _ }) -> id - | Some (Toplevel fn_info) -> - let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in - let id = Ident.of_core_ident ~ty id in - fn_info.name_as_closure <- Some id; - id - | Some (Local (_addr, ty)) -> Ident.of_core_ident ~ty id - | None -> - let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in - Ident.of_core_ident ~ty id + ~type_defs mty = + (match Addr_table.find_opt addr_tbl id with + | Some (Toplevel { name_as_closure = Some id; _ }) -> id + | Some (Toplevel fn_info) -> + let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in + let id = Ident.of_core_ident ~ty id in + fn_info.name_as_closure <- Some id; + id + | Some (Local (_addr, ty)) -> Ident.of_core_ident ~ty id + | None -> + let ty = Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs mty in + Ident.of_core_ident ~ty id + : Ident.t) let rec transl_expr ~name_hint ~mtype_defs ~addr_tbl ~type_defs ~object_methods - (x : Mcore.expr) : Clam.lambda = - let transl_type mtype = - Transl_mtype.mtype_to_ltype mtype ~type_defs ~mtype_defs - [@@inline] - in - let transl_type_as_named_exn mtype = - match transl_type mtype with - | Ref_lazy_init { tid } | Ltype.Ref { tid } | Ref_nullable { tid } -> tid - | Ref_bytes -> Ltype.tid_bytes - | _ -> assert false - [@@inline] - in - let transl_constr_type tag mtype = - Transl_mtype.constr_to_ltype ~tag mtype - [@@inline] - in - let go x = - transl_expr ~name_hint ~mtype_defs ~addr_tbl ~type_defs ~object_methods x - [@@inline] - in - let bind (rhs : Mcore.expr) cont : Clam.lambda = - match rhs with - | Cexpr_var { id; ty; _ } -> - let ty = transl_type ty in - cont (Ident.of_core_ident ~ty id) - | _ -> - let ty = transl_type (Mcore.type_of_expr rhs) in - let name = Ident.fresh ~ty "*bind" in - Llet { name; e = go rhs; body = cont name } - [@@inline] - in - let append_name_hint new_name : Stdlib.String.t = - name_hint ^ "." ^ Core_ident.base_name new_name - [@@inline] - in - let handle_abstract_closure_type ~(name : Core_ident.t option) (fn : Mcore.fn) - (address : Fn_address.t) : Tid.t = - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - [ - Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body); - ] - in - let sig_ : Ltype.fn_sig = - { params = Lst.map params Ident.get_type; ret = return_type_ } - in - let abs_closure_tid = - match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl sig_ with - | Some tid -> tid - | None -> - let tid = - Name_mangle.make_type_name - (T_func - { - params = Lst.map fn.params (fun p -> p.ty); - return = Mcore.type_of_expr fn.body; - }) - in - Ltype.FnSigHash.add type_defs.fn_sig_tbl sig_ tid; - Tid.Hash.add type_defs.defs tid - (Ltype.Ref_closure_abstract { fn_sig = sig_ }); - tid - in - let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in - (match name with - | Some name -> - Addr_table.add_local_fn_addr_and_type addr_tbl name address - abs_closure_ty - | None -> ()); - abs_closure_tid - in - let expr : Clam.lambda = - match x with - | Cexpr_const { c; ty = _ } -> Lconst c - | Cexpr_unit _ -> clam_unit - | Cexpr_var { id; ty; prim = _ } -> - let var = transl_ident id ty ~addr_tbl ~mtype_defs ~type_defs in - Lvar { var } - | Cexpr_prim { prim; args; ty } -> ( - let make_prim fn = - Clam.Lprim { fn; args = Lst.map args go } - [@@inline] - in - match prim with - | Parray_make -> - let args = Lst.map args go in - let arr_tid = - let tid = Mtype.get_constr_tid_exn ty in - match Mtype.Id_hash.find_opt mtype_defs.defs tid with - | Some (Record { fields = { field_type = arr_type; _ } :: _ }) -> - transl_type_as_named_exn arr_type - | _ -> assert false - in - let vec_tid = transl_type_as_named_exn ty in - Clam.Lallocate - { - kind = Struct; - tid = vec_tid; - fields = - [ - Clam.Lmake_array - { kind = EverySingleElem; tid = arr_tid; elems = args }; - Clam.Lconst - (C_int - { v = Int32.of_int (List.length args); repr = None }); - ]; - } - | Pfixedarray_make { kind } -> - Lmake_array - { - kind; - tid = transl_type_as_named_exn ty; - elems = Lst.map args go; - } - | Pfixedarray_get_item { kind } -> ( - let arr_type = Mcore.type_of_expr (List.hd args) in - if arr_type = T_bytes then - Lprim { fn = Pgetbytesitem; args = Lst.map args go } - else - let need_non_null_cast = - let elem = Mtype.get_fixedarray_elem_exn arr_type in - Mtype.is_uninit elem - in - match[@warning "-fragile-match"] Lst.map args go with - | [ arr; index ] -> - Larray_get_item - { - arr; - index; - tid = transl_type_as_named_exn arr_type; - need_non_null_cast; - kind; - } - | _ -> assert false) - | Pfixedarray_set_item { set_kind } -> ( - let arr_type = Mcore.type_of_expr (List.hd args) in - match[@warning "-fragile-match"] Lst.map args go with - | arr :: index :: item -> - let item = - match item with - | [] -> None - | item :: [] -> Some item - | _ -> assert false - in - Larray_set_item - { - tid = transl_type_as_named_exn arr_type; - kind = set_kind; - arr; - index; - item; - } - | _ -> assert false) - | Prefeq -> - let mty = Mcore.type_of_expr (List.hd args) in - let lty = transl_type mty in - make_prim - (match lty with - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char -> - Pcomparison { operator = Eq; operand_type = I32 } - | I64 -> Pcomparison { operator = Eq; operand_type = I64 } - | F32 -> Pcomparison { operator = Eq; operand_type = F32 } - | F64 -> Pcomparison { operator = Eq; operand_type = F64 } - | Ref_string when !Basic_config.use_js_builtin_string -> - Pstringequal - | Ref_nullable { tid } - when !Basic_config.use_js_builtin_string - && Tid.equal tid Ltype.tid_string -> - Pstringequal - | Ref _ | Ref_lazy_init _ | Ref_nullable _ | Ref_extern - | Ref_string | Ref_bytes | Ref_func | Ref_any -> - Prefeq) - | Pcast { kind } -> ( - match[@warning "-fragile-match"] args with - | arg :: [] -> ( - match kind with - | Constr_to_enum | Make_newtype -> go arg - | Unfold_rec_newtype -> - let target_type = transl_type ty in - Lcast { expr = go arg; target_type }) - | _ -> assert false) - | Penum_field { index; tag } -> ( - let tid = - Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) - in - match[@warning "-fragile-match"] List.map go args with - | obj :: [] -> - let tag = Tag.of_core_tag mtype_defs.ext_tags tag in - Lget_field { kind = Enum { tag }; obj; index; tid } - | _ -> assert false) - | Pset_enum_field { index; tag } -> ( + (x : Mcore.expr) = + (let transl_type mtype = + Transl_mtype.mtype_to_ltype mtype ~type_defs ~mtype_defs + [@@inline] + in + let transl_type_as_named_exn mtype = + match transl_type mtype with + | Ref_lazy_init { tid } | Ltype.Ref { tid } | Ref_nullable { tid } -> tid + | Ref_bytes -> Ltype.tid_bytes + | _ -> assert false + [@@inline] + in + let transl_constr_type tag mtype = + Transl_mtype.constr_to_ltype ~tag mtype + [@@inline] + in + let go x = + transl_expr ~name_hint ~mtype_defs ~addr_tbl ~type_defs ~object_methods x + [@@inline] + in + let bind (rhs : Mcore.expr) cont = + (match rhs with + | Cexpr_var { id; ty; _ } -> + let ty = transl_type ty in + cont (Ident.of_core_ident ~ty id) + | _ -> + let ty = transl_type (Mcore.type_of_expr rhs) in + let name = Ident.fresh ~ty "*bind" in + Llet { name; e = go rhs; body = cont name } + : Clam.lambda) + [@@inline] + in + let append_name_hint new_name = + (name_hint ^ "." ^ Core_ident.base_name new_name : Stdlib.String.t) + [@@inline] + in + let handle_abstract_closure_type ~(name : Core_ident.t option) + (fn : Mcore.fn) (address : Fn_address.t) = + (let params = transl_params ~mtype_defs ~type_defs fn.params in + let return_type_ = + [ + Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs + (Mcore.type_of_expr fn.body); + ] + in + let sig_ : Ltype.fn_sig = + { params = Lst.map params Ident.get_type; ret = return_type_ } + in + let abs_closure_tid = + match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl sig_ with + | Some tid -> tid + | None -> let tid = - Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) - in - match[@warning "-fragile-match"] List.map go args with - | [ obj; field ] -> - let tag = Tag.of_core_tag mtype_defs.ext_tags tag in - Lset_field { kind = Enum { tag }; obj; field; index; tid } - | _ -> assert false) - | Pcatch -> ( - match[@warning "-fragile-match"] args with - | [ body; on_exception ] -> - Lcatch - { - body = go body; - on_exception = go on_exception; - type_ = transl_type (Mcore.type_of_expr body); - } - | _ -> assert false) - | Pmake_value_or_error { tag } -> - let tag = Tag.of_core_tag_no_ext tag in - let t = transl_constr_type tag ty in - Lallocate - { kind = Enum { tag }; tid = t; fields = List.map go args } - | Pnull when !Basic_config.use_js_builtin_string -> ( - let ty = transl_type ty in - match ty with - | Ref_nullable { tid } when Tid.equal tid Ltype.tid_string -> - make_prim Pnull_string_extern - | _ -> make_prim Pnull) - | Pcall_object_method { method_index; _ } -> ( - let method_ty = - transl_type + Name_mangle.make_type_name (T_func - { params = Lst.map args Mcore.type_of_expr; return = ty }) - in - match[@warning "-fragile-match"] args with - | self :: args -> - bind self (fun obj -> - let args = Lst.map args go in - Lapply - { - fn = Object { obj; method_index; method_ty }; - args; - prim = None; - }) - | _ -> assert false) - | _ -> make_prim prim) - | Cexpr_let { name; rhs; body; ty = _ } -> - let ty_rhs = Mcore.type_of_expr rhs in - let name = Ident.of_core_ident ~ty:(transl_type ty_rhs) name in - Llet { name; e = go rhs; body = go body } - | Cexpr_letfn { name; fn; body; kind; ty } -> ( - match kind with - | Nonrec -> - let name_hint = append_name_hint name in - let address = Fn_address.fresh (name_hint ^ ".fn") in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~object_methods ~address - ~name_hint ~mtype_defs ~self:None ~abs_closure_tid fn - in - let body = go body in - let name = Ident.of_core_ident name ~ty in - Llet { name; e = Lclosure closure; body } - else - let tuple, binder = - well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~name_hint ~address ~self:name ~is_rec:false - fn - in - let body = go body in - Llet { name = binder; e = tuple; body } - | Rec -> - let name_hint = append_name_hint name in - let address = Fn_address.fresh (name_hint ^ ".fn") in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~object_methods ~name_hint - ~mtype_defs ~self:(Some name) ~address ~abs_closure_tid fn - in - let body = go body in - let name = Ident.of_core_ident name ~ty in - Llet { name; e = Lclosure closure; body } - else - let tuple, binder = - well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~name_hint ~address ~self:name ~is_rec:true fn - in - let body = go body in - Llet { name = binder; e = tuple; body } - | Tail_join | Nontail_join -> - let name = Join.of_core_ident name in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let join_body = go fn.body in - let body = go body in - let kind : Clam.join_kind = - match kind with - | Tail_join -> Tail_join - | Nontail_join -> Nontail_join - | _ -> assert false - in - let type_ = [ transl_type ty ] in - Ljoinlet { name; params; e = join_body; body; kind; type_ }) - | Cexpr_function { func; ty = _ } -> - let address = Fn_address.fresh (name_hint ^ ".fn") in - let abs_closure_tid = - handle_abstract_closure_type ~name:None func address - in - let closure, _ = - closure_of_fn ~addr_tbl ~type_defs ~mtype_defs ~object_methods - ~name_hint ~address ~self:None ~abs_closure_tid func - in - Lclosure closure - | Cexpr_apply { func; args; kind = Join; ty = _; prim = _ } -> - let name = Join.of_core_ident func in - let args = List.map go args in - Ljoinapply { name; args } - | Cexpr_apply - { func; args = core_args; kind = Normal { func_ty }; ty = _; prim } -> ( - let args = Lst.map core_args go in - match Addr_table.find_opt addr_tbl func with - | Some (Toplevel { addr; _ }) -> - let prim : Clam.intrinsic option = - match prim with - | Some (Pintrinsic FixedArray_copy) -> ( - match core_args with - | dst :: _ :: src :: _ -> - let dst_tid = - transl_type_as_named_exn (Mcore.type_of_expr dst) - in - let src_tid = - transl_type_as_named_exn (Mcore.type_of_expr src) - in - Some (FixedArray_copy { src_tid; dst_tid }) - | _ -> assert false) - | Some (Pintrinsic FixedArray_fill) -> ( - match core_args with - | arr :: _ -> - let arr_tid = - transl_type_as_named_exn (Mcore.type_of_expr arr) - in - Some (FixedArray_fill { tid = arr_tid }) - | _ -> assert false) - | Some - (Pintrinsic - ( Char_to_string | F64_to_string | String_substring - | FixedArray_join | FixedArray_iter | FixedArray_iteri - | FixedArray_map | FixedArray_fold_left | Iter_map - | Iter_iter | Iter_from_array | Iter_take | Iter_reduce - | Iter_flat_map | Iter_repeat | Iter_filter | Iter_concat - | Array_length | Array_get | Array_unsafe_get | Array_set - | Array_unsafe_set )) -> - None - | Some _ -> assert false - | None -> None - in - Lapply { fn = StaticFn addr; args; prim } - | Some (Local (addr, self_ty)) -> - let self = Ident.of_core_ident func ~ty:self_ty in - Lapply - { - fn = StaticFn addr; - args = Lvar { var = self } :: args; - prim = None; - } - | None -> - let fn = Ident.of_core_ident ~ty:(transl_type func_ty) func in - Lapply { fn = Dynamic fn; args; prim = None }) - | Cexpr_object { self; methods_key; ty = _ } -> - let ({ trait; type_ } : Object_util.object_key) = methods_key in - let tid = Tid.concrete_object_type ~trait ~type_name:type_ in - let methods = Object_util.Hash.find_exn object_methods methods_key in - bind self (fun self -> - Lclosure { tid; address = Object methods; captures = [ self ] }) - | Cexpr_letrec { bindings; body; ty = _ } -> - let addresses = - Lst.map bindings (fun (name, fn) -> - let address = Fn_address.fresh (append_name_hint name ^ ".fn") in - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = - handle_abstract_closure_type ~name:(Some name) fn address - in - (address, Some abs_closure_tid) - else - let ty = Ltype.Ref { tid = Tid.capture_of_function address } in - Addr_table.add_local_fn_addr_and_type addr_tbl name address ty; - (address, None)) - in - let fns, names = - Lst.split_map2 bindings addresses - (fun (name, fn) (address, abs_closure_tid_opt) -> - if Core_ident.Hashset.mem local_non_well_knowns name then - let abs_closure_tid = Option.get abs_closure_tid_opt in - let closure, ty = - closure_of_fn ~addr_tbl ~type_defs ~mtype_defs ~object_methods - ~address ~name_hint:(append_name_hint name) - ~self:(Some name) ~abs_closure_tid fn - in - let self = Ident.of_core_ident name ~ty in - (closure, self) - else - well_known_closure_of_mut_rec_fn ~addr_tbl ~type_defs - ~mtype_defs ~object_methods ~address - ~name_hint:(append_name_hint name) ~self:name fn) - in - Lletrec { names; fns; body = go body } - | Cexpr_constr { constr = _; tag; args; ty } -> - let t = transl_constr_type tag ty in - Lallocate { kind = Enum { tag }; tid = t; fields = Lst.map args go } - | Cexpr_tuple { exprs; ty } -> - let t = transl_type_as_named_exn ty in - Lallocate { kind = Tuple; tid = t; fields = List.map go exprs } - | Cexpr_record { fields; ty } -> - if fields = [] then clam_unit - else - let fields = Lst.map fields (fun { expr; _ } -> go expr) in - let t = transl_type_as_named_exn ty in - Lallocate { kind = Struct; tid = t; fields } - | Cexpr_record_update { record; fields; fields_num; ty } -> - let t = transl_type_as_named_exn ty in - bind record (fun record_id -> - let record_clam : Clam.lambda = Lvar { var = record_id } in - let get_new_field i = - match Lst.find_first fields (fun { pos; _ } -> pos = i) with - | Some { expr; _ } -> go expr - | None -> - Lget_field - { kind = Struct; obj = record_clam; index = i; tid = t } - in - Lallocate - { - kind = Struct; - tid = t; - fields = List.init fields_num get_new_field; - }) - | Cexpr_field { record; accessor; pos; ty = _ } -> - let obj = go record in - let t = transl_type_as_named_exn (Mcore.type_of_expr record) in - let kind : Clam.aggregate_kind = - match accessor with - | Newtype -> assert false - | Label _ -> Struct - | Index _ -> Tuple - in - Lget_field { kind; obj; index = pos; tid = t } - | Cexpr_mutate { record; label = _; field; pos; ty = _ } -> - let t = transl_type_as_named_exn (Mcore.type_of_expr record) in - Lset_field - { - obj = go record; - field = go field; - index = pos; - tid = t; - kind = Struct; - } - | Cexpr_array { exprs; ty } -> - let tid = transl_type_as_named_exn ty in - Lmake_array { kind = EverySingleElem; tid; elems = List.map go exprs } - | Cexpr_assign { var; expr; ty = _ } -> - let var = - Ident.of_core_ident var ~ty:(transl_type (Mcore.type_of_expr expr)) - in - Lassign { var; e = go expr } - | Cexpr_sequence { expr1; expr2; ty = _ } -> - Lsequence - { - expr1 = go expr1; - expr2 = go expr2; - expr1_type_ = transl_type (Mcore.type_of_expr expr1); - } - | Cexpr_if { cond; ifso; ifnot; ty } -> ( - let pred = go cond in - let ifso = go ifso in - match ifnot with - | Some ifnot -> - Lif { pred; ifso; ifnot = go ifnot; type_ = transl_type ty } - | None -> Lif { pred; ifso; ifnot = clam_unit; type_ = I32_Unit }) - | Cexpr_handle_error { obj; handle_kind = To_result; _ } -> go obj - | Cexpr_handle_error { obj; handle_kind; ty } -> - let obj_ty = Mcore.type_of_expr obj in - bind obj (fun obj_id -> - let obj : Clam.lambda = Lvar { var = obj_id } in - let ok_tag = Tag.of_core_tag_no_ext Builtin.constr_ok.cs_tag in - let action_ok : Clam.lambda = - let constr_tid = transl_constr_type ok_tag obj_ty in - Lget_field - { - kind = Enum { tag = ok_tag }; - obj = - Lcast { expr = obj; target_type = Ref { tid = constr_tid } }; - index = 0; - tid = constr_tid; - } + { + params = Lst.map fn.params (fun p -> p.ty); + return = Mcore.type_of_expr fn.body; + }) in - let cases = [ (ok_tag, action_ok) ] in - let default : Clam.lambda = - let err_tag = Tag.of_core_tag_no_ext Builtin.constr_err.cs_tag in - let constr_tid = transl_constr_type err_tag obj_ty in - match handle_kind with - | Joinapply err_join -> - let err_value : Clam.lambda = - Lget_field + Ltype.FnSigHash.add type_defs.fn_sig_tbl sig_ tid; + Tid.Hash.add type_defs.defs tid + (Ltype.Ref_closure_abstract { fn_sig = sig_ }); + tid + in + let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in + (match name with + | Some name -> + Addr_table.add_local_fn_addr_and_type addr_tbl name address + abs_closure_ty + | None -> ()); + abs_closure_tid + : Tid.t) + in + let expr : Clam.lambda = + match x with + | Cexpr_const { c; ty = _ } -> Lconst c + | Cexpr_unit _ -> clam_unit + | Cexpr_var { id; ty; prim = _ } -> + let var = transl_ident id ty ~addr_tbl ~mtype_defs ~type_defs in + Lvar { var } + | Cexpr_and { lhs; rhs } -> + Lif + { + pred = go lhs; + ifso = go rhs; + ifnot = Lconst (C_bool false); + type_ = Ltype.i32_bool; + } + | Cexpr_or { lhs; rhs } -> + Lif + { + pred = go lhs; + ifso = Lconst (C_bool true); + ifnot = go rhs; + type_ = Ltype.i32_bool; + } + | Cexpr_prim { prim; args; ty } -> ( + let make_prim fn = + Clam.Lprim { fn; args = Lst.map args go } + [@@inline] + in + match prim with + | Parray_make -> assert false + | Pfixedarray_make { kind } -> + Lmake_array + { + kind; + tid = transl_type_as_named_exn ty; + elems = Lst.map args go; + } + | Pfixedarray_get_item { kind } -> ( + let arr_type = Mcore.type_of_expr (List.hd args) in + if arr_type = T_bytes then + match kind with + | Safe -> + Lprim + { + fn = Pgetbytesitem { safe = true }; + args = Lst.map args go; + } + | Unsafe -> + Lprim + { + fn = Pgetbytesitem { safe = false }; + args = Lst.map args go; + } + | Rev_unsafe -> assert false + else + let extra : Clam.get_item_extra = + let elem = Mtype.get_fixedarray_elem_exn arr_type in + if Mtype.is_uninit elem then Need_non_null_cast + else if elem = T_int16 then Need_signed_info { signed = true } + else if elem = T_uint16 then + Need_signed_info { signed = false } + else No_extra + in + match[@warning "-fragile-match"] Lst.map args go with + | [ arr; index ] -> + Larray_get_item + { + arr; + index; + tid = transl_type_as_named_exn arr_type; + kind; + extra; + } + | _ -> assert false) + | Pfixedarray_set_item { set_kind } -> ( + let arr_type = Mcore.type_of_expr (List.hd args) in + match[@warning "-fragile-match"] Lst.map args go with + | arr :: index :: item -> + let item = + match item with + | [] -> None + | item :: [] -> Some item + | _ -> assert false + in + Larray_set_item + { + tid = transl_type_as_named_exn arr_type; + kind = set_kind; + arr; + index; + item; + } + | _ -> assert false) + | Prefeq -> + let mty = Mcore.type_of_expr (List.hd args) in + let lty = transl_type mty in + make_prim + (match lty with + | I32 _ -> Pcomparison { operator = Eq; operand_type = I32 } + | I64 -> Pcomparison { operator = Eq; operand_type = I64 } + | F32 -> Pcomparison { operator = Eq; operand_type = F32 } + | F64 -> Pcomparison { operator = Eq; operand_type = F64 } + | Ref_string when !Basic_config.use_js_builtin_string -> + Pstringequal + | Ref_nullable { tid } + when !Basic_config.use_js_builtin_string + && Tid.equal tid Ltype.tid_string -> + Pstringequal + | Ref _ | Ref_lazy_init _ | Ref_nullable _ | Ref_extern + | Ref_string | Ref_bytes | Ref_func | Ref_any -> + Prefeq) + | Pcast { kind } -> ( + match[@warning "-fragile-match"] args with + | arg :: [] -> ( + match kind with + | Constr_to_enum | Make_newtype -> go arg + | Unfold_rec_newtype | Enum_to_constr -> + let target_type = transl_type ty in + Lcast { expr = go arg; target_type }) + | _ -> assert false) + | Penum_field { index; tag = _ } -> ( + let tid = + Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) + in + match[@warning "-fragile-match"] Lst.map args go with + | obj :: [] -> Lget_field { kind = Enum; obj; index; tid } + | _ -> assert false) + | Pset_enum_field { index; tag = _ } -> ( + let tid = + Name_mangle.make_type_name (Mcore.type_of_expr (List.hd args)) + in + match[@warning "-fragile-match"] Lst.map args go with + | [ obj; field ] -> + Lset_field { kind = Enum; obj; field; index; tid } + | _ -> assert false) + | Pcatch -> ( + match[@warning "-fragile-match"] args with + | [ body; on_exception ] -> + Lcatch + { + body = go body; + on_exception = go on_exception; + type_ = transl_type (Mcore.type_of_expr body); + } + | _ -> assert false) + | Pmake_value_or_error { tag } -> + let tag = Tag.of_core_tag_no_ext tag in + let t = transl_constr_type tag ty in + Lallocate + { kind = Enum { tag }; tid = t; fields = Lst.map args go } + | Pnull when !Basic_config.use_js_builtin_string -> ( + let ty = transl_type ty in + match ty with + | Ref_nullable { tid } when Tid.equal tid Ltype.tid_string -> + make_prim Pnull_string_extern + | _ -> make_prim Pnull) + | Pcall_object_method { method_index; _ } -> ( + let method_ty = + transl_type + (T_func + { params = Lst.map args Mcore.type_of_expr; return = ty }) + in + match[@warning "-fragile-match"] args with + | self :: args -> + bind self (fun obj -> + let args = Lst.map args go in + Lapply + { + fn = Object { obj; method_index; method_ty }; + args; + prim = None; + }) + | _ -> assert false) + | _ -> make_prim prim) + | Cexpr_let { name; rhs; body; ty = _ } -> + let ty_rhs = Mcore.type_of_expr rhs in + let name = Ident.of_core_ident ~ty:(transl_type ty_rhs) name in + Llet { name; e = go rhs; body = go body } + | Cexpr_letfn { name; fn; body; kind; ty } -> ( + match kind with + | Nonrec -> + let name_hint = append_name_hint name in + let address = Fn_address.fresh (name_hint ^ ".fn") in + if Core_ident.Hashset.mem local_non_well_knowns name then + let abs_closure_tid = + handle_abstract_closure_type ~name:(Some name) fn address + in + let closure, ty = + closure_of_fn ~addr_tbl ~type_defs ~object_methods ~address + ~name_hint ~mtype_defs ~self:None ~abs_closure_tid fn + in + let body = go body in + let name = Ident.of_core_ident name ~ty in + Llet { name; e = Lclosure closure; body } + else + let tuple, binder = + well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs + ~object_methods ~name_hint ~address ~self:name ~is_rec:false + fn + in + let body = go body in + Llet { name = binder; e = tuple; body } + | Rec -> + let name_hint = append_name_hint name in + let address = Fn_address.fresh (name_hint ^ ".fn") in + if Core_ident.Hashset.mem local_non_well_knowns name then + let abs_closure_tid = + handle_abstract_closure_type ~name:(Some name) fn address + in + let closure, ty = + closure_of_fn ~addr_tbl ~type_defs ~object_methods ~name_hint + ~mtype_defs ~self:(Some name) ~address ~abs_closure_tid fn + in + let body = go body in + let name = Ident.of_core_ident name ~ty in + Llet { name; e = Lclosure closure; body } + else + let tuple, binder = + well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs + ~object_methods ~name_hint ~address ~self:name ~is_rec:true + fn + in + let body = go body in + Llet { name = binder; e = tuple; body } + | Tail_join | Nontail_join -> + let name = Join.of_core_ident name in + let params = transl_params ~mtype_defs ~type_defs fn.params in + let join_body = go fn.body in + let body = go body in + let kind : Clam.join_kind = + match kind with + | Tail_join -> Tail_join + | Nontail_join -> Nontail_join + | _ -> assert false + in + let type_ = [ transl_type ty ] in + Ljoinlet { name; params; e = join_body; body; kind; type_ }) + | Cexpr_function { func; is_raw_; ty = _ } -> + let address = Fn_address.fresh (name_hint ^ ".fn") in + if is_raw_ then ( + let params = transl_params ~mtype_defs ~type_defs func.params in + let return = Mcore.type_of_expr func.body in + let return_type_ = + if return = T_unit then [] else [ transl_type return ] + in + let body = go func.body in + new_top + { + binder = address; + fn_kind_ = Top_private; + tid = None; + fn = { params; body; return_type_ }; + }; + Lget_raw_func address) + else + let abs_closure_tid = + handle_abstract_closure_type ~name:None func address + in + let closure, _ = + closure_of_fn ~addr_tbl ~type_defs ~mtype_defs ~object_methods + ~name_hint ~address ~self:None ~abs_closure_tid func + in + Lclosure closure + | Cexpr_apply { func; args; kind = Join; ty = _; prim = _ } -> + let name = Join.of_core_ident func in + let args = Lst.map args go in + Ljoinapply { name; args } + | Cexpr_apply + { func; args = core_args; kind = Normal { func_ty }; ty = _; prim } + -> ( + let args = Lst.map core_args go in + match Addr_table.find_opt addr_tbl func with + | Some (Toplevel { addr; _ }) -> + let prim : Clam.intrinsic option = + match prim with + | Some (Pintrinsic FixedArray_copy) -> ( + match[@warning "-fragile-match"] core_args with + | dst :: _ :: src :: _ -> + let dst_tid = + transl_type_as_named_exn (Mcore.type_of_expr dst) + in + let src_tid = + transl_type_as_named_exn (Mcore.type_of_expr src) + in + Some (FixedArray_copy { src_tid; dst_tid }) + | _ -> assert false) + | Some (Pintrinsic FixedArray_fill) -> ( + match[@warning "-fragile-match"] core_args with + | arr :: _ -> + let arr_tid = + transl_type_as_named_exn (Mcore.type_of_expr arr) + in + Some (FixedArray_fill { tid = arr_tid }) + | _ -> assert false) + | Some (Pintrinsic Char_to_string) + when !Basic_config.use_js_builtin_string -> + Some Char_to_string + | Some (Pintrinsic _) -> None + | Some _ -> assert false + | None -> None + in + Lapply { fn = StaticFn addr; args; prim } + | Some (Local (addr, self_ty)) -> + let self = Ident.of_core_ident func ~ty:self_ty in + Lapply + { + fn = StaticFn addr; + args = Lvar { var = self } :: args; + prim = None; + } + | None -> + let fn = Ident.of_core_ident ~ty:(transl_type func_ty) func in + Lapply { fn = Dynamic fn; args; prim = None }) + | Cexpr_object { self; methods_key; ty = _ } -> + let ({ trait; type_ } : Object_util.object_key) = methods_key in + let tid = Tid.concrete_object_type ~trait ~type_name:type_ in + let methods = Object_util.Hash.find_exn object_methods methods_key in + Lallocate { tid; kind = Object { methods }; fields = [ go self ] } + | Cexpr_letrec { bindings; body; ty = _ } -> + let addresses = + Lst.map bindings (fun (name, fn) -> + let address = Fn_address.fresh (append_name_hint name ^ ".fn") in + if Core_ident.Hashset.mem local_non_well_knowns name then + let abs_closure_tid = + handle_abstract_closure_type ~name:(Some name) fn address + in + (address, Some abs_closure_tid) + else + let ty = Ltype.Ref { tid = Tid.capture_of_function address } in + Addr_table.add_local_fn_addr_and_type addr_tbl name address ty; + (address, None)) + in + let fns, names = + Lst.split_map2 bindings addresses (fun (name, fn) -> + fun (address, abs_closure_tid_opt) -> + if Core_ident.Hashset.mem local_non_well_knowns name then + let abs_closure_tid = Option.get abs_closure_tid_opt in + let closure, ty = + closure_of_fn ~addr_tbl ~type_defs ~mtype_defs + ~object_methods ~address + ~name_hint:(append_name_hint name) ~self:(Some name) + ~abs_closure_tid fn + in + let self = Ident.of_core_ident name ~ty in + (closure, self) + else + well_known_closure_of_mut_rec_fn ~addr_tbl ~type_defs + ~mtype_defs ~object_methods ~address + ~name_hint:(append_name_hint name) ~self:name fn) + in + Lletrec { names; fns; body = go body } + | Cexpr_constr { tag; args; ty } -> + let t = transl_constr_type tag ty in + Lallocate { kind = Enum { tag }; tid = t; fields = Lst.map args go } + | Cexpr_tuple { exprs; ty } -> + let t = transl_type_as_named_exn ty in + Lallocate { kind = Tuple; tid = t; fields = Lst.map exprs go } + | Cexpr_record { fields; ty } -> + if fields = [] then clam_unit + else + let fields = Lst.map fields (fun { expr; _ } -> go expr) in + let t = transl_type_as_named_exn ty in + Lallocate { kind = Struct; tid = t; fields } + | Cexpr_record_update { record; fields; fields_num; ty } -> + let t = transl_type_as_named_exn ty in + bind record (fun record_id -> + let record_clam : Clam.lambda = Lvar { var = record_id } in + let get_new_field i = + match Lst.find_first fields (fun { pos; _ } -> pos = i) with + | Some { expr; _ } -> go expr + | None -> + Lget_field + { kind = Struct; obj = record_clam; index = i; tid = t } + in + Lallocate + { + kind = Struct; + tid = t; + fields = List.init fields_num get_new_field; + }) + | Cexpr_field { record; accessor; pos; ty = _ } -> + let obj = go record in + let t = transl_type_as_named_exn (Mcore.type_of_expr record) in + let kind : Clam.get_field_kind = + match accessor with + | Newtype -> assert false + | Label _ -> Struct + | Index _ -> Tuple + in + Lget_field { kind; obj; index = pos; tid = t } + | Cexpr_mutate { record; label = _; field; pos; ty = _ } -> + let t = transl_type_as_named_exn (Mcore.type_of_expr record) in + Lset_field + { + obj = go record; + field = go field; + index = pos; + tid = t; + kind = Struct; + } + | Cexpr_array { exprs; ty } -> + let tid = transl_type_as_named_exn ty in + Lmake_array { kind = EverySingleElem; tid; elems = Lst.map exprs go } + | Cexpr_assign { var; expr; ty = _ } -> + let var = + Ident.of_core_ident var ~ty:(transl_type (Mcore.type_of_expr expr)) + in + Lassign { var; e = go expr } + | Cexpr_sequence { exprs; last_expr; ty = _ } -> + let exprs = Lst.map exprs go in + let last_expr = go last_expr in + Lsequence { exprs; last_expr } + | Cexpr_if { cond; ifso; ifnot; ty } -> ( + let pred = go cond in + let ifso = go ifso in + match ifnot with + | Some ifnot -> + Lif { pred; ifso; ifnot = go ifnot; type_ = transl_type ty } + | None -> Lif { pred; ifso; ifnot = clam_unit; type_ = Ltype.i32_unit } + ) + | Cexpr_handle_error { obj; handle_kind = To_result; _ } -> go obj + | Cexpr_handle_error { obj; handle_kind; ty } -> + let obj_ty = Mcore.type_of_expr obj in + bind obj (fun obj_id -> + let obj : Clam.lambda = Lvar { var = obj_id } in + let ok_tag = Tag.of_core_tag_no_ext Builtin.constr_ok.cs_tag in + let action_ok : Clam.lambda = + let constr_tid = transl_constr_type ok_tag obj_ty in + Lget_field + { + kind = Enum; + obj = + Lcast + { expr = obj; target_type = Ref { tid = constr_tid } }; + index = 0; + tid = constr_tid; + } + in + let cases = [ (ok_tag, action_ok) ] in + let default : Clam.lambda = + let err_tag = Tag.of_core_tag_no_ext Builtin.constr_err.cs_tag in + let constr_tid = transl_constr_type err_tag obj_ty in + match handle_kind with + | Joinapply err_join -> + let err_value : Clam.lambda = + Lget_field + { + kind = Enum; + obj = + Lcast + { + expr = obj; + target_type = Ref { tid = constr_tid }; + }; + index = 0; + tid = constr_tid; + } + in + Ljoinapply + { + name = Join.of_core_ident err_join; + args = [ err_value ]; + } + | Return_err _ -> Lreturn obj + | To_result -> assert false + in + Lswitch { obj = obj_id; cases; default; type_ = transl_type ty }) + | Cexpr_switch_constr { obj; cases; default; ty } -> + let obj_ty = Mcore.type_of_expr obj in + bind obj (fun obj_id -> + let obj : Clam.lambda = Lvar { var = obj_id } in + let transl_action tag binder body = + (match binder with + | None -> go body + | Some binder -> + let constr_tid = transl_constr_type tag obj_ty in + Clam.Llet { - kind = Enum { tag = err_tag }; - obj = + name = + Ident.of_core_ident binder + ~ty:(Ref { tid = constr_tid }); + e = Lcast { expr = obj; target_type = Ref { tid = constr_tid }; }; - index = 0; - tid = constr_tid; + body = go body; } - in - Ljoinapply - { name = Join.of_core_ident err_join; args = [ err_value ] } - | Return_err _ -> Lreturn obj - | To_result -> assert false - in - Lswitch { obj = obj_id; cases; default; type_ = transl_type ty }) - | Cexpr_switch_constr { obj; cases; default; ty } -> - let obj_ty = Mcore.type_of_expr obj in - bind obj (fun obj_id -> - let obj : Clam.lambda = Lvar { var = obj_id } in - let transl_action tag binder body : Clam.lambda = - match binder with - | None -> go body - | Some binder -> - let constr_tid = transl_constr_type tag obj_ty in - Clam.Llet - { - name = - Ident.of_core_ident binder - ~ty:(Ref { tid = constr_tid }); - e = - Lcast - { expr = obj; target_type = Ref { tid = constr_tid } }; - body = go body; - } - [@@inline] - in - let cases, default = - Lst.fold_right cases - ([], Option.map go default) - (fun (tag, binder, action) (cases, default) -> - let action = transl_action tag binder action in - match default with - | Some _ -> ((tag, action) :: cases, default) - | None -> (cases, Some action)) - in - match (cases, default) with - | [], Some default -> default - | [], None -> Lprim { fn = Praise; args = [] } - | _ :: _, None -> assert false - | _, Some default -> - Lswitch { obj = obj_id; cases; default; type_ = transl_type ty }) - | Cexpr_switch_constant { obj; cases; default; ty } -> - bind obj (fun obj_id -> - let obj : Clam.lambda = Lvar { var = obj_id } in - match cases with - | (C_string _, _) :: _ -> - let cases = - Lst.map cases (fun (c, action) -> - match c with - | C_string s -> (s, go action) - | _ -> assert false) - in - Lswitchstring - { obj; cases; default = go default; type_ = transl_type ty } - | (C_int _, _) :: _ -> - let cases = - Lst.map cases (fun (c, action) -> - match c with - | C_int { v; repr = _ } -> (Int32.to_int v, go action) - | _ -> assert false) - in - Lswitchint - { - obj = obj_id; - cases; - default = go default; - type_ = transl_type ty; - } - | (c, _) :: _ -> - let default = go default in - let equal = - match c with - | C_char _ -> Primitive.equal_char - | C_int _ -> Primitive.equal_int - | C_int64 _ -> Primitive.equal_int64 - | C_uint _ -> Primitive.equal_uint - | C_uint64 _ -> Primitive.equal_uint64 - | C_float _ -> Primitive.equal_float - | C_double _ -> Primitive.equal_float64 - | C_bool _ -> Primitive.equal_bool - | C_bigint _ -> assert false - | C_string _ -> assert false - | C_bytes _ -> assert false - in - Lst.fold_right cases default (fun (c, action) rest -> - let pred : Clam.lambda = - Lprim { fn = equal; args = [ obj; Lconst c ] } - in - Lif - { - pred; - ifso = go action; - ifnot = rest; - type_ = transl_type ty; - }) - | [] -> go default) - | Cexpr_loop { params; body; args; label; ty } -> - let params = transl_params ~mtype_defs ~type_defs params in - let body = go body in - let args = Lst.map args go in - let type_ = transl_type ty in - Lloop { params; body; args; label; type_ } - | Cexpr_break { arg; label; ty = _ } -> - Lbreak { arg = Option.map go arg; label } - | Cexpr_continue { args; label; ty = _ } -> - Lcontinue { args = List.map go args; label } - | Cexpr_return { expr; return_kind; ty = _ } -> ( - match return_kind with - | Single_value -> Lreturn (go expr) - | Error_result { is_error; return_ty } -> - let tag = - Tag.of_core_tag_no_ext - (if is_error then Builtin.constr_err.cs_tag - else Builtin.constr_ok.cs_tag) - in - let t = transl_constr_type tag return_ty in - Lreturn - (Lallocate { kind = Enum { tag }; tid = t; fields = [ go expr ] }) - ) - in - if !Basic_config.debug then - let expr_loc = Mcore.loc_of_expr x in - Clam.event ~loc_:(Rloc.to_loc ~base:!base expr_loc) expr - else expr + : Clam.lambda) + [@@inline] + in + let cases, default = + Lst.fold_right cases + ([], Option.map go default) + (fun (tag, binder, action) -> + fun (cases, default) -> + let action = transl_action tag binder action in + match default with + | Some _ -> ((tag, action) :: cases, default) + | None -> (cases, Some action)) + in + match (cases, default) with + | [], Some default -> default + | [], None -> Lprim { fn = Ppanic; args = [] } + | _ :: _, None -> assert false + | _, Some default -> + Lswitch + { obj = obj_id; cases; default; type_ = transl_type ty }) + | Cexpr_switch_constant { obj; cases; default; ty } -> + bind obj (fun obj_id -> + let obj : Clam.lambda = Lvar { var = obj_id } in + match cases with + | (C_string _, _) :: _ -> + let cases = + Lst.map cases (fun (c, action) -> + match[@warning "-fragile-match"] c with + | C_string s -> (s, go action) + | _ -> assert false) + in + Lswitchstring + { obj; cases; default = go default; type_ = transl_type ty } + | (C_int _, _) :: _ -> + let cases = + Lst.map cases (fun (c, action) -> + match[@warning "-fragile-match"] c with + | C_int { v; repr = _ } -> (Int32.to_int v, go action) + | _ -> assert false) + in + Lswitchint + { + obj = obj_id; + cases; + default = go default; + type_ = transl_type ty; + } + | (c, _) :: _ -> + let default = go default in + let equal = + match c with + | C_char _ -> Primitive.equal_char + | C_int _ -> Primitive.equal_int + | C_byte _ -> Primitive.equal_int + | C_int64 _ -> Primitive.equal_int64 + | C_uint _ -> Primitive.equal_uint + | C_uint64 _ -> Primitive.equal_uint64 + | C_float _ -> Primitive.equal_float + | C_double _ -> Primitive.equal_float64 + | C_bool _ -> Primitive.equal_bool + | C_bigint _ -> assert false + | C_string _ -> assert false + | C_bytes _ -> Primitive.Pbytesequal + in + Lst.fold_right cases default (fun (c, action) -> + fun rest -> + let pred : Clam.lambda = + Lprim { fn = equal; args = [ obj; Lconst c ] } + in + Lif + { + pred; + ifso = go action; + ifnot = rest; + type_ = transl_type ty; + }) + | [] -> go default) + | Cexpr_loop { params; body; args; label; ty } -> + let params = transl_params ~mtype_defs ~type_defs params in + let body = go body in + let args = Lst.map args go in + let type_ = transl_type ty in + Lloop { params; body; args; label; type_ } + | Cexpr_break { arg; label; ty = _ } -> + Lbreak { arg = Option.map go arg; label } + | Cexpr_continue { args; label; ty = _ } -> + Lcontinue { args = Lst.map args go; label } + | Cexpr_return { expr; return_kind; ty = _ } -> ( + match return_kind with + | Single_value -> Lreturn (go expr) + | Error_result { is_error; return_ty } -> + let tag = + Tag.of_core_tag_no_ext + (if is_error then Builtin.constr_err.cs_tag + else Builtin.constr_ok.cs_tag) + in + let t = transl_constr_type tag return_ty in + Lreturn + (Lallocate { kind = Enum { tag }; tid = t; fields = [ go expr ] }) + ) + in + if !Basic_config.debug then + let expr_loc = Mcore.loc_of_expr x in + Clam.event ~loc_:(Rloc.to_loc ~base:!base expr_loc) expr + else expr + : Clam.lambda) and closure_of_fn ~mtype_defs ~addr_tbl ~type_defs ~object_methods ~name_hint ~(address : Fn_address.t) ~(self : Core_ident.t option) - ~(abs_closure_tid : Tid.t) (fn : Mcore.fn) : Clam.closure * Ltype.t = - let exclude = - match self with - | Some self -> Core_ident.Set.singleton self - | None -> Core_ident.Set.empty - in - let fvs = - Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - [ - Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body); - ] - in - let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in - match (fvs, self) with - | [], None -> - let env_id = Ident.fresh ~ty:abs_closure_ty "*env" in - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - ( { captures = fvs; address = Normal address; tid = abs_closure_tid }, - abs_closure_ty ) - | _ -> - let closure_cap_tid = Tid.capture_of_function address in - let closure_type_def = - Ltype.Ref_closure - { - fn_sig_tid = abs_closure_tid; - captures = Lst.map fvs Ident.get_type; - } - in - let closure_ty = Ltype.Ref { tid = closure_cap_tid } in - Tid.Hash.add type_defs.defs closure_cap_tid closure_type_def; - let self = - match self with - | Some self -> Some (Ident.of_core_ident self ~ty:abs_closure_ty) - | None -> None - in - let env_id = Ident.fresh ~ty:abs_closure_ty "*env" in - let env = Clam.Lvar { var = env_id } in - let casted_env_id = Ident.fresh "*casted_env" ~ty:closure_ty in - let casted_env = Clam.Lvar { var = casted_env_id } in - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body_with_captures = - Lst.fold_left_with_offset fvs body 0 (fun fv rest i -> - let rhs = - Clam.Lclosure_field - { obj = casted_env; index = i; tid = closure_cap_tid } - in - let rhs : Clam.lambda = - if Ltype_util.is_non_nullable_ref_type (Ident.get_type fv) then - Lprim { fn = Pas_non_null; args = [ rhs ] } - else rhs - in - Clam.Llet { name = fv; e = rhs; body = rest }) - in - let body_with_cast = - Clam.Llet - { - name = casted_env_id; - e = - Lcast { expr = env; target_type = Ref { tid = closure_cap_tid } }; - body = body_with_captures; - } - in - let body = - match self with - | Some self -> Clam.Llet { name = self; e = env; body = body_with_cast } - | None -> body_with_cast - in - let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - ( { captures = fvs; address = Normal address; tid = closure_cap_tid }, - abs_closure_ty ) + ~(abs_closure_tid : Tid.t) (fn : Mcore.fn) = + (let exclude = + match self with + | Some self -> Core_ident.Set.singleton self + | None -> Core_ident.Set.empty + in + let fvs = + Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id -> + fun mty -> + fun acc -> transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) + in + let params = transl_params ~mtype_defs ~type_defs fn.params in + let return_type_ = + [ + Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs + (Mcore.type_of_expr fn.body); + ] + in + let abs_closure_ty = Ltype.Ref { tid = abs_closure_tid } in + match fvs with + | [] -> + let env_id = Ident.fresh ~ty:abs_closure_ty "*env" in + let body = + transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods + fn.body + in + let body = + match self with + | Some self -> + let name = Ident.of_core_ident self ~ty:abs_closure_ty in + let env = Clam.Lvar { var = env_id } in + Clam.Llet { name; e = env; body } + | None -> body + in + let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in + new_top + { + binder = address; + fn_kind_ = Clam.Top_private; + fn; + tid = Some (Tid.code_pointer_of_closure abs_closure_tid); + }; + ( { captures = fvs; address = Normal address; tid = abs_closure_tid }, + abs_closure_ty ) + | _ -> + let closure_cap_tid = Tid.capture_of_function address in + let closure_type_def = + Ltype.Ref_closure + { + fn_sig_tid = abs_closure_tid; + captures = Lst.map fvs Ident.get_type; + } + in + let closure_ty = Ltype.Ref { tid = closure_cap_tid } in + Tid.Hash.add type_defs.defs closure_cap_tid closure_type_def; + let self = + match self with + | Some self -> Some (Ident.of_core_ident self ~ty:abs_closure_ty) + | None -> None + in + let env_id = Ident.fresh ~ty:abs_closure_ty "*env" in + let env = Clam.Lvar { var = env_id } in + let casted_env_id = Ident.fresh "*casted_env" ~ty:closure_ty in + let casted_env = Clam.Lvar { var = casted_env_id } in + let body = + transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods + fn.body + in + let body_with_captures = + Lst.fold_left_with_offset fvs body 0 (fun fv -> + fun rest -> + fun i -> + let rhs = + Clam.Lclosure_field + { obj = casted_env; index = i; tid = closure_cap_tid } + in + let rhs : Clam.lambda = + if Ltype_util.is_non_nullable_ref_type (Ident.get_type fv) then + Lprim { fn = Pas_non_null; args = [ rhs ] } + else rhs + in + Clam.Llet { name = fv; e = rhs; body = rest }) + in + let body_with_cast = + Clam.Llet + { + name = casted_env_id; + e = + Lcast { expr = env; target_type = Ref { tid = closure_cap_tid } }; + body = body_with_captures; + } + in + let body = + match self with + | Some self -> + Clam.Llet { name = self; e = env; body = body_with_cast } + | None -> body_with_cast + in + let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in + new_top + { + binder = address; + fn_kind_ = Clam.Top_private; + fn; + tid = Some (Tid.code_pointer_of_closure abs_closure_tid); + }; + ( { captures = fvs; address = Normal address; tid = closure_cap_tid }, + abs_closure_ty ) + : Clam.closure * Ltype.t) and well_known_closure_of_fn ~mtype_defs ~addr_tbl ~type_defs ~object_methods ~name_hint ~(address : Fn_address.t) ~(self : Core_ident.t) ~(is_rec : bool) - (fn : Mcore.fn) : Clam.lambda * Ident.t = - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - [ - Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body); - ] - in - let exclude = - if is_rec then Core_ident.Set.singleton self else Core_ident.Set.empty - in - let fvs = - Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let insert_let_self_for_recursive_case self rhs ty body = - if is_rec then - let self = Ident.of_core_ident ~ty self in - Clam.Llet { name = self; e = rhs; body } - else body - [@@inline] - in - let update_type_table ty = - Addr_table.add_local_fn_addr_and_type addr_tbl self address ty - [@@inline] - in - match fvs with - | [] -> - let env = Ident.fresh ~ty:I32_Unit "*env" in - Addr_table.add_local_fn_addr_and_type addr_tbl self address I32_Unit; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - insert_let_self_for_recursive_case self clam_unit I32_Unit body - in - let fn : Clam.fn = { params = env :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - (clam_unit, Ident.of_core_ident ~ty:I32_Unit self) - | fv :: [] -> - let fv_ty = Ident.get_type fv in - let fv_var = Clam.Lvar { var = fv } in - update_type_table fv_ty; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - if is_rec then - let self = Ident.of_core_ident ~ty:I32_Unit self in - fix_single_var ~self ~replace:fv body - else body - in - let fn : Clam.fn = { params = fv :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - (fv_var, Ident.of_core_ident self ~ty:fv_ty) - | _ :: _ :: _ -> - let ty_tuple_def = - Ltype.Ref_struct - { fields = Lst.map fvs (fun id -> (Ident.get_type id, false)) } - in - let ty_tuple_tid = Tid.capture_of_function address in - Basic_ty_ident.Hash.add type_defs.defs ty_tuple_tid ty_tuple_def; - let ty_tuple = Ltype.Ref { tid = ty_tuple_tid } in - let env_id = Ident.fresh ~ty:ty_tuple "*env" in - let env = Clam.Lvar { var = env_id } in - update_type_table ty_tuple; - let body = - transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods - fn.body - in - let body = - Lst.fold_left_with_offset fvs body 0 (fun fv rest index -> - let rhs = - Clam.Lget_field - { kind = Tuple; obj = env; index; tid = ty_tuple_tid } - in - Clam.Llet { name = fv; e = rhs; body = rest }) - in - let body = insert_let_self_for_recursive_case self env ty_tuple body in - let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - ( Lallocate - { - kind = Struct; - tid = ty_tuple_tid; - fields = Lst.map fvs (fun fv -> Clam.Lvar { var = fv }); - }, - Ident.of_core_ident ~ty:ty_tuple self ) + (fn : Mcore.fn) = + (let params = transl_params ~mtype_defs ~type_defs fn.params in + let return_type_ = + [ + Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs + (Mcore.type_of_expr fn.body); + ] + in + let exclude = + if is_rec then Core_ident.Set.singleton self else Core_ident.Set.empty + in + let fvs = + Core_ident.Map.fold (Mcore_util.free_vars ~exclude fn) [] (fun id -> + fun mty -> + fun acc -> transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) + in + let insert_let_self_for_recursive_case self rhs ty body = + if is_rec then + let self = Ident.of_core_ident ~ty self in + Clam.Llet { name = self; e = rhs; body } + else body + [@@inline] + in + let update_type_table ty = + Addr_table.add_local_fn_addr_and_type addr_tbl self address ty + [@@inline] + in + match fvs with + | [] -> + let env = Ident.fresh ~ty:Ltype.i32_unit "*env" in + Addr_table.add_local_fn_addr_and_type addr_tbl self address + Ltype.i32_unit; + let body = + transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods + fn.body + in + let body = + insert_let_self_for_recursive_case self clam_unit Ltype.i32_unit body + in + let fn : Clam.fn = { params = env :: params; body; return_type_ } in + new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; + (clam_unit, Ident.of_core_ident ~ty:Ltype.i32_unit self) + | fv :: [] -> + let fv_ty = Ident.get_type fv in + let fv_var = Clam.Lvar { var = fv } in + update_type_table fv_ty; + let body = + transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods + fn.body + in + let body = + if is_rec then + let self = Ident.of_core_ident ~ty:Ltype.i32_unit self in + fix_single_var ~self ~replace:fv body + else body + in + let fn : Clam.fn = { params = fv :: params; body; return_type_ } in + new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; + (fv_var, Ident.of_core_ident self ~ty:fv_ty) + | _ :: _ :: _ -> + let ty_tuple_def = + Ltype.Ref_struct + { fields = Lst.map fvs (fun id -> (Ident.get_type id, false)) } + in + let ty_tuple_tid = Tid.capture_of_function address in + Basic_ty_ident.Hash.add type_defs.defs ty_tuple_tid ty_tuple_def; + let ty_tuple = Ltype.Ref { tid = ty_tuple_tid } in + let env_id = Ident.fresh ~ty:ty_tuple "*env" in + let env = Clam.Lvar { var = env_id } in + update_type_table ty_tuple; + let body = + transl_expr ~mtype_defs ~addr_tbl ~name_hint ~type_defs ~object_methods + fn.body + in + let body = + Lst.fold_left_with_offset fvs body 0 (fun fv -> + fun rest -> + fun index -> + let rhs = + Clam.Lget_field + { kind = Tuple; obj = env; index; tid = ty_tuple_tid } + in + Clam.Llet { name = fv; e = rhs; body = rest }) + in + let body = insert_let_self_for_recursive_case self env ty_tuple body in + let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in + new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; + ( Lallocate + { + kind = Struct; + tid = ty_tuple_tid; + fields = Lst.map fvs (fun fv -> Clam.Lvar { var = fv }); + }, + Ident.of_core_ident ~ty:ty_tuple self ) + : Clam.lambda * Ident.t) and well_known_closure_of_mut_rec_fn ~mtype_defs ~addr_tbl ~type_defs - ~object_methods ~self ~name_hint ~address (fn : Mcore.fn) : - Clam.closure * Ident.t = - let fvs = - Core_ident.Map.fold - (Mcore_util.free_vars ~exclude:(Core_ident.Set.singleton self) fn) - [] - (fun id mty acc -> - transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) - in - let params = transl_params ~mtype_defs ~type_defs fn.params in - let return_type_ = - [ - Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs - (Mcore.type_of_expr fn.body); - ] - in - let tid = Tid.capture_of_function address in - let closure_type = - Ltype.Ref_late_init_struct { fields = Lst.map fvs Ident.get_type } - in - Tid.Hash.add type_defs.defs tid closure_type; - let name_hint = - (name_hint ^ "." ^ Core_ident.base_name self : Stdlib.String.t) - in - let ty : Ltype.t = Ref { tid } in - let self = Ident.of_core_ident ~ty self in - let body = - transl_expr ~mtype_defs ~addr_tbl ~type_defs ~name_hint ~object_methods - fn.body - in - let env_id = Ident.fresh ~ty "*env" in - let env = Clam.Lvar { var = env_id } in - let body = - Lst.fold_left_with_offset fvs body 0 (fun fv rest index -> - let rhs = Clam.Lget_field { obj = env; index; tid; kind = Tuple } in - let rhs : Clam.lambda = - if Ltype_util.is_non_nullable_ref_type (Ident.get_type fv) then - Lprim { fn = Pas_non_null; args = [ rhs ] } - else rhs - in - Clam.Llet { name = fv; e = rhs; body = rest }) - in - let body = fix_single_var ~self ~replace:env_id body in - let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in - new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; - ({ captures = fvs; address = Well_known_mut_rec; tid }, self) + ~object_methods ~self ~name_hint ~address (fn : Mcore.fn) = + (let fvs = + Core_ident.Map.fold + (Mcore_util.free_vars ~exclude:(Core_ident.Set.singleton self) fn) + [] + (fun id -> + fun mty -> + fun acc -> transl_ident id mty ~addr_tbl ~mtype_defs ~type_defs :: acc) + in + let params = transl_params ~mtype_defs ~type_defs fn.params in + let return_type_ = + [ + Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs + (Mcore.type_of_expr fn.body); + ] + in + let tid = Tid.capture_of_function address in + let closure_type = + Ltype.Ref_late_init_struct { fields = Lst.map fvs Ident.get_type } + in + Tid.Hash.add type_defs.defs tid closure_type; + let name_hint = + (name_hint ^ "." ^ Core_ident.base_name self : Stdlib.String.t) + in + let ty : Ltype.t = Ref { tid } in + let self = Ident.of_core_ident ~ty self in + let body = + transl_expr ~mtype_defs ~addr_tbl ~type_defs ~name_hint ~object_methods + fn.body + in + let env_id = Ident.fresh ~ty "*env" in + let env = Clam.Lvar { var = env_id } in + let body = + Lst.fold_left_with_offset fvs body 0 (fun fv -> + fun rest -> + fun index -> + let rhs = Clam.Lget_field { obj = env; index; tid; kind = Tuple } in + let rhs : Clam.lambda = + if Ltype_util.is_non_nullable_ref_type (Ident.get_type fv) then + Lprim { fn = Pas_non_null; args = [ rhs ] } + else rhs + in + Clam.Llet { name = fv; e = rhs; body = rest }) + in + let body = fix_single_var ~self ~replace:env_id body in + let fn : Clam.fn = { params = env_id :: params; body; return_type_ } in + new_top { binder = address; fn_kind_ = Clam.Top_private; fn; tid = None }; + ({ captures = fvs; address = Well_known_mut_rec; tid }, self) + : Clam.closure * Ident.t) let make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods (fn_address : Fn_address.t) params (body : [ `Clam of Clam.lambda | `Core of Mcore.expr ]) return_type_ - ~export_info_ : Clam.top_func_item = - let fn_kind_ = - match export_info_ with - | Some export_name -> Clam.Top_pub export_name - | None -> Clam.Top_private - in - let fn_body = - match body with - | `Core body -> - transl_expr ~addr_tbl ~type_defs ~object_methods - ~name_hint:(Fn_address.to_string fn_address) - ~mtype_defs body - | `Clam body -> body - in - { - binder = fn_address; - fn_kind_; - fn = { params; body = fn_body; return_type_ }; - tid = None; - } + ~export_info_ = + (let fn_kind_ = + match export_info_ with + | Some export_name -> Clam.Top_pub export_name + | None -> Clam.Top_private + in + let fn_body = + match body with + | `Core body -> + transl_expr ~addr_tbl ~type_defs ~object_methods + ~name_hint:(Fn_address.to_string fn_address) + ~mtype_defs body + | `Clam body -> body + in + { + binder = fn_address; + fn_kind_; + fn = { params; body = fn_body; return_type_ }; + tid = None; + } + : Clam.top_func_item) let make_top_closure_item (addr : Fn_address.t) (params : Ident.t list) - (return_type_ : Ltype.t list) ~(closure_ty : Ltype.t) : Clam.top_func_item = - let closure_address = Fn_address.make_closure_wrapper addr in - let closure_body = - let args = Lst.map params (fun p -> Clam.Lvar { var = p }) in - Clam.Lapply { fn = Clam.StaticFn addr; args; prim = None } - in - let env_id = Ident.fresh ~ty:closure_ty "*env" in - { - binder = closure_address; - fn_kind_ = Top_private; - fn = { params = env_id :: params; body = closure_body; return_type_ }; - tid = None; - } + (return_type_ : Ltype.t list) ~(closure_ty : Ltype.t) = + (let closure_address = Fn_address.make_closure_wrapper addr in + let closure_body = + let args = Lst.map params (fun p -> Clam.Lvar { var = p }) in + Clam.Lapply { fn = Clam.StaticFn addr; args; prim = None } + in + let env_id = Ident.fresh ~ty:closure_ty "*env" in + match[@warning "-fragile-match"] closure_ty with + | Ref { tid } -> + { + binder = closure_address; + fn_kind_ = Top_private; + fn = { params = env_id :: params; body = closure_body; return_type_ }; + tid = Some (Tid.code_pointer_of_closure tid); + } + | _ -> assert false + : Clam.top_func_item) let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods - ~abstract_obj_tid ~concrete_obj_tid ~self_lty ~trait ~method_index + ~abstract_obj_tid ~concrete_obj_tid ~self_lty ~method_index ~trait + ~number_of_methods ({ method_id; method_prim; method_ty } : Object_util.object_method_item) = let params_ty, ret_ty = match method_ty with | T_func { params; return } -> (params, return) - | T_char | T_bool | T_int | T_uint | T_unit | T_byte | T_string | T_bytes - | T_tuple _ | T_fixedarray _ | T_trait _ | T_constr _ | T_int64 | T_uint64 - | T_float | T_double | T_any _ | T_optimized_option _ | T_maybe_uninit _ - | T_error_value_result _ -> - assert false + | T_maybe_uninit _ -> assert false + | T_optimized_option _ -> assert false + | T_double -> assert false + | T_uint64 -> assert false + | T_constr _ -> assert false + | T_fixedarray _ -> assert false + | T_bytes -> assert false + | T_uint16 -> assert false + | T_byte -> assert false + | T_uint -> assert false + | T_bool -> assert false + | T_char -> assert false + | T_int -> assert false + | T_unit -> assert false + | T_int16 -> assert false + | T_string -> assert false + | T_tuple _ -> assert false + | T_trait _ -> assert false + | T_int64 -> assert false + | T_float -> assert false + | T_any _ -> assert false + | T_raw_func _ -> assert false + | T_error_value_result _ -> assert false in match[@warning "-fragile-match"] params_ty with | self_ty :: params_ty -> ( @@ -989,8 +1078,8 @@ let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods let body = let args = Mcore.var ~prim:None ~ty:self_ty self_id - :: Lst.map2 params_id params_ty (fun id ty -> - Mcore.var ~prim:None ~ty id) + :: Lst.map2 params_id params_ty (fun id -> + fun ty -> Mcore.var ~prim:None ~ty id) in match method_prim with | Some (Pintrinsic _) | None -> @@ -1012,7 +1101,7 @@ let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods { name = self_id; e = - Lclosure_field + Lget_field { obj = Lcast @@ -1022,6 +1111,7 @@ let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods }; tid = concrete_obj_tid; index = 0; + kind = Object { number_of_methods }; }; body; } @@ -1030,11 +1120,12 @@ let make_object_wrapper ~mtype_defs ~type_defs ~addr_tbl ~object_methods { params = obj_id - :: Lst.map2 params_ty params_id (fun ty id -> - let ty = - Transl_mtype.mtype_to_ltype ~type_defs ~mtype_defs ty - in - Ident.of_core_ident ~ty id); + :: Lst.map2 params_ty params_id (fun ty -> + fun id -> + let ty = + Transl_mtype.mtype_to_ltype ~type_defs ~mtype_defs ty + in + Ident.of_core_ident ~ty id); return_type_ = [ Transl_mtype_gc.mtype_to_ltype ~type_defs ~mtype_defs ret_ty ]; body; @@ -1066,10 +1157,23 @@ let transl_top_func ~(mtype_defs : Mtype.defs) ~(addr_tbl : Addr_table.t) new_top fn_item | _ -> assert false -let sequence (a : Clam.lambda) (b : Clam.lambda) ~expr1_type_ = - if Basic_prelude.phys_equal (Clam_util.no_located b) clam_unit then a - else if Basic_prelude.phys_equal (Clam_util.no_located a) clam_unit then b - else Lsequence { expr1 = a; expr2 = b; expr1_type_ } +let sequence (exprs : Clam.lambda list) (last_expr : Clam.lambda) = + let is_unit x = Basic_prelude.phys_equal (Clam_util.no_located x) clam_unit in + let rec loop rev_items = function + | [] -> ( + match rev_items with + | prev_expr :: rev_items when is_unit last_expr -> + if rev_items = [] then prev_expr + else + Clam.Lsequence + { exprs = List.rev rev_items; last_expr = prev_expr } + | _ :: _ -> Lsequence { exprs = List.rev rev_items; last_expr } + | [] -> last_expr) + | expr :: remain -> + if is_unit expr then loop rev_items remain + else loop (expr :: rev_items) remain + in + loop [] exprs type translate_result = { globals : (Ident.t * Constant.t option) list; @@ -1079,95 +1183,98 @@ type translate_result = { let transl_top_item ~(mtype_defs : Mtype.defs) ~(addr_tbl : Addr_table.t) ~(type_defs : Ltype.type_defs_with_context) ~object_methods - (top : Mcore.top_item) (acc : translate_result) : translate_result = - match top with - | Ctop_expr { expr; loc_ } -> - let name_hint = "*init*" in - base := loc_; - let clam_expr = - transl_expr ~mtype_defs ~name_hint ~addr_tbl ~type_defs ~object_methods - expr - in - let expr1_type_ = - Transl_mtype.mtype_to_ltype (Mcore.type_of_expr expr) ~type_defs - ~mtype_defs - in - { acc with init = sequence clam_expr acc.init ~expr1_type_ } - | Ctop_let { binder; expr; is_pub_ = _; loc_ } -> ( - base := loc_; - match expr with - | Cexpr_function { func; ty = _ } -> - transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func - binder None; - acc - | _ -> ( - let ty = Mcore.type_of_expr expr in - let name = - Ident.of_core_ident - ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty) - binder - in - let expr = - transl_expr ~name_hint:(Ident.to_string name) ~mtype_defs ~addr_tbl - ~type_defs ~object_methods expr - in - match Clam_util.no_located expr with - | Lconst - ((C_bool _ | C_char _ | C_int _ | C_int64 _ | C_double _) as c) -> - { acc with globals = (name, Some c) :: acc.globals } - | Lconst (C_string _ as c) when !Basic_config.use_js_builtin_string -> - { acc with globals = (name, Some c) :: acc.globals } - | _ -> - { - acc with - globals = (name, None) :: acc.globals; - init = Llet { name; e = expr; body = acc.init }; - })) - | Ctop_fn { binder; func; export_info_; loc_ } -> - base := loc_; - transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func - binder export_info_; - acc - | Ctop_stub { binder; func_stubs; params_ty; return_ty; export_info_; loc_ } - -> ( - base := loc_; - match[@warning "-fragile-match"] Addr_table.find_exn addr_tbl binder with - | Toplevel { addr; params; return; _ } -> - let args = - Lst.map2 params params_ty (fun id ty : Clam.lambda -> - let var : Clam.lambda = Lvar { var = id } in - if Mtype.is_func ty then - Lprim { fn = Pclosure_to_extern_ref; args = [ var ] } - else var) - in - let params_ty = - Lst.map2 params params_ty (fun id ty : Ltype.t -> - if Mtype.is_func ty then Ref_extern else Ident.get_type id) - in - let return_ty = - match return_ty with - | None -> None - | Some _ -> ( - match[@warning "-fragile-match"] return with - | return_ltype :: [] -> Some return_ltype - | _ -> assert false) - in - let body : Clam.lambda = - Levent - { - expr = - Lstub_call { fn = func_stubs; args; params_ty; return_ty }; - loc_; - } - in - let ret = Option.value return_ty ~default:I32_Unit in - let fn_item = - make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods - addr params (`Clam body) [ ret ] ~export_info_ - in - new_top fn_item; - acc - | _ -> assert false) + (top : Mcore.top_item) (acc : translate_result) = + (match top with + | Ctop_expr { expr; loc_ } -> + let name_hint = "*init*" in + base := loc_; + let clam_expr = + transl_expr ~mtype_defs ~name_hint ~addr_tbl ~type_defs ~object_methods + expr + in + { acc with init = sequence [ clam_expr ] acc.init } + | Ctop_let { binder; expr; is_pub_ = _; loc_ } -> ( + base := loc_; + match expr with + | Cexpr_function { func; ty = _ } -> + transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func + binder None; + acc + | _ -> ( + let ty = Mcore.type_of_expr expr in + let name = + Ident.of_core_ident + ~ty:(Transl_mtype.mtype_to_ltype ~mtype_defs ~type_defs ty) + binder + in + let expr = + transl_expr ~name_hint:(Ident.to_string name) ~mtype_defs ~addr_tbl + ~type_defs ~object_methods expr + in + match Clam_util.no_located expr with + | Lconst + ((C_bool _ | C_char _ | C_int _ | C_int64 _ | C_double _) as c) + -> + { acc with globals = (name, Some c) :: acc.globals } + | Lconst (C_string _ as c) when !Basic_config.use_js_builtin_string + -> + { acc with globals = (name, Some c) :: acc.globals } + | _ -> + { + acc with + globals = (name, None) :: acc.globals; + init = Llet { name; e = expr; body = acc.init }; + })) + | Ctop_fn { binder; func; export_info_; loc_ } -> + base := loc_; + transl_top_func ~mtype_defs ~addr_tbl ~type_defs ~object_methods func + binder export_info_; + acc + | Ctop_stub { binder; func_stubs; params_ty; return_ty; export_info_; loc_ } + -> ( + base := loc_; + match[@warning "-fragile-match"] Addr_table.find_exn addr_tbl binder with + | Toplevel { addr; params; return; _ } -> + let args = + Lst.map2 params params_ty (fun id -> + fun ty -> + (let var : Clam.lambda = Lvar { var = id } in + if Mtype.is_func ty then + Lprim { fn = Pclosure_to_extern_ref; args = [ var ] } + else var + : Clam.lambda)) + in + let params_ty = + Lst.map2 params params_ty (fun id -> + fun ty -> + (if Mtype.is_func ty then Ref_extern else Ident.get_type id + : Ltype.t)) + in + let return_ty = + match return_ty with + | None -> None + | Some _ -> ( + match[@warning "-fragile-match"] return with + | return_ltype :: [] -> Some return_ltype + | _ -> assert false) + in + let body : Clam.lambda = + Levent + { + expr = + Lstub_call { fn = func_stubs; args; params_ty; return_ty }; + loc_; + } + in + let ret = Option.value return_ty ~default:Ltype.i32_unit in + let fn_item = + make_top_fn_item ~mtype_defs ~addr_tbl ~type_defs ~object_methods + addr params (`Clam body) [ ret ] ~export_info_ + in + new_top fn_item; + acc + | _ -> assert false) + : translate_result) let collect_top_func ~mtype_defs ~type_defs (item : Mcore.top_item) ~(addr_tbl : Addr_table.t) = @@ -1193,7 +1300,7 @@ let collect_top_func ~mtype_defs ~type_defs (item : Mcore.top_item) match return_ty with | Some return_ty -> Transl_mtype.mtype_to_ltype return_ty ~type_defs ~mtype_defs - | None -> I32_Unit + | None -> Ltype.i32_unit in Addr_table.add_toplevel_fn_addr addr_tbl binder ~params ~return:[ return ] | Ctop_let _ -> () @@ -1208,88 +1315,96 @@ let non_well_knowns_obj = let collect_local_non_well_knowns (ctx : Core_ident.Hashset.t) (prog : Mcore.t) = - Lst.iter prog.body (non_well_knowns_obj#visit_top_item ctx); + Lst.iter prog.body ~f:(non_well_knowns_obj#visit_top_item ctx); match prog.main with | None -> () | Some (main, _) -> non_well_knowns_obj#visit_expr ctx main -let transl_prog ({ body; main; types; object_methods = _ } as prog : Mcore.t) : - Clam.prog = - binds_init := []; - Ident_hashset.reset local_non_well_knowns; - collect_local_non_well_knowns local_non_well_knowns prog; - let type_defs = Transl_mtype.transl_mtype_defs types in - let addr_tbl = Addr_table.create 17 in - Lst.iter body (collect_top_func ~type_defs ~mtype_defs:types ~addr_tbl); - let object_methods = Object_util.Hash.create 17 in - Object_util.Hash.iter2 prog.object_methods - (fun obj_key { self_ty; methods } -> - let ({ trait; type_ } : Object_util.object_key) = obj_key in - let abstract_obj_tid = Tid.of_type_path trait in - let concrete_obj_tid = Tid.concrete_object_type ~trait ~type_name:type_ in - let self_lty = - Transl_mtype_gc.mtype_to_ltype ~type_defs ~mtype_defs:types self_ty - in - Tid.Hash.add type_defs.defs concrete_obj_tid - (Ref_closure { fn_sig_tid = abstract_obj_tid; captures = [ self_lty ] }); - let addrs = - Lst.mapi methods (fun method_index method_item -> - make_object_wrapper ~type_defs ~mtype_defs:types ~addr_tbl - ~object_methods ~abstract_obj_tid ~concrete_obj_tid ~self_lty - ~method_index ~trait method_item) - in - Object_util.Hash.add object_methods obj_key addrs); - (match main with - | Some (main, loc_) -> - collect_top_func ~type_defs ~mtype_defs:types - (Ctop_expr { expr = main; loc_ }) - ~addr_tbl - | None -> ()); - let acc = { globals = []; init = clam_unit; test = clam_unit } in - let main = - match main with - | None -> None - | Some (main, loc_) -> - base := loc_; - Some - (transl_expr ~mtype_defs:types ~name_hint:"*main*" ~addr_tbl - ~type_defs ~object_methods main) - in - let { globals; init; test } = - List.fold_right - (transl_top_item ~mtype_defs:types ~addr_tbl ~type_defs ~object_methods) - body acc - in - let start = sequence init test ~expr1_type_:I32_Unit in - let globals, init, fns = - Addr_table.fold addr_tbl (globals, start, !binds_init) - (fun _fn_binder fn_info (globals, start, fns) -> - match fn_info with - | Toplevel { name_as_closure = Some name; params; return; addr } -> ( - let closure_ty : Ltype.t = - match Ident.get_type name with - | Ref_any -> - let sig_ : Ltype.fn_sig = - { params = Lst.map params Ident.get_type; ret = return } - in - Ref - { tid = Ltype.FnSigHash.find_exn type_defs.fn_sig_tbl sig_ } - | ty -> ty - in - let closure_item = - make_top_closure_item addr params return ~closure_ty - in - let address = closure_item.binder in - match[@warning "-fragile-match"] closure_ty with - | Ref { tid } -> - let fn_closure = - Clam.Lclosure { captures = []; address = Normal address; tid } - in - ( (name, None) :: globals, - Clam.Llet { name; e = fn_closure; body = start }, - closure_item :: fns ) - | _ -> assert false) - | Toplevel { name_as_closure = None; _ } | Local _ -> - (globals, start, fns)) - in - { fns; init; main; globals; type_defs = type_defs.defs } +let transl_prog ({ body; main; types; object_methods = _ } as prog : Mcore.t) = + (binds_init := []; + Ident_hashset.reset local_non_well_knowns; + collect_local_non_well_knowns local_non_well_knowns prog; + let type_defs = Transl_mtype.transl_mtype_defs types in + let addr_tbl = Addr_table.create 17 in + Lst.iter body ~f:(collect_top_func ~type_defs ~mtype_defs:types ~addr_tbl); + let object_methods = Object_util.Hash.create 17 in + Object_util.Hash.iter2 prog.object_methods (fun obj_key -> + fun { self_ty; methods } -> + let ({ trait; type_ } : Object_util.object_key) = obj_key in + let abstract_obj_tid = Tid.of_type_path trait in + let concrete_obj_tid = + Tid.concrete_object_type ~trait ~type_name:type_ + in + let self_lty = + Transl_mtype_gc.mtype_to_ltype ~type_defs ~mtype_defs:types self_ty + in + Tid.Hash.add type_defs.defs concrete_obj_tid + (Ref_concrete_object { abstract_obj_tid; self = self_lty }); + let number_of_methods = List.length methods in + let addrs = + Lst.mapi methods (fun method_index -> + fun method_item -> + make_object_wrapper ~type_defs ~mtype_defs:types ~addr_tbl + ~object_methods ~abstract_obj_tid ~concrete_obj_tid ~self_lty + ~method_index ~trait ~number_of_methods method_item) + in + Object_util.Hash.add object_methods obj_key addrs); + (match main with + | Some (main, loc_) -> + collect_top_func ~type_defs ~mtype_defs:types + (Ctop_expr { expr = main; loc_ }) + ~addr_tbl + | None -> ()); + let acc = { globals = []; init = clam_unit; test = clam_unit } in + let main = + match main with + | None -> None + | Some (main, loc_) -> + base := loc_; + Some + (transl_expr ~mtype_defs:types ~name_hint:"*main*" ~addr_tbl + ~type_defs ~object_methods main) + in + let { globals; init; test } = + Lst.fold_right body acc + (transl_top_item ~mtype_defs:types ~addr_tbl ~type_defs ~object_methods) + in + let start = sequence [ init ] test in + let globals, init, fns = + Addr_table.fold addr_tbl (globals, start, !binds_init) (fun _fn_binder -> + fun fn_info -> + fun (globals, start, fns) -> + match fn_info with + | Toplevel { name_as_closure = Some name; params; return; addr } -> ( + let closure_ty : Ltype.t = + match Ident.get_type name with + | Ref_any -> + let sig_ : Ltype.fn_sig = + { params = Lst.map params Ident.get_type; ret = return } + in + Ref + { + tid = + Ltype.FnSigHash.find_exn type_defs.fn_sig_tbl sig_; + } + | ty -> ty + in + let closure_item = + make_top_closure_item addr params return ~closure_ty + in + let address = closure_item.binder in + match[@warning "-fragile-match"] closure_ty with + | Ref { tid } -> + let fn_closure = + Clam.Lclosure + { captures = []; address = Normal address; tid } + in + ( (name, None) :: globals, + Clam.Llet { name; e = fn_closure; body = start }, + closure_item :: fns ) + | _ -> assert false) + | Toplevel { name_as_closure = None; _ } | Local _ -> + (globals, start, fns)) + in + { fns; init; main; globals; type_defs = type_defs.defs } + : Clam.prog) diff --git a/src/clam_util.ml b/src/clam_util.ml index 30eb756..07cf9b9 100644 --- a/src/clam_util.ml +++ b/src/clam_util.ml @@ -15,10 +15,10 @@ let loc_of_lambda : Clam.lambda -> Loc.t option = function | Levent { loc_; _ } -> Some loc_ - | Lallocate _ | Lclosure _ | Lget_field _ | Lclosure_field _ | Lset_field _ - | Lmake_array _ | Larray_get_item _ | Larray_set_item _ | Lapply _ - | Lstub_call _ | Lconst _ | Lif _ | Llet _ | Lletrec _ | Lprim _ | Lsequence _ - | Ljoinlet _ | Ljoinapply _ | Lbreak _ | Lcontinue _ | Lswitch _ + | Lallocate _ | Lclosure _ | Lget_raw_func _ | Lget_field _ | Lclosure_field _ + | Lset_field _ | Lmake_array _ | Larray_get_item _ | Larray_set_item _ + | Lapply _ | Lstub_call _ | Lconst _ | Lif _ | Llet _ | Lletrec _ | Lprim _ + | Lsequence _ | Ljoinlet _ | Ljoinapply _ | Lbreak _ | Lcontinue _ | Lswitch _ | Lswitchint _ | Lswitchstring _ | Lvar _ | Lassign _ | Lcatch _ | Lcast _ | Lloop _ | Lreturn _ -> None diff --git a/src/const_table.ml b/src/const_table.ml index 5d134e0..9251492 100644 --- a/src/const_table.ml +++ b/src/const_table.ml @@ -22,7 +22,9 @@ include struct let sexp_of_const_kind = (function - | Str -> S.Atom "Str" | Bytes -> S.Atom "Bytes" | Arr -> S.Atom "Arr" + | Str -> S.Atom "Str" + | Bytes -> S.Atom "Bytes" + | Arr -> S.Atom "Arr" : const_kind -> S.t) let _ = sexp_of_const_kind @@ -30,9 +32,10 @@ include struct let _ = equal_const_kind let (hash_fold_const_kind : Ppx_base.state -> const_kind -> Ppx_base.state) = - (fun hsv arg -> - Ppx_base.hash_fold_int hsv - (match arg with Str -> 0 | Bytes -> 1 | Arr -> 2) + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv + (match arg with Str -> 0 | Bytes -> 1 | Arr -> 2) : Ppx_base.state -> const_kind -> Ppx_base.state) let _ = hash_fold_const_kind @@ -70,23 +73,25 @@ include struct let _ = sexp_of_const let equal_const = - (fun a__008_ b__009_ -> - if Stdlib.( == ) a__008_ b__009_ then true - else - Stdlib.( && ) - (equal_const_kind a__008_.kind b__009_.kind) - (Stdlib.( = ) (a__008_.value : string) b__009_.value) + (fun a__008_ -> + fun b__009_ -> + if Stdlib.( == ) a__008_ b__009_ then true + else + Stdlib.( && ) + (equal_const_kind a__008_.kind b__009_.kind) + (Stdlib.( = ) (a__008_.value : string) b__009_.value) : const -> const -> bool) let _ = equal_const let (hash_fold_const : Ppx_base.state -> const -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = hsv in - hash_fold_const_kind hsv arg.kind - in - Ppx_base.hash_fold_string hsv arg.value + fun hsv -> + fun arg -> + let hsv = + let hsv = hsv in + hash_fold_const_kind hsv arg.kind + in + Ppx_base.hash_fold_string hsv arg.value let _ = hash_fold_const @@ -139,44 +144,47 @@ let create () = let get_string_count (t : t) = Hash_string.length t.str_index_table -let find_str_const (obj : t) (s : string) : int * int = - match Hash_string.find_opt obj.str_index_table s with - | Some index -> - let offset = - Hash_const.find_exn obj.offset_table { value = s; kind = Str } - in - (offset, index) - | None -> - let index = Hash_string.length obj.str_index_table in - let offset = obj.current_offset in - Hash_string.add obj.str_index_table s index; - Hash_const.add obj.offset_table { value = s; kind = Str } offset; - obj.current_offset <- obj.current_offset + String.length s; - Buffer.add_string obj.buf s; - (offset, index) - -let find_js_builtin_str_const (obj : t) (s : string) : int = - match Hash_string.find_opt obj.str_index_table s with - | Some index -> index - | None -> - let index = Hash_string.length obj.str_index_table in - Hash_string.add obj.str_index_table s index; - index - -let find_const (obj : t) (s : string) (kind : const_kind) : int = - let const = { kind; value = s } in - match Hash_const.find_opt obj.offset_table const with - | Some i -> i - | None -> - let offset = obj.current_offset in - let size = String.length s in - obj.current_offset <- obj.current_offset + size; - Buffer.add_string obj.buf s; - Hash_const.add obj.offset_table const offset; - offset - -let find_array_const (obj : t) (s : string) : int = find_const obj s Arr -let find_bytes_const (obj : t) (s : string) : int = find_const obj s Bytes +let find_str_const (obj : t) (s : string) = + (match Hash_string.find_opt obj.str_index_table s with + | Some index -> + let offset = + Hash_const.find_exn obj.offset_table { value = s; kind = Str } + in + (offset, index) + | None -> + let index = Hash_string.length obj.str_index_table in + let offset = obj.current_offset in + Hash_string.add obj.str_index_table s index; + Hash_const.add obj.offset_table { value = s; kind = Str } offset; + obj.current_offset <- obj.current_offset + String.length s; + Buffer.add_string obj.buf s; + (offset, index) + : int * int) + +let find_js_builtin_str_const (obj : t) (s : string) = + (match Hash_string.find_opt obj.str_index_table s with + | Some index -> index + | None -> + let index = Hash_string.length obj.str_index_table in + Hash_string.add obj.str_index_table s index; + index + : int) + +let find_const (obj : t) (s : string) (kind : const_kind) = + (let const = { kind; value = s } in + match Hash_const.find_opt obj.offset_table const with + | Some i -> i + | None -> + let offset = obj.current_offset in + let size = String.length s in + obj.current_offset <- obj.current_offset + size; + Buffer.add_string obj.buf s; + Hash_const.add obj.offset_table const offset; + offset + : int) + +let find_array_const (obj : t) (s : string) = (find_const obj s Arr : int) +let find_bytes_const (obj : t) (s : string) = (find_const obj s Bytes : int) let to_wat_string (obj : t) = Buffer.contents obj.buf let iter_constant_string_with_index (t : t) (f : string -> int -> unit) = diff --git a/src/const_util.ml b/src/const_util.ml new file mode 100644 index 0000000..4ad40a4 --- /dev/null +++ b/src/const_util.ml @@ -0,0 +1,262 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Lst = Basic_lst +module Vec = Basic_vec +module Hash_string = Basic_hash_string +module Syntax = Parsing_syntax +module Ident = Basic_ident + +let rec eval_const_expr (expr : Typedtree.expr) ~diagnostics = + (let error reason loc = + Local_diagnostics.add_error diagnostics + (Errors.constant_not_constant ~reason ~loc); + None + [@@local] + in + match expr with + | Texpr_constant { c; ty = _; name_ = _ } -> Some c + | Texpr_apply + { + func = + Texpr_ident + { kind = Prim (Parith { operand_type; operator = Neg }); _ }; + args = { arg_value = target; arg_kind = Positional } :: []; + ty = _; + loc_; + } -> ( + match eval_const_expr target ~diagnostics with + | Some c -> ( + match operand_type with + | I32 | I64 | F64 -> Constant.eval_negation c + | I16 | F32 -> error `Unsupported loc_ + | U8 | U16 | U32 | U64 -> None) + | _ -> None) + | Texpr_apply + { + func = + Texpr_ident { kind = Prim (Parith { operand_type; operator }); _ }; + kind_ = Infix; + args = + [ + { arg_value = lhs; arg_kind = Positional }; + { arg_value = rhs; arg_kind = Positional }; + ]; + ty = _; + loc_; + } -> ( + match + (eval_const_expr lhs ~diagnostics, eval_const_expr rhs ~diagnostics) + with + | Some c1, Some c2 -> ( + match operator with + | Add | Sub | Mul | Div | Mod -> ( + match operand_type with + | I32 | U32 | I64 | U64 | F64 -> ( + match Constant.eval_arith operand_type operator c1 c2 with + | Some _ as result -> result + | None -> error `Arith_error loc_) + | F32 | U8 | I16 | U16 -> error `Unsupported loc_) + | Sqrt | Neg | Abs -> None) + | _ -> None) + | Texpr_apply + { + func = + Texpr_ident { kind = Prim (Pbitwise { operand_type; operator }); _ }; + kind_ = Infix; + args = + [ + { arg_value = lhs; arg_kind = Positional }; + { arg_value = rhs; arg_kind = Positional }; + ]; + ty = _; + loc_; + } -> ( + match + (eval_const_expr lhs ~diagnostics, eval_const_expr rhs ~diagnostics) + with + | Some c1, Some c2 -> ( + match operand_type with + | I32 | U32 | I64 | U64 -> + Constant.eval_bitwise operand_type operator c1 c2 + | I16 | U16 | U8 -> error `Unsupported loc_ + | F32 | F64 -> None) + | _ -> None) + | Texpr_apply + { + func = + Texpr_ident + { kind = Prim (Pcomparison { operand_type; operator }); _ }; + kind_ = Infix; + args = + [ + { arg_value = lhs; arg_kind = Positional }; + { arg_value = rhs; arg_kind = Positional }; + ]; + ty = _; + loc_; + } -> ( + match + (eval_const_expr lhs ~diagnostics, eval_const_expr rhs ~diagnostics) + with + | Some c1, Some c2 -> ( + match operand_type with + | I32 | U32 | I64 | U64 | F64 -> + Constant.eval_comparison operand_type operator c1 c2 + | I16 | U16 | U8 | F32 -> error `Unsupported loc_) + | _ -> None) + | Texpr_constraint { expr; _ } -> eval_const_expr expr ~diagnostics + | Texpr_hole { kind = Synthesized; _ } -> None + | _ -> error `Not_const (Typedtree.loc_of_typed_expr expr) + : Constant.t option) + +let typing_const_decl + ({ binder; expr; is_pub; loc_; doc_; attrs; konstraint; id; typ } : + Local_typing_worklist.const_decl) ~global_env ~diagnostics = + (let binder_loc = Rloc.to_loc ~base:loc_ binder.loc_ in + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let binder, expr = + Typer.typing_impl_let binder expr ~id:(Ident.of_qual_ident id) ~typ + ~global_env ~diagnostics:local_diagnostics + in + let kind : Value_info.value_kind = + match Stype.type_repr typ with + | _ when Local_diagnostics.has_fatal_errors local_diagnostics -> Normal + | T_builtin _ -> ( + match eval_const_expr expr ~diagnostics:local_diagnostics with + | Some value -> Const value + | None -> Normal) + | T_blackhole | Tvar { contents = Tnolink Tvar_error } -> Normal + | typ -> + let loc = + match konstraint with + | Some konstraint -> Typedtree.loc_of_typ konstraint + | None -> Typedtree.loc_of_typed_expr expr + in + Local_diagnostics.add_error local_diagnostics + (Errors.invalid_constant_type ~ty:(Printer.type_to_string typ) ~loc); + Normal + in + let toplevel_env = Global_env.get_toplevel_values global_env in + let value_info : Value_info.toplevel = + { + id; + typ; + pub = is_pub; + kind; + loc_ = binder_loc; + doc_; + attrs; + ty_params_ = Tvar_env.empty; + arity_ = None; + param_names_ = []; + direct_use_loc_ = Not_direct_use; + } + in + Typing_info.add_value toplevel_env value_info; + Local_diagnostics.add_to_global local_diagnostics diagnostics; + Timpl_letdef + { + binder; + expr; + is_pub; + loc_; + konstraint; + doc_; + attrs; + is_generated_ = false; + } + : Typedtree.impl) + +let typing_const_decls (const_decls : Local_typing_worklist.const_decl Vec.t) + ~global_env ~diagnostics = + let decls = Hash_string.create (Vec.length const_decls) in + let toplevel_env = Global_env.get_toplevel_values global_env in + Vec.iter (fun (decl : Local_typing_worklist.const_decl) -> + let name = decl.binder.binder_name in + match Hash_string.find_opt decls name with + | Some (`Unresolved (prev_def : Local_typing_worklist.const_decl)) -> + Diagnostics.add_error diagnostics + (Errors.value_redeclare ~name + ~first_loc:(Rloc.to_loc ~base:prev_def.loc_ prev_def.binder.loc_) + ~second_loc:(Rloc.to_loc ~base:decl.loc_ decl.binder.loc_) + ~extra_message:None) + | Some (`Resolved _) -> assert false + | None -> + (match Typing_info.find_constructor toplevel_env name with + | constr :: _ -> + Diagnostics.add_error diagnostics + (Errors.constant_constr_duplicate ~name + ~constr_loc:constr.cs_loc_ + ~const_loc:(Rloc.to_loc ~base:decl.loc_ decl.binder.loc_)) + | [] -> ()); + Hash_string.add decls decl.binder.binder_name (`Unresolved decl)) + const_decls; + let visitor = + object (self) + inherit [_] Syntax.iter + + method! visit_constructor visiting constr = + match constr.extra_info with + | No_extra_info -> ( + let name = constr.constr_name.name in + if Lst.mem_string visiting name then + match[@warning "-fragile-match"] + Hash_string.find_exn decls name + with + | `Unresolved decl -> + Diagnostics.add_error diagnostics + (Errors.cycle_in_const_decl + ~cycle:(List.rev (name :: visiting)) + ~loc:(Rloc.to_loc ~base:decl.loc_ decl.binder.loc_)); + let dummy_value_info : Value_info.toplevel = + { + id = decl.id; + typ = decl.typ; + pub = decl.is_pub; + kind = Normal; + loc_ = Loc.no_location; + doc_ = decl.doc_; + attrs = decl.attrs; + ty_params_ = Tvar_env.empty; + arity_ = None; + param_names_ = []; + direct_use_loc_ = Not_direct_use; + } + in + Typing_info.add_value toplevel_env dummy_value_info + | _ -> assert false + else + match Hash_string.find_opt decls name with + | Some (`Unresolved decl) -> + ignore + (self#visit_const_decl visiting decl ~is_redeclare:false) + | Some (`Resolved _) | None -> ()) + | Package _ | Type_name _ -> () + + method visit_const_decl visiting decl ~is_redeclare = + self#visit_expr (decl.binder.binder_name :: visiting) decl.expr; + let result = typing_const_decl decl ~global_env ~diagnostics in + if not is_redeclare then + Hash_string.replace decls decl.binder.binder_name (`Resolved result); + result + end + in + Vec.map_into_list const_decls ~unorder:(fun decl -> + match Hash_string.find_exn decls decl.binder.binder_name with + | `Unresolved decl' -> + let is_redeclare = Basic_prelude.phys_not_equal decl' decl in + visitor#visit_const_decl [] decl ~is_redeclare + | `Resolved result -> result) diff --git a/src/constant.ml b/src/constant.ml index f8c9477..308488a 100644 --- a/src/constant.ml +++ b/src/constant.ml @@ -23,6 +23,7 @@ type t = | C_bool of bool | C_char of Uchar.t | C_int of { v : int32; repr : string option [@ceh.ignore] } + | C_byte of { v : int; repr : string option [@ceh.ignore] } | C_int64 of { v : int64; repr : string option [@ceh.ignore] } | C_uint of { v : UInt32.t; repr : string option [@ceh.ignore] } | C_uint64 of { v : UInt64.t; repr : string option [@ceh.ignore] } @@ -36,101 +37,111 @@ include struct let _ = fun (_ : t) -> () let compare = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then 0 - else - match (a__001_, b__002_) with - | C_bool _a__003_, C_bool _b__004_ -> - Stdlib.compare (_a__003_ : bool) _b__004_ - | C_bool _, _ -> -1 - | _, C_bool _ -> 1 - | C_char _a__005_, C_char _b__006_ -> Uchar.compare _a__005_ _b__006_ - | C_char _, _ -> -1 - | _, C_char _ -> 1 - | C_int _a__007_, C_int _b__008_ -> - Stdlib.Int32.compare (_a__007_.v : int32) _b__008_.v - | C_int _, _ -> -1 - | _, C_int _ -> 1 - | C_int64 _a__009_, C_int64 _b__010_ -> - Stdlib.Int64.compare (_a__009_.v : int64) _b__010_.v - | C_int64 _, _ -> -1 - | _, C_int64 _ -> 1 - | C_uint _a__011_, C_uint _b__012_ -> - UInt32.compare _a__011_.v _b__012_.v - | C_uint _, _ -> -1 - | _, C_uint _ -> 1 - | C_uint64 _a__013_, C_uint64 _b__014_ -> - UInt64.compare _a__013_.v _b__014_.v - | C_uint64 _, _ -> -1 - | _, C_uint64 _ -> 1 - | C_float _a__015_, C_float _b__016_ -> - Stdlib.compare (_a__015_.v : float) _b__016_.v - | C_float _, _ -> -1 - | _, C_float _ -> 1 - | C_double _a__017_, C_double _b__018_ -> - Stdlib.compare (_a__017_.v : float) _b__018_.v - | C_double _, _ -> -1 - | _, C_double _ -> 1 - | C_string _a__019_, C_string _b__020_ -> - Stdlib.compare (_a__019_ : string) _b__020_ - | C_string _, _ -> -1 - | _, C_string _ -> 1 - | C_bytes _a__021_, C_bytes _b__022_ -> - Stdlib.compare (_a__021_.v : string) _b__022_.v - | C_bytes _, _ -> -1 - | _, C_bytes _ -> 1 - | C_bigint _a__023_, C_bigint _b__024_ -> - BigInt.compare _a__023_.v _b__024_.v + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then 0 + else + match (a__001_, b__002_) with + | C_bool _a__003_, C_bool _b__004_ -> + Stdlib.compare (_a__003_ : bool) _b__004_ + | C_bool _, _ -> -1 + | _, C_bool _ -> 1 + | C_char _a__005_, C_char _b__006_ -> Uchar.compare _a__005_ _b__006_ + | C_char _, _ -> -1 + | _, C_char _ -> 1 + | C_int _a__007_, C_int _b__008_ -> + Stdlib.Int32.compare (_a__007_.v : int32) _b__008_.v + | C_int _, _ -> -1 + | _, C_int _ -> 1 + | C_byte _a__009_, C_byte _b__010_ -> + Stdlib.compare (_a__009_.v : int) _b__010_.v + | C_byte _, _ -> -1 + | _, C_byte _ -> 1 + | C_int64 _a__011_, C_int64 _b__012_ -> + Stdlib.Int64.compare (_a__011_.v : int64) _b__012_.v + | C_int64 _, _ -> -1 + | _, C_int64 _ -> 1 + | C_uint _a__013_, C_uint _b__014_ -> + UInt32.compare _a__013_.v _b__014_.v + | C_uint _, _ -> -1 + | _, C_uint _ -> 1 + | C_uint64 _a__015_, C_uint64 _b__016_ -> + UInt64.compare _a__015_.v _b__016_.v + | C_uint64 _, _ -> -1 + | _, C_uint64 _ -> 1 + | C_float _a__017_, C_float _b__018_ -> + Stdlib.compare (_a__017_.v : float) _b__018_.v + | C_float _, _ -> -1 + | _, C_float _ -> 1 + | C_double _a__019_, C_double _b__020_ -> + Stdlib.compare (_a__019_.v : float) _b__020_.v + | C_double _, _ -> -1 + | _, C_double _ -> 1 + | C_string _a__021_, C_string _b__022_ -> + Stdlib.compare (_a__021_ : string) _b__022_ + | C_string _, _ -> -1 + | _, C_string _ -> 1 + | C_bytes _a__023_, C_bytes _b__024_ -> + Stdlib.compare (_a__023_.v : string) _b__024_.v + | C_bytes _, _ -> -1 + | _, C_bytes _ -> 1 + | C_bigint _a__025_, C_bigint _b__026_ -> + BigInt.compare _a__025_.v _b__026_.v : t -> t -> int) let _ = compare let equal = - (fun a__025_ b__026_ -> - if Stdlib.( == ) a__025_ b__026_ then true - else - match (a__025_, b__026_) with - | C_bool _a__027_, C_bool _b__028_ -> - Stdlib.( = ) (_a__027_ : bool) _b__028_ - | C_bool _, _ -> false - | _, C_bool _ -> false - | C_char _a__029_, C_char _b__030_ -> Uchar.equal _a__029_ _b__030_ - | C_char _, _ -> false - | _, C_char _ -> false - | C_int _a__031_, C_int _b__032_ -> - Stdlib.( = ) (_a__031_.v : int32) _b__032_.v - | C_int _, _ -> false - | _, C_int _ -> false - | C_int64 _a__033_, C_int64 _b__034_ -> - Stdlib.( = ) (_a__033_.v : int64) _b__034_.v - | C_int64 _, _ -> false - | _, C_int64 _ -> false - | C_uint _a__035_, C_uint _b__036_ -> - UInt32.equal _a__035_.v _b__036_.v - | C_uint _, _ -> false - | _, C_uint _ -> false - | C_uint64 _a__037_, C_uint64 _b__038_ -> - UInt64.equal _a__037_.v _b__038_.v - | C_uint64 _, _ -> false - | _, C_uint64 _ -> false - | C_float _a__039_, C_float _b__040_ -> - Stdlib.( = ) (_a__039_.v : float) _b__040_.v - | C_float _, _ -> false - | _, C_float _ -> false - | C_double _a__041_, C_double _b__042_ -> - Stdlib.( = ) (_a__041_.v : float) _b__042_.v - | C_double _, _ -> false - | _, C_double _ -> false - | C_string _a__043_, C_string _b__044_ -> - Stdlib.( = ) (_a__043_ : string) _b__044_ - | C_string _, _ -> false - | _, C_string _ -> false - | C_bytes _a__045_, C_bytes _b__046_ -> - Stdlib.( = ) (_a__045_.v : string) _b__046_.v - | C_bytes _, _ -> false - | _, C_bytes _ -> false - | C_bigint _a__047_, C_bigint _b__048_ -> - BigInt.equal _a__047_.v _b__048_.v + (fun a__027_ -> + fun b__028_ -> + if Stdlib.( == ) a__027_ b__028_ then true + else + match (a__027_, b__028_) with + | C_bool _a__029_, C_bool _b__030_ -> + Stdlib.( = ) (_a__029_ : bool) _b__030_ + | C_bool _, _ -> false + | _, C_bool _ -> false + | C_char _a__031_, C_char _b__032_ -> Uchar.equal _a__031_ _b__032_ + | C_char _, _ -> false + | _, C_char _ -> false + | C_int _a__033_, C_int _b__034_ -> + Stdlib.( = ) (_a__033_.v : int32) _b__034_.v + | C_int _, _ -> false + | _, C_int _ -> false + | C_byte _a__035_, C_byte _b__036_ -> + Stdlib.( = ) (_a__035_.v : int) _b__036_.v + | C_byte _, _ -> false + | _, C_byte _ -> false + | C_int64 _a__037_, C_int64 _b__038_ -> + Stdlib.( = ) (_a__037_.v : int64) _b__038_.v + | C_int64 _, _ -> false + | _, C_int64 _ -> false + | C_uint _a__039_, C_uint _b__040_ -> + UInt32.equal _a__039_.v _b__040_.v + | C_uint _, _ -> false + | _, C_uint _ -> false + | C_uint64 _a__041_, C_uint64 _b__042_ -> + UInt64.equal _a__041_.v _b__042_.v + | C_uint64 _, _ -> false + | _, C_uint64 _ -> false + | C_float _a__043_, C_float _b__044_ -> + Stdlib.( = ) (_a__043_.v : float) _b__044_.v + | C_float _, _ -> false + | _, C_float _ -> false + | C_double _a__045_, C_double _b__046_ -> + Stdlib.( = ) (_a__045_.v : float) _b__046_.v + | C_double _, _ -> false + | _, C_double _ -> false + | C_string _a__047_, C_string _b__048_ -> + Stdlib.( = ) (_a__047_ : string) _b__048_ + | C_string _, _ -> false + | _, C_string _ -> false + | C_bytes _a__049_, C_bytes _b__050_ -> + Stdlib.( = ) (_a__049_.v : string) _b__050_.v + | C_bytes _, _ -> false + | _, C_bytes _ -> false + | C_bigint _a__051_, C_bigint _b__052_ -> + BigInt.equal _a__051_.v _b__052_.v : t -> t -> bool) let _ = equal @@ -141,6 +152,10 @@ let sexp_of_t = function match repr with | Some s -> S.Atom s | None -> Moon_sexp_conv.sexp_of_int32 v) + | C_byte { v; repr } -> ( + match repr with + | Some s -> S.Atom s + | None -> Moon_sexp_conv.sexp_of_int v) | C_int64 { v; repr } -> ( match repr with | Some s -> S.Atom s @@ -176,7 +191,20 @@ let eval_arith (ty : Primitive.operand_type) (op : Primitive.arith_operator) | Mul -> make_int (Int32.mul v1 v2) | Div -> if v2 <> 0l then make_int (Int32.div v1 v2) else None | Mod -> if v2 <> 0l then make_int (Int32.rem v1 v2) else None - | Neg | Sqrt -> None) + | Neg | Sqrt | Abs -> None) + | U32, C_uint { v = v1; repr = _ }, C_uint { v = v2; repr = _ } -> ( + let make_uint i = Some (C_uint { v = i; repr = None }) in + match op with + | Add -> make_uint (UInt32.add v1 v2) + | Sub -> make_uint (UInt32.sub v1 v2) + | Mul -> make_uint (UInt32.mul v1 v2) + | Div -> + if UInt32.equal v2 UInt32.min_int then None + else make_uint (UInt32.div v1 v2) + | Mod -> + if UInt32.equal v2 UInt32.min_int then None + else make_uint (UInt32.rem v1 v2) + | Neg | Sqrt | Abs -> None) | I64, C_int64 { v = v1; repr = _ }, C_int64 { v = v2; repr = _ } -> ( let make_int64 i = Some (C_int64 { v = i; repr = None }) in match op with @@ -185,7 +213,20 @@ let eval_arith (ty : Primitive.operand_type) (op : Primitive.arith_operator) | Mul -> make_int64 (Int64.mul v1 v2) | Div -> if v2 <> 0L then make_int64 (Int64.div v1 v2) else None | Mod -> if v2 <> 0L then make_int64 (Int64.rem v1 v2) else None - | Neg | Sqrt -> None) + | Neg | Sqrt | Abs -> None) + | U64, C_uint64 { v = v1; repr = _ }, C_uint64 { v = v2; repr = _ } -> ( + let make_uint i = Some (C_uint64 { v = i; repr = None }) in + match op with + | Add -> make_uint (UInt64.add v1 v2) + | Sub -> make_uint (UInt64.sub v1 v2) + | Mul -> make_uint (UInt64.mul v1 v2) + | Div -> + if UInt64.equal v2 UInt64.min_int then None + else make_uint (UInt64.div v1 v2) + | Mod -> + if UInt64.equal v2 UInt64.min_int then None + else make_uint (UInt64.rem v1 v2) + | Neg | Sqrt | Abs -> None) | F64, C_double { v = v1; repr = _ }, C_double { v = v2; repr = _ } -> ( let make_float i = Some (C_double { v = i; repr = None }) in match op with @@ -193,9 +234,20 @@ let eval_arith (ty : Primitive.operand_type) (op : Primitive.arith_operator) | Sub -> make_float (v1 -. v2) | Mul -> make_float (v1 *. v2) | Div -> if v2 <> 0. then make_float (v1 /. v2) else None - | Mod | Neg | Sqrt -> None) + | Mod -> if v2 <> 0. then make_float (Float.rem v1 v2) else None + | Neg | Sqrt | Abs -> None) | _ -> None +let eval_negation (c : t) = + (match c with + | C_int { v; repr = _ } -> Some (C_int { v = Int32.neg v; repr = None }) + | C_int64 { v; repr = _ } -> Some (C_int64 { v = Int64.neg v; repr = None }) + | C_double { v; repr = _ } -> + Some (C_double { v = Float.neg v; repr = None }) + | C_byte _ | C_uint _ | C_uint64 _ | C_float _ -> None + | C_bool _ | C_char _ | C_bytes _ | C_string _ | C_bigint _ -> None + : t option) + let eval_comparison (ty : Primitive.operand_type) (op : Primitive.comparison) (c1 : t) (c2 : t) = let make_bool b = Some (C_bool b) [@@local] in @@ -310,41 +362,43 @@ let eval_bitwise (ty : Primitive.operand_type) (op : Primitive.bitwise_operator) | _ -> None) | _ -> None -let eval_compare c1 c2 : int option = - match c1 with - | C_int { v = v1; repr = _ } -> ( - match c2 with - | C_int { v = v2; repr = _ } -> Some (Int32.compare v1 v2) - | _ -> None) - | C_int64 { v = v1; repr = _ } -> ( - match c2 with - | C_int64 { v = v2; repr = _ } -> Some (Int64.compare v1 v2) - | _ -> None) - | C_uint { v = v1; repr = _ } -> ( - match c2 with - | C_uint { v = v2; repr = _ } -> Some (Basic_uint32.compare v1 v2) - | _ -> None) - | C_uint64 { v = v1; repr = _ } -> ( - match c2 with - | C_uint64 { v = v2; repr = _ } -> Some (Basic_uint64.compare v1 v2) - | _ -> None) - | C_char c1 -> ( - match c2 with C_char c2 -> Some (Uchar.compare c1 c2) | _ -> None) - | C_float { v = v1; repr = _ } -> ( - match c2 with - | C_float { v = v2; repr = _ } -> Some (Float.compare v1 v2) - | _ -> None) - | C_double { v = v1; repr = _ } -> ( - match c2 with - | C_double { v = v2; repr = _ } -> Some (Float.compare v1 v2) - | _ -> None) - | C_string _ | C_bytes _ | C_bool _ | C_bigint _ -> None +let eval_compare c1 c2 = + (match c1 with + | C_int { v = v1; repr = _ } -> ( + match c2 with + | C_int { v = v2; repr = _ } -> Some (Int32.compare v1 v2) + | _ -> None) + | C_int64 { v = v1; repr = _ } -> ( + match c2 with + | C_int64 { v = v2; repr = _ } -> Some (Int64.compare v1 v2) + | _ -> None) + | C_uint { v = v1; repr = _ } -> ( + match c2 with + | C_uint { v = v2; repr = _ } -> Some (Basic_uint32.compare v1 v2) + | _ -> None) + | C_uint64 { v = v1; repr = _ } -> ( + match c2 with + | C_uint64 { v = v2; repr = _ } -> Some (Basic_uint64.compare v1 v2) + | _ -> None) + | C_char c1 -> ( + match c2 with C_char c2 -> Some (Uchar.compare c1 c2) | _ -> None) + | C_float { v = v1; repr = _ } -> ( + match c2 with + | C_float { v = v2; repr = _ } -> Some (Float.compare v1 v2) + | _ -> None) + | C_double { v = v1; repr = _ } -> ( + match c2 with + | C_double { v = v2; repr = _ } -> Some (Float.compare v1 v2) + | _ -> None) + | C_string _ | C_bytes _ | C_bool _ | C_bigint _ | C_byte _ -> None + : int option) let to_string (c : t) = match c with | C_bool true -> "true" | C_bool false -> "false" | C_int { repr = Some repr; v = _ } + | C_byte { repr = Some repr; v = _ } | C_uint { repr = Some repr; v = _ } | C_int64 { repr = Some repr; v = _ } | C_uint64 { repr = Some repr; v = _ } @@ -354,6 +408,7 @@ let to_string (c : t) = | C_bytes { repr = Some repr; v = _ } -> repr | C_int { v; repr = None } -> Int32.to_string v + | C_byte { v; repr = None } -> Int.to_string v | C_uint { v; repr = None } -> UInt32.to_string v | C_int64 { v; repr = None } -> Int64.to_string v | C_uint64 { v; repr = None } -> UInt64.to_string v diff --git a/src/constraint_cache.ml b/src/constraint_cache.ml index 15191e8..24d9b31 100644 --- a/src/constraint_cache.ml +++ b/src/constraint_cache.ml @@ -31,11 +31,12 @@ module Key = struct let _ = sexp_of_t let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - fun hsv arg -> - let e0, e1 = arg in - let hsv = Hashed_type.hash_fold_t hsv e0 in - let hsv = Type_path.hash_fold_t hsv e1 in - hsv + fun hsv -> + fun arg -> + let e0, e1 = arg in + let hsv = Hashed_type.hash_fold_t hsv e0 in + let hsv = Type_path.hash_fold_t hsv e1 in + hsv let _ = hash_fold_t @@ -50,12 +51,13 @@ module Key = struct let _ = hash let equal = - (fun a__005_ b__006_ -> - let t__007_, t__008_ = a__005_ in - let t__009_, t__010_ = b__006_ in - Stdlib.( && ) - (Hashed_type.equal t__007_ t__009_) - (Type_path.equal t__008_ t__010_) + (fun a__005_ -> + fun b__006_ -> + let t__007_, t__008_ = a__005_ in + let t__009_, t__010_ = b__006_ in + Stdlib.( && ) + (Hashed_type.equal t__007_ t__009_) + (Type_path.equal t__008_ t__010_) : t -> t -> bool) let _ = equal diff --git a/src/control_ctx.ml b/src/control_ctx.ml index 840fb8c..44e49e2 100644 --- a/src/control_ctx.ml +++ b/src/control_ctx.ml @@ -14,13 +14,18 @@ module Type_path = Basic_type_path +module Lst = Basic_lst type control_info = | Not_in_loop | Ambiguous_position | In_while - | In_while_else of { break : Stype.t } - | In_loop of { break : Stype.t; continue : Stype.t list } + | In_while_with_else of { break : Stype.t } + | In_loop of { + break : Stype.t; + continue : Stype.t list; + has_continue : bool ref; + } | In_for of { break : Stype.t option; continue : Stype.t list } | In_foreach of { break : Stype.t option } @@ -36,185 +41,292 @@ type fixed_error_ctx = type error_ctx = Fixed_ctx of fixed_error_ctx | Open_ctx of open_error_ctx -let error_ctx_to_stype ctx : Stype.t = - match ctx with - | Open_ctx Empty_ctx -> Stype.new_type_var Stype.Tvar_error - | Open_ctx (Suberrors es) -> ( - match es with - | [] -> assert false - | p :: [] -> - T_constr - { - type_constructor = p; - tys = []; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = true; - } - | _ -> Stype.error) - | Open_ctx (Tparam { index; name_ }) | Fixed_ctx (Tparam { index; name_ }) -> - Stype.Tparam { index; name_ } - | Fixed_ctx Supererror -> Stype.error - | Fixed_ctx (Suberror p) -> - T_constr - { - type_constructor = p; - tys = []; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let error_ctx_to_stype ctx = + (match ctx with + | Open_ctx Empty_ctx -> Stype.new_type_var Stype.Tvar_error + | Open_ctx (Suberrors es) -> ( + match es with + | [] -> assert false + | p :: [] -> + T_constr + { + type_constructor = p; + tys = []; + generic_ = false; + is_suberror_ = true; + } + | _ -> Stype.error) + | Open_ctx (Tparam { index; name_ }) | Fixed_ctx (Tparam { index; name_ }) -> + Stype.Tparam { index; name_ } + | Fixed_ctx Supererror -> Stype.error + | Fixed_ctx (Suberror p) -> + T_constr + { + type_constructor = p; + tys = []; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) + +type labeled_loop_info = { + control_info : control_info; + label : Label.t; + used : bool ref; +} + +type async_ctx = In_sync_fn | In_async_fn | In_foreach type t = { return : Stype.t option; error_ctx : error_ctx ref option; + async_ctx : async_ctx; control_info : control_info; - has_continue : bool ref; - has_error : bool ref; + may_has_error : bool ref; + labeled_controls : (string * labeled_loop_info) list; } let empty = { return = None; error_ctx = None; + async_ctx = In_sync_fn; control_info = Not_in_loop; - has_continue = ref false; - has_error = ref false; + may_has_error = ref false; + labeled_controls = []; } -let make_fn ~return ~error_ctx = +let make_fn ~return ~error_ctx ~is_async = { return = Some return; error_ctx; + async_ctx = (if is_async then In_async_fn else In_sync_fn); control_info = Not_in_loop; - has_continue = ref false; - has_error = ref false; + may_has_error = ref false; + labeled_controls = []; } -let with_while ~break_typ parent = +let warn_if_label_shadowed (label : Typedtree.loop_label_binder) + (parent : (string * labeled_loop_info) list) diagnostics = + if Lst.exists parent (fun (name, _) -> name = Label.basename label.label) then + Local_diagnostics.add_warning diagnostics + { + kind = Warnings.Loop_label_shadow (Label.basename label.label); + loc = label.loc_; + } + +let warn_if_label_unused (label : Typedtree.loop_label_binder option) (ctx : t) + ~diagnostics = + match label with + | None -> () + | Some label -> + let _, { used; _ } = List.hd ctx.labeled_controls in + if not !used then + Local_diagnostics.add_warning diagnostics + { + kind = Warnings.Loop_label_unused (Label.basename label.label); + loc = label.loc_; + } + +let with_while ~break_typ ~(label : Typedtree.loop_label_binder option) parent + ~diagnostics = + let control_info = + match break_typ with + | None -> In_while + | Some break_typ -> In_while_with_else { break = break_typ } + in + let labeled_controls = + match label with + | None -> parent.labeled_controls + | Some label -> + warn_if_label_shadowed label parent.labeled_controls diagnostics; + ( Label.basename label.label, + { label = label.label; control_info; used = ref false } ) + :: parent.labeled_controls + in { return = parent.return; error_ctx = parent.error_ctx; - control_info = - (match break_typ with - | None -> In_while - | Some break_typ -> In_while_else { break = break_typ }); - has_continue = ref false; - has_error = parent.has_error; + async_ctx = parent.async_ctx; + control_info; + may_has_error = parent.may_has_error; + labeled_controls; } -let with_loop ~arg_typs ~result_typ parent = +let with_loop ~arg_typs ~result_typ + ~(label : Typedtree.loop_label_binder option) parent ~diagnostics = + let control_info = + In_loop + { break = result_typ; continue = arg_typs; has_continue = ref false } + in + let labeled_controls = + match label with + | None -> parent.labeled_controls + | Some label -> + warn_if_label_shadowed label parent.labeled_controls diagnostics; + ( Label.basename label.label, + { label = label.label; control_info; used = ref false } ) + :: parent.labeled_controls + in { return = parent.return; error_ctx = parent.error_ctx; - control_info = In_loop { break = result_typ; continue = arg_typs }; - has_continue = ref false; - has_error = parent.has_error; + async_ctx = parent.async_ctx; + control_info; + may_has_error = parent.may_has_error; + labeled_controls; } -let with_for ~break_typ ~arg_typs parent = +let loop_has_continue (ctx : t) = + (match ctx.control_info with + | In_loop { has_continue; _ } -> !has_continue + | _ -> assert false + : bool) + +let with_for ~break_typ ~arg_typs ~(label : Typedtree.loop_label_binder option) + parent ~diagnostics = + let control_info = In_for { continue = arg_typs; break = break_typ } in + let labeled_controls = + match label with + | None -> parent.labeled_controls + | Some label -> + warn_if_label_shadowed label parent.labeled_controls diagnostics; + ( Label.basename label.label, + { label = label.label; control_info; used = ref false } ) + :: parent.labeled_controls + in { return = parent.return; error_ctx = parent.error_ctx; - control_info = In_for { continue = arg_typs; break = break_typ }; - has_continue = ref false; - has_error = parent.has_error; + async_ctx = parent.async_ctx; + control_info; + may_has_error = parent.may_has_error; + labeled_controls; } -let with_foreach ~break_typ parent = +let with_foreach ~break_typ ~(label : Typedtree.loop_label_binder option) parent + ~diagnostics = + let control_info : control_info = In_foreach { break = break_typ } in + let labeled_controls = + match label with + | None -> parent.labeled_controls + | Some label -> + warn_if_label_shadowed label parent.labeled_controls diagnostics; + ( Label.basename label.label, + { label = label.label; control_info; used = ref false } ) + :: parent.labeled_controls + in { return = parent.return; error_ctx = parent.error_ctx; - has_error = parent.has_error; + async_ctx = In_foreach; + may_has_error = parent.may_has_error; control_info = In_foreach { break = break_typ }; - has_continue = ref false; + labeled_controls; } let with_ambiguous_position parent = { return = parent.return; error_ctx = parent.error_ctx; + async_ctx = parent.async_ctx; control_info = Ambiguous_position; - has_continue = ref false; - has_error = parent.has_error; + may_has_error = parent.may_has_error; + labeled_controls = parent.labeled_controls; } let with_error_ctx ~error_ctx parent = - { parent with error_ctx = Some error_ctx; has_error = ref false } - -let check_error_in_ctx ~error_ty ~(ctx : error_ctx ref) loc : - Local_diagnostics.error_option = - let is_tvar (typ : Stype.t) : bool = - let typ = Stype.type_repr typ in - match typ with Tvar _ -> true | _ -> false - [@@local] - in - let error_ty = Stype.type_repr error_ty in - let make_error expect_ty = - let expected_ty, error_ty = - Printer.type_pair_to_string expect_ty error_ty - in - Some (Errors.error_type_mismatch ~expected_ty ~actual_ty:error_ty ~loc) - [@@local] - in - if is_tvar error_ty then Ctype.unify_exn error_ty Stype.error; - match !ctx with - | Fixed_ctx expect_ty -> ( - match expect_ty with - | Supererror -> None - | Tparam { index; name_ } -> ( - match error_ty with - | Tparam { index = index' } when index = index' -> None - | _ -> - let expect_ty : Stype.t = Tparam { index; name_ } in - make_error expect_ty) - | Suberror p -> ( - match error_ty with - | T_constr { type_constructor = p'; _ } when Type_path.equal p p' -> - None - | _ -> - let expect_ty : Stype.t = - T_constr - { - type_constructor = p; - tys = []; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = true; - } - in - make_error expect_ty)) - | Open_ctx open_ctx -> ( - match open_ctx with - | Empty_ctx -> ( - match error_ty with - | T_constr { type_constructor = p; is_suberror_ = true; _ } -> - ctx := Open_ctx (Suberrors [ p ]); - None - | Tparam { index; name_ } -> - ctx := Open_ctx (Tparam { index; name_ }); - None - | T_constr { type_constructor = Type_path.T_error; _ } -> - ctx := Fixed_ctx Supererror; - None - | _ -> None) - | Tparam { index } -> ( - match error_ty with - | Tparam { index = index' } -> - if index <> index' then ctx := Fixed_ctx Supererror; - None - | T_constr { type_constructor = _; is_suberror_ = true; _ } - | T_constr { type_constructor = Type_path.T_error; _ } -> - ctx := Fixed_ctx Supererror; - None - | _ -> None) - | Suberrors ps -> ( - match error_ty with - | T_constr { type_constructor = p; is_suberror_ = true; _ } -> - if not (Basic_lst.exists ps (Type_path.equal p)) then - ctx := Open_ctx (Suberrors (p :: ps)); - None - | Tparam _ | T_constr { type_constructor = Type_path.T_error; _ } -> - ctx := Fixed_ctx Supererror; - None - | _ -> None)) + { + parent with + error_ctx = Some error_ctx; + may_has_error = ref false; + labeled_controls = parent.labeled_controls; + } + +let check_error_in_ctx ~error_ty ~(ctx : error_ctx ref) loc = + (let is_tvar (typ : Stype.t) = + (let typ = Stype.type_repr typ in + match typ with Tvar _ -> true | _ -> false + : bool) + [@@local] + in + let error_ty = Stype.type_repr error_ty in + let make_error expect_ty = + let expected_ty, error_ty = + Printer.type_pair_to_string expect_ty error_ty + in + Some (Errors.error_type_mismatch ~expected_ty ~actual_ty:error_ty ~loc) + [@@local] + in + if is_tvar error_ty then Ctype.unify_exn error_ty Stype.error; + match !ctx with + | Fixed_ctx expect_ty -> ( + match expect_ty with + | Supererror -> None + | Tparam { index; name_ } -> ( + match error_ty with + | Tparam { index = index' } when index = index' -> None + | _ -> + let expect_ty : Stype.t = Tparam { index; name_ } in + make_error expect_ty) + | Suberror p -> ( + match error_ty with + | T_constr { type_constructor = p'; _ } when Type_path.equal p p' -> + None + | _ -> + let expect_ty : Stype.t = + T_constr + { + type_constructor = p; + tys = []; + generic_ = false; + is_suberror_ = true; + } + in + make_error expect_ty)) + | Open_ctx open_ctx -> ( + match open_ctx with + | Empty_ctx -> ( + match error_ty with + | T_constr { type_constructor = p; is_suberror_ = true; _ } -> + ctx := Open_ctx (Suberrors [ p ]); + None + | Tparam { index; name_ } -> + ctx := Open_ctx (Tparam { index; name_ }); + None + | T_constr { type_constructor = Type_path.T_error; _ } -> + ctx := Fixed_ctx Supererror; + None + | _ -> None) + | Tparam { index } -> ( + match error_ty with + | Tparam { index = index' } -> + if index <> index' then ctx := Fixed_ctx Supererror; + None + | T_constr { type_constructor = _; is_suberror_ = true; _ } + | T_constr { type_constructor = Type_path.T_error; _ } -> + ctx := Fixed_ctx Supererror; + None + | _ -> None) + | Suberrors ps -> ( + match error_ty with + | T_constr { type_constructor = p; is_suberror_ = true; _ } -> + if not (Basic_lst.exists ps (Type_path.equal p)) then + ctx := Open_ctx (Suberrors (p :: ps)); + None + | Tparam _ | T_constr { type_constructor = Type_path.T_error; _ } -> + ctx := Fixed_ctx Supererror; + None + | _ -> None)) + : Local_diagnostics.error option) + +let async_is_allowed (ctx : t) ~loc = + (match ctx.async_ctx with + | In_async_fn -> None + | In_sync_fn -> + Some + (Errors.async_not_allowed_in_context ~context:"non-async function" ~loc) + | In_foreach -> + Some + (Errors.async_not_allowed_in_context ~context:"`for .. in` loop" ~loc) + : Local_diagnostics.error option) diff --git a/src/core.ml b/src/core.ml index f68e783..71f87d8 100644 --- a/src/core.ml +++ b/src/core.ml @@ -236,7 +236,7 @@ and expr = loc_ : location; } | Cexpr_prim of { prim : prim; args : expr list; ty : typ; loc_ : location } - [@build fun p args ty loc -> prim ~loc ~ty p args] + [@build fun p -> fun args -> fun ty -> fun loc -> prim ~loc ~ty p args] | Cexpr_let of { name : binder; rhs : expr; @@ -252,7 +252,7 @@ and expr = kind : letfn_kind; loc_ : location; } - | Cexpr_function of { func : fn; ty : typ; loc_ : location } + | Cexpr_function of { func : fn; ty : typ; is_raw_ : bool; loc_ : location } | Cexpr_letrec of { bindings : (binder * fn) list; body : expr; @@ -269,7 +269,6 @@ and expr = loc_ : location; } | Cexpr_constr of { - constr : constr; tag : constr_tag; args : expr list; ty : typ; @@ -291,6 +290,10 @@ and expr = ty : typ; loc_ : location; } + [@build + fun record -> + fun accessor -> + fun pos -> fun ty -> fun loc -> field ~loc record accessor ~pos ~ty] | Cexpr_mutate of { record : expr; label : label; @@ -301,15 +304,26 @@ and expr = } | Cexpr_array of { exprs : expr list; ty : typ; loc_ : location } | Cexpr_assign of { var : var; expr : expr; ty : typ; loc_ : location } - | Cexpr_sequence of { expr1 : expr; expr2 : expr; ty : typ; loc_ : location } - [@build fun expr1 expr2 ty loc_ -> sequence ~loc:loc_ expr1 expr2] + | Cexpr_sequence of { + exprs : expr list; + last_expr : expr; + ty : typ; + loc_ : location; + } + [@build + fun expr1 -> + fun expr2 -> fun ty -> fun loc_ -> sequence ~loc:loc_ expr1 expr2] | Cexpr_if of { cond : expr; ifso : expr; ifnot : expr option; ty : typ; loc_ : location; - } [@build fun cond ifso ifnot ty loc -> if_ ~loc cond ~ifso ?ifnot] + } + [@build + fun cond -> + fun ifso -> + fun ifnot -> fun ty -> fun loc -> if_ ~loc cond ~ifso ?ifnot] | Cexpr_switch_constr of { obj : expr; cases : (constr_tag * binder option * expr) list; @@ -318,7 +332,10 @@ and expr = loc_ : location; } [@build - fun obj cases default ty loc -> switch_constr ~loc obj cases ~default] + fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constr ~loc obj cases ~default] | Cexpr_switch_constant of { obj : expr; cases : (constant * expr) list; @@ -327,7 +344,10 @@ and expr = loc_ : location; } [@build - fun obj cases default ty loc -> switch_constant ~loc obj cases ~default] + fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constant ~loc obj cases ~default] | Cexpr_loop of { params : param list; body : expr; @@ -341,7 +361,9 @@ and expr = label : loop_label; ty : typ; loc_ : location; - } [@build fun arg label ty loc_ -> break arg label ty ~loc_] + } + [@build + fun arg -> fun label -> fun ty -> fun loc_ -> break arg label ty ~loc_] | Cexpr_continue of { args : expr list; label : loop_label; @@ -360,10 +382,19 @@ and expr = ty : typ; loc_ : location; } + | Cexpr_and of { lhs : expr; rhs : expr; loc_ : location } + [@build fun lhs -> fun rhs -> fun loc -> and_ ~loc lhs rhs] + | Cexpr_or of { lhs : expr; rhs : expr; loc_ : location } + [@build fun lhs -> fun rhs -> fun loc -> or_ ~loc lhs rhs] -and fn = { params : param list; body : expr } +and fn = { params : param list; body : expr; is_async : bool } and param = { binder : binder; ty : typ; loc_ : location } -and apply_kind = Normal of { func_ty : typ } | Join + +and apply_kind = + | Normal of { func_ty : typ } + | Async of { func_ty : typ } + | Join + and field_def = { label : label; pos : int; is_mut : bool; expr : expr } include struct @@ -383,21 +414,26 @@ type program = top_item list module Iter = struct class virtual ['a] iterbase = object - method visit_prim : 'a -> Primitive.prim -> unit = fun _ _ -> () - method visit_constr_tag : 'a -> constr_tag -> unit = fun _ _ -> () - method visit_constr : 'a -> constr -> unit = fun _ _ -> () - method visit_label : 'a -> label -> unit = fun _ _ -> () - method visit_accessor : 'a -> accessor -> unit = fun _ _ -> () - method visit_location : 'a -> location -> unit = fun _ _ -> () - method visit_absolute_loc : 'a -> absolute_loc -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_loop_label : 'a -> loop_label -> unit = fun _ _ -> () - method visit_typ : 'a -> typ -> unit = fun _ _ -> () - method visit_type_path : 'a -> type_path -> unit = fun _ _ -> () - method visit_tvar_env : 'a -> tvar_env -> unit = fun _ _ -> () - method visit_func_stubs : 'a -> func_stubs -> unit = fun _ _ -> () - method visit_return_kind : 'a -> return_kind -> unit = fun _ _ -> () + method visit_prim : 'a -> Primitive.prim -> unit = fun _ -> fun _ -> () + method visit_constr_tag : 'a -> constr_tag -> unit = fun _ -> fun _ -> () + method visit_constr : 'a -> constr -> unit = fun _ -> fun _ -> () + method visit_label : 'a -> label -> unit = fun _ -> fun _ -> () + method visit_accessor : 'a -> accessor -> unit = fun _ -> fun _ -> () + method visit_location : 'a -> location -> unit = fun _ -> fun _ -> () + + method visit_absolute_loc : 'a -> absolute_loc -> unit = + fun _ -> fun _ -> () + + method visit_binder : 'a -> binder -> unit = fun _ -> fun _ -> () + method visit_var : 'a -> var -> unit = fun _ -> fun _ -> () + method visit_loop_label : 'a -> loop_label -> unit = fun _ -> fun _ -> () + method visit_typ : 'a -> typ -> unit = fun _ -> fun _ -> () + method visit_type_path : 'a -> type_path -> unit = fun _ -> fun _ -> () + method visit_tvar_env : 'a -> tvar_env -> unit = fun _ -> fun _ -> () + method visit_func_stubs : 'a -> func_stubs -> unit = fun _ -> fun _ -> () + + method visit_return_kind : 'a -> return_kind -> unit = + fun _ -> fun _ -> () end type _unused @@ -411,841 +447,1045 @@ module Iter = struct inherit [_] iterbase method visit_Ctop_expr : _ -> expr -> bool -> absolute_loc -> unit = - fun env _visitors_fexpr _visitors_fis_main _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fis_main in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - () - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> unit = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pub_ in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_main + in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + () + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_pub_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + () method visit_Ctop_fn : _ -> top_fun_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - () - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - bool -> - absolute_loc -> - unit = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_freturn_ty - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fis_pub_ in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + () + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + bool -> + absolute_loc -> + unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_freturn_ty + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fis_pub_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + () method visit_top_item : _ -> top_item -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main - _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty _visitors_fis_pub_ - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main + _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ method visit_subtop_fun_decl : _ -> subtop_fun_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.fn in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.fn in + () method visit_top_fun_decl : _ -> top_fun_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_subtop_fun_decl env)) - _visitors_this.subtops - in - let _visitors_r3 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.is_pub_ - in - let _visitors_r5 = - self#visit_absolute_loc env _visitors_this.loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_subtop_fun_decl env)) + _visitors_this.subtops + in + let _visitors_r3 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_this.is_pub_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_this.loc_ + in + () method visit_To_result : _ -> unit = fun env -> () method visit_Joinapply : _ -> var -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + () method visit_Return_err : _ -> typ -> unit = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - () + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + () method visit_handle_kind : _ -> handle_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> unit = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_unit : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_var - : _ -> var -> typ -> typ array -> prim option -> location -> unit = - fun env _visitors_fid _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - Basic_arr.iter _visitors_this (self#visit_typ env)) - _visitors_fty_args_ - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_prim env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_as - : _ -> expr -> type_path -> typ -> location -> unit = - fun env _visitors_fexpr _visitors_ftrait _visitors_fobj_type - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_path env _visitors_ftrait in - let _visitors_r2 = self#visit_typ env _visitors_fobj_type in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> unit = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> unit = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> unit - = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_function : _ -> fn -> typ -> location -> unit = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> unit = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - ())) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - typ -> - typ array -> - prim option -> - location -> - unit = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> - Basic_arr.iter _visitors_this (self#visit_typ env)) - _visitors_fty_args_ - in - let _visitors_r5 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_prim env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_var : + _ -> var -> typ -> typ array -> prim option -> location -> unit = + fun env -> + fun _visitors_fid -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + Basic_arr.iter _visitors_this (self#visit_typ env)) + _visitors_fty_args_ + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_prim env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_as : + _ -> expr -> type_path -> typ -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fobj_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_path env _visitors_ftrait in + let _visitors_r2 = self#visit_typ env _visitors_fobj_type in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> unit = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> unit = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> unit + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> unit = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + ())) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + typ -> + typ array -> + prim option -> + location -> + unit = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + Basic_arr.iter _visitors_this (self#visit_typ env)) + _visitors_fty_args_ + in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_prim env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> unit = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> unit = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_ffields_num - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> unit = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_ffields_num + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fpos + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_array : _ -> expr list -> typ -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> unit = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> unit = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_binder env) t - | None -> ()) - _visitors_c1 - in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - ())) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - unit = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> unit = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> unit = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> unit = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> unit = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_binder env) t + | None -> ()) + _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + ())) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + ())) + _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> unit = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> unit = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_and : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_or : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_expr : _ -> expr -> unit = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ - | Cexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - obj_type = _visitors_fobj_type; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fobj_type _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fty + _visitors_fty_args_ _visitors_fprim _visitors_floc_ + | Cexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + obj_type = _visitors_fobj_type; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fobj_type _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fty _visitors_fty_args_ + _visitors_fprim _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.is_async + in + () method visit_param : _ -> param -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + () method visit_Normal : _ -> typ -> unit = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - () + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + () + + method visit_Async : _ -> typ -> unit = + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + () method visit_Join : _ -> unit = fun env -> () method visit_apply_kind : _ -> apply_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Async { func_ty = _visitors_ffunc_ty } -> + self#visit_Async env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.is_mut - in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.is_mut + in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + () end [@@@VISITORS.END] @@ -1262,50 +1502,55 @@ open struct inherit [_] Sexp_visitors.sexp method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x + fun _ -> fun x -> sexp_of_constant x - method visit_prim : 'a -> prim -> S.t = fun _ x -> sexp_of_prim x + method visit_prim : 'a -> prim -> S.t = fun _ -> fun x -> sexp_of_prim x method visit_constr_tag : 'a -> constr_tag -> S.t = - fun _ x -> sexp_of_constr_tag x + fun _ -> fun x -> sexp_of_constr_tag x - method visit_constr : 'a -> constr -> S.t = fun _ x -> sexp_of_constr x - method visit_label : 'a -> label -> S.t = fun _ x -> sexp_of_label x + method visit_constr : 'a -> constr -> S.t = + fun _ -> fun x -> sexp_of_constr x + + method visit_label : 'a -> label -> S.t = + fun _ -> fun x -> sexp_of_label x method visit_accessor : 'a -> accessor -> S.t = - fun _ x -> sexp_of_accessor x + fun _ -> fun x -> sexp_of_accessor x method visit_location : 'a -> location -> S.t = - fun _ x -> sexp_of_location x + fun _ -> fun x -> sexp_of_location x method visit_absolute_loc : 'a -> absolute_loc -> S.t = - fun _ x -> sexp_of_absolute_loc x + fun _ -> fun x -> sexp_of_absolute_loc x + + method visit_binder : 'a -> binder -> S.t = + fun _ -> fun x -> sexp_of_binder x - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x + method visit_var : 'a -> var -> S.t = fun _ -> fun x -> sexp_of_var x method visit_loop_label : 'a -> loop_label -> S.t = - fun _ x -> sexp_of_loop_label x + fun _ -> fun x -> sexp_of_loop_label x - method visit_typ : 'a -> typ -> S.t = fun _ x -> sexp_of_typ x + method visit_typ : 'a -> typ -> S.t = fun _ -> fun x -> sexp_of_typ x method visit_type_path : 'a -> type_path -> S.t = - fun _ x -> sexp_of_type_path x + fun _ -> fun x -> sexp_of_type_path x method visit_tvar_env : 'a -> tvar_env -> S.t = - fun _ x -> sexp_of_tvar_env x + fun _ -> fun x -> sexp_of_tvar_env x method private visit_test_name : 'a -> Syntax.test_name -> S.t = - fun _ x -> Syntax.sexp_of_test_name x + fun _ -> fun x -> Syntax.sexp_of_test_name x method visit_func_stubs : 'a -> func_stubs -> S.t = - fun _ x -> sexp_of_func_stubs x + fun _ -> fun x -> sexp_of_func_stubs x method visit_letfn_kind : 'a -> letfn_kind -> S.t = - fun _ x -> sexp_of_letfn_kind x + fun _ -> fun x -> sexp_of_letfn_kind x method visit_return_kind : 'a -> return_kind -> S.t = - fun _ x -> sexp_of_return_kind x + fun _ -> fun x -> sexp_of_return_kind x end type _unused @@ -1319,981 +1564,1193 @@ open struct inherit [_] sexpbase method visit_Ctop_expr : _ -> expr -> bool -> absolute_loc -> S.t = - fun env _visitors_fexpr _visitors_fis_main _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_bool env _visitors_fis_main in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_expr" - [ - ("expr", _visitors_r0); - ("is_main", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> S.t = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_bool env _visitors_fis_pub_ in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_let" - [ - ("binder", _visitors_r0); - ("expr", _visitors_r1); - ("is_pub_", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_bool env _visitors_fis_main in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + self#visit_inline_record env "Ctop_expr" + [ + ("expr", _visitors_r0); + ("is_main", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_bool env _visitors_fis_pub_ in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ctop_let" + [ + ("binder", _visitors_r0); + ("expr", _visitors_r1); + ("is_pub_", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Ctop_fn : _ -> top_fun_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - self#visit_inline_tuple env "Ctop_fn" [ _visitors_r0 ] - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - bool -> - absolute_loc -> - S.t = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - self#visit_list self#visit_typ env _visitors_fparams_ty - in - let _visitors_r3 = - self#visit_option self#visit_typ env _visitors_freturn_ty - in - let _visitors_r4 = self#visit_bool env _visitors_fis_pub_ in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_stub" - [ - ("binder", _visitors_r0); - ("func_stubs", _visitors_r1); - ("params_ty", _visitors_r2); - ("return_ty", _visitors_r3); - ("is_pub_", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + self#visit_inline_tuple env "Ctop_fn" [ _visitors_r0 ] + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + bool -> + absolute_loc -> + S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + self#visit_list self#visit_typ env _visitors_fparams_ty + in + let _visitors_r3 = + self#visit_option self#visit_typ env _visitors_freturn_ty + in + let _visitors_r4 = self#visit_bool env _visitors_fis_pub_ in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ctop_stub" + [ + ("binder", _visitors_r0); + ("func_stubs", _visitors_r1); + ("params_ty", _visitors_r2); + ("return_ty", _visitors_r3); + ("is_pub_", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_top_item : _ -> top_item -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main - _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty _visitors_fis_pub_ - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main + _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ method visit_subtop_fun_decl : _ -> subtop_fun_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.fn in - self#visit_record env - [ ("binder", _visitors_r0); ("fn", _visitors_r1) ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.fn in + self#visit_record env + [ ("binder", _visitors_r0); ("fn", _visitors_r1) ] method visit_top_fun_decl : _ -> top_fun_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - self#visit_list self#visit_subtop_fun_decl env - _visitors_this.subtops - in - let _visitors_r3 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r4 = self#visit_bool env _visitors_this.is_pub_ in - let _visitors_r5 = - self#visit_absolute_loc env _visitors_this.loc_ - in - self#visit_record env - [ - ("binder", _visitors_r0); - ("func", _visitors_r1); - ("subtops", _visitors_r2); - ("ty_params_", _visitors_r3); - ("is_pub_", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + self#visit_list self#visit_subtop_fun_decl env + _visitors_this.subtops + in + let _visitors_r3 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r4 = self#visit_bool env _visitors_this.is_pub_ in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_this.loc_ + in + self#visit_record env + [ + ("binder", _visitors_r0); + ("func", _visitors_r1); + ("subtops", _visitors_r2); + ("ty_params_", _visitors_r3); + ("is_pub_", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_To_result : _ -> S.t = fun env -> self#visit_inline_tuple env "To_result" [] method visit_Joinapply : _ -> var -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - self#visit_inline_tuple env "Joinapply" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + self#visit_inline_tuple env "Joinapply" [ _visitors_r0 ] method visit_Return_err : _ -> typ -> S.t = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - self#visit_inline_record env "Return_err" - [ ("ok_ty", _visitors_r0) ] + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + self#visit_inline_record env "Return_err" + [ ("ok_ty", _visitors_r0) ] method visit_handle_kind : _ -> handle_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> S.t = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_const" - [ - ("c", _visitors_r0); ("ty", _visitors_r1); ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_const" + [ + ("c", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Cexpr_unit : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_unit" [ ("loc_", _visitors_r0) ] - - method visit_Cexpr_var - : _ -> var -> typ -> typ array -> prim option -> location -> S.t = - fun env _visitors_fid _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = - self#visit_array self#visit_typ env _visitors_fty_args_ - in - let _visitors_r3 = - self#visit_option self#visit_prim env _visitors_fprim - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_var" - [ - ("id", _visitors_r0); - ("ty", _visitors_r1); - ("ty_args_", _visitors_r2); - ("prim", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_unit" + [ ("loc_", _visitors_r0) ] + + method visit_Cexpr_var : + _ -> var -> typ -> typ array -> prim option -> location -> S.t = + fun env -> + fun _visitors_fid -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + self#visit_array self#visit_typ env _visitors_fty_args_ + in + let _visitors_r3 = + self#visit_option self#visit_prim env _visitors_fprim + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_var" + [ + ("id", _visitors_r0); + ("ty", _visitors_r1); + ("ty_args_", _visitors_r2); + ("prim", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_Cexpr_as : _ -> expr -> type_path -> typ -> location -> S.t = - fun env _visitors_fexpr _visitors_ftrait _visitors_fobj_type - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_path env _visitors_ftrait in - let _visitors_r2 = self#visit_typ env _visitors_fobj_type in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_as" - [ - ("expr", _visitors_r0); - ("trait", _visitors_r1); - ("obj_type", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> S.t = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_prim" - [ - ("prim", _visitors_r0); - ("args", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> S.t = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_let" - [ - ("name", _visitors_r0); - ("rhs", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> S.t + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fobj_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_path env _visitors_ftrait in + let _visitors_r2 = self#visit_typ env _visitors_fobj_type in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_as" + [ + ("expr", _visitors_r0); + ("trait", _visitors_r1); + ("obj_type", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> S.t = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_prim" + [ + ("prim", _visitors_r0); + ("args", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_let" + [ + ("name", _visitors_r0); + ("rhs", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + self#visit_letfn_kind env _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_letfn" + [ + ("name", _visitors_r0); + ("fn", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("kind", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> S.t = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_letfn_kind env _visitors_fkind in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_letfn" - [ - ("name", _visitors_r0); - ("fn", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("kind", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Cexpr_function : _ -> fn -> typ -> location -> S.t = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_function" - [ - ("func", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> S.t = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_letrec" - [ - ("bindings", _visitors_r0); - ("body", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - typ -> - typ array -> - prim option -> - location -> - S.t = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = - self#visit_array self#visit_typ env _visitors_fty_args_ - in - let _visitors_r5 = - self#visit_option self#visit_prim env _visitors_fprim - in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_apply" - [ - ("func", _visitors_r0); - ("args", _visitors_r1); - ("kind", _visitors_r2); - ("ty", _visitors_r3); - ("ty_args_", _visitors_r4); - ("prim", _visitors_r5); - ("loc_", _visitors_r6); - ] - - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> S.t = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_constr" - [ - ("constr", _visitors_r0); - ("tag", _visitors_r1); - ("args", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_bool env _visitors_fis_raw_ in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_function" + [ + ("func", _visitors_r0); + ("ty", _visitors_r1); + ("is_raw_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_letrec" + [ + ("bindings", _visitors_r0); + ("body", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + typ -> + typ array -> + prim option -> + location -> + S.t = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + self#visit_array self#visit_typ env _visitors_fty_args_ + in + let _visitors_r5 = + self#visit_option self#visit_prim env _visitors_fprim + in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_apply" + [ + ("func", _visitors_r0); + ("args", _visitors_r1); + ("kind", _visitors_r2); + ("ty", _visitors_r3); + ("ty_args_", _visitors_r4); + ("prim", _visitors_r5); + ("loc_", _visitors_r6); + ] + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> S.t = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_constr" + [ + ("tag", _visitors_r0); + ("args", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_tuple" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> S.t = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_record" - [ - ("fields", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r2 = self#visit_int env _visitors_ffields_num in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_record_update" - [ - ("record", _visitors_r0); - ("fields", _visitors_r1); - ("fields_num", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_int env _visitors_fpos in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_field" - [ - ("record", _visitors_r0); - ("accessor", _visitors_r1); - ("pos", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = self#visit_int env _visitors_fpos in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_mutate" - [ - ("record", _visitors_r0); - ("label", _visitors_r1); - ("field", _visitors_r2); - ("pos", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_tuple" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> S.t = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_record" + [ + ("fields", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r2 = self#visit_int env _visitors_ffields_num in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_record_update" + [ + ("record", _visitors_r0); + ("fields", _visitors_r1); + ("fields_num", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = self#visit_int env _visitors_fpos in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_field" + [ + ("record", _visitors_r0); + ("accessor", _visitors_r1); + ("pos", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = self#visit_int env _visitors_fpos in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_mutate" + [ + ("record", _visitors_r0); + ("label", _visitors_r1); + ("field", _visitors_r2); + ("pos", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_Cexpr_array : _ -> expr list -> typ -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_array" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_array" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> S.t = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_assign" - [ - ("var", _visitors_r0); - ("expr", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_sequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> S.t = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_if" - [ - ("cond", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - self#visit_option self#visit_binder env _visitors_c1 + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_assign" + [ + ("var", _visitors_r0); + ("expr", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_sequence" + [ + ("exprs", _visitors_r0); + ("last_expr", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_if" + [ + ("cond", _visitors_r0); + ("ifso", _visitors_r1); + ("ifnot", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + self#visit_option self#visit_binder env _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + self#visit_tuple env + [ _visitors_r0; _visitors_r1; _visitors_r2 ]) + env _visitors_fcases + in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_switch_constr" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_constant env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_switch_constant" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_param env _visitors_fparams in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - self#visit_tuple env - [ _visitors_r0; _visitors_r1; _visitors_r2 ]) - env _visitors_fcases - in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_switch_constr" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_switch_constant" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - S.t = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_param env _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_loop" - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("args", _visitors_r2); - ("label", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> S.t = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_break" - [ - ("arg", _visitors_r0); - ("label", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> S.t = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_continue" - [ - ("args", _visitors_r0); - ("label", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> S.t = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_handle_error" - [ - ("obj", _visitors_r0); - ("handle_kind", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> S.t = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_return" - [ - ("expr", _visitors_r0); - ("return_kind", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_loop" + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("args", _visitors_r2); + ("label", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> S.t = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_break" + [ + ("arg", _visitors_r0); + ("label", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> S.t = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_continue" + [ + ("args", _visitors_r0); + ("label", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_handle_error" + [ + ("obj", _visitors_r0); + ("handle_kind", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_return" + [ + ("expr", _visitors_r0); + ("return_kind", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_and : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_and" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_or : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_or" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_expr : _ -> expr -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ - | Cexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - obj_type = _visitors_fobj_type; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fobj_type _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fty + _visitors_fty_args_ _visitors_fprim _visitors_floc_ + | Cexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + obj_type = _visitors_fobj_type; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fobj_type _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fty _visitors_fty_args_ + _visitors_fprim _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_param env _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - self#visit_record env - [ ("params", _visitors_r0); ("body", _visitors_r1) ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_param env _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + let _visitors_r2 = self#visit_bool env _visitors_this.is_async in + self#visit_record env + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("is_async", _visitors_r2); + ] method visit_param : _ -> param -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - self#visit_record env - [ - ("binder", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + self#visit_record env + [ + ("binder", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Normal : _ -> typ -> S.t = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - self#visit_inline_record env "Normal" [ ("func_ty", _visitors_r0) ] + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + self#visit_inline_record env "Normal" [ ("func_ty", _visitors_r0) ] + + method visit_Async : _ -> typ -> S.t = + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + self#visit_inline_record env "Async" [ ("func_ty", _visitors_r0) ] method visit_Join : _ -> S.t = fun env -> self#visit_inline_tuple env "Join" [] method visit_apply_kind : _ -> apply_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Async { func_ty = _visitors_ffunc_ty } -> + self#visit_Async env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = self#visit_int env _visitors_this.pos in - let _visitors_r2 = self#visit_bool env _visitors_this.is_mut in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - self#visit_record env - [ - ("label", _visitors_r0); - ("pos", _visitors_r1); - ("is_mut", _visitors_r2); - ("expr", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = self#visit_int env _visitors_this.pos in + let _visitors_r2 = self#visit_bool env _visitors_this.is_mut in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + self#visit_record env + [ + ("label", _visitors_r0); + ("pos", _visitors_r1); + ("is_mut", _visitors_r2); + ("expr", _visitors_r3); + ] end [@@@VISITORS.END] @@ -2312,6 +2769,9 @@ open struct | "subtops", S.List [] -> None | "prim", S.List [] -> None | "is_handle_error", S.Atom "false" -> None + | "is_async", S.Atom "false" -> None + | "is_raw_", Atom "false" -> None + | "is_raw_", Atom "true" -> Some ("is_raw_", S.List [ Atom "raw" ]) | _ -> Some field let compose f g x = match g x with None -> None | Some x -> f x @@ -2363,7 +2823,7 @@ open struct (args : S.t) (List.cons (ty : S.t) (loc_ : S.t list))))) : S.t) - | Normal _ -> + | Normal _ | Async _ -> super#visit_Cexpr_apply env func args kind ty ty_args prim loc_ method! visit_Cexpr_letfn env name fn body ty letfn_kind loc_ = @@ -2436,7 +2896,7 @@ open struct method! visit_location env loc = match env with - | Use_absolute_loc base -> Rloc.to_loc ~base loc |> sexp_of_absolute_loc + | Use_absolute_loc base -> sexp_of_absolute_loc (Rloc.to_loc ~base loc) | Use_relative_loc -> super#visit_location env loc end end @@ -2458,9 +2918,8 @@ let sexp_of_program ?(use_absolute_loc = false) prog = Use_absolute_loc base else Use_relative_loc in - top_item - |> sexp_visitor#visit_top_item ctx - |> Basic_compress_stamp.normalize ~global_stamps)) + Basic_compress_stamp.normalize ~global_stamps + (sexp_visitor#visit_top_item ctx top_item))) let type_of_expr = function | Cexpr_const { ty; _ } @@ -2491,6 +2950,7 @@ let type_of_expr = function ty | Cexpr_as { trait; _ } -> Stype.T_trait trait | Cexpr_unit _ -> Stype.unit + | Cexpr_and _ | Cexpr_or _ -> Stype.bool let loc_of_expr = function | Cexpr_const { loc_; _ } @@ -2519,7 +2979,9 @@ let loc_of_expr = function | Cexpr_continue { loc_; _ } | Cexpr_as { loc_; _ } | Cexpr_loop { loc_; _ } - | Cexpr_return { loc_; _ } -> + | Cexpr_return { loc_; _ } + | Cexpr_and { loc_; _ } + | Cexpr_or { loc_; _ } -> loc_ let update_expr_loc e ~loc = @@ -2552,101 +3014,140 @@ let update_expr_loc e ~loc = | Cexpr_break t -> Cexpr_break { t with loc_ } | Cexpr_continue t -> Cexpr_continue { t with loc_ } | Cexpr_return t -> Cexpr_return { t with loc_ } + | Cexpr_and t -> Cexpr_and { t with loc_ } + | Cexpr_or t -> Cexpr_or { t with loc_ } + +let rec expr_equal e1 e2 = + Basic_prelude.phys_equal e1 e2 + || + match (e1, e2) with + | Cexpr_const { c = c1; _ }, Cexpr_const { c = c2; _ } -> Constant.equal c1 c2 + | Cexpr_unit _, Cexpr_unit _ -> true + | Cexpr_var { id = id1; _ }, Cexpr_var { id = id2; _ } -> Ident.equal id1 id2 + | ( Cexpr_prim { prim = prim1; args = args1; _ }, + Cexpr_prim { prim = prim2; args = args2; _ } ) -> + Primitive.equal_prim prim1 prim2 + && Lst.for_all2_no_exn args1 args2 expr_equal + | Cexpr_as { expr = e1; trait = t1; _ }, Cexpr_as { expr = e2; trait = t2; _ } + -> + expr_equal e1 e2 && Type_path.equal t1 t2 + | ( Cexpr_apply { func = func1; args = args1; _ }, + Cexpr_apply { func = func2; args = args2; _ } ) -> + Ident.equal func1 func2 && Lst.for_all2_no_exn args1 args2 expr_equal + | ( Cexpr_constr { tag = tag1; args = args1; _ }, + Cexpr_constr { tag = tag2; args = args2; _ } ) -> + Constr_info.equal_constr_tag tag1 tag2 + && Lst.for_all2_no_exn args1 args2 expr_equal + | Cexpr_tuple { exprs = exprs1; _ }, Cexpr_tuple { exprs = exprs2; _ } -> + Lst.for_all2_no_exn exprs1 exprs2 expr_equal + | _ -> false let ghost_loc_ = Rloc.no_location -let const ?(loc = ghost_loc_) (c : constant) : expr = - let ty = - match c with - | C_int _ -> Stype.int - | C_int64 _ -> Stype.int64 - | C_uint _ -> Stype.uint - | C_uint64 _ -> Stype.uint64 - | C_float _ -> Stype.float - | C_double _ -> Stype.double - | C_char _ -> Stype.char - | C_bool _ -> Stype.bool - | C_string _ -> Stype.string - | C_bytes _ -> Stype.bytes - | C_bigint _ -> Stype.bigint - in - Cexpr_const { c; ty; loc_ = loc } - -let unit ?(loc = ghost_loc_) () : expr = Cexpr_unit { loc_ = loc } - -let prim ?(loc = ghost_loc_) ~ty (prim : Primitive.prim) args : expr = - match (prim, args) with - | ( Parith { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_arith operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | Parith { operand_type = _; operator = Neg }, Cexpr_const { c; _ } :: [] -> ( - match c with - | C_int { v; repr = _ } -> - const ~loc (C_int { v = Int32.neg v; repr = None }) - | C_int64 { v; repr = _ } -> - const ~loc (C_int64 { v = Int64.neg v; repr = None }) - | C_double { v; repr = _ } -> - const ~loc (C_double { v = -.v; repr = None }) - | _ -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | ( Pbitwise { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_bitwise operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | ( Pcomparison { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_comparison operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | Psequand, [ (Cexpr_const { c = C_bool b; _ } as arg1); arg2 ] -> - if b then arg2 else arg1 - | Psequor, [ (Cexpr_const { c = C_bool b; _ } as arg1); arg2 ] -> - if b then arg1 else arg2 - | Pnot, Cexpr_const { c = C_bool b; _ } :: [] -> const ~loc (C_bool (not b)) - | _ -> Cexpr_prim { prim; args; ty; loc_ = loc } - -let unsaturated_prim ?(loc = ghost_loc_) ~ty prim : expr = - match Stype.type_repr ty with - | Tarrow { params_ty; ret_ty; err_ty = _ } as ty -> - let params, args = - Lst.map_split params_ty (fun ty : (param * expr) -> - let id = Ident.fresh "*x" in - ( { binder = id; ty; loc_ = ghost_loc_ }, - Cexpr_var - { id; ty; ty_args_ = [||]; prim = None; loc_ = ghost_loc_ } )) - in - let body : expr = - Cexpr_prim { prim; args; ty = ret_ty; loc_ = ghost_loc_ } - in - Cexpr_function { func = { params; body }; ty; loc_ = loc } - | _ -> assert false - -let join_apply ?(loc = ghost_loc_) ~ty join args : expr = - Cexpr_apply - { - func = join; - args; - kind = Join; - ty; - ty_args_ = [||]; - prim = None; - loc_ = loc; - } - -let rec let_ ?(loc = ghost_loc_) (name : Ident.t) (rhs : expr) (body : expr) : - expr = - let ty = type_of_expr body in - match (rhs, name) with - | Cexpr_function { func; _ }, Pident _ -> - Cexpr_letfn { name; fn = func; kind = Nonrec; body; ty; loc_ = loc } - | Cexpr_let { name = id2; rhs = rhs2; body = body2; ty = _; loc_ }, _ -> - if !Basic_config.debug then Cexpr_let { name; rhs; body; ty; loc_ = loc } - else - let body = let_ name body2 body in - let_ id2 rhs2 body ~loc:loc_ - | _ -> Cexpr_let { name; rhs; body; ty; loc_ = loc } +let const ?(loc = ghost_loc_) (c : constant) = + (let ty = + match c with + | C_int _ -> Stype.int + | C_byte _ -> Stype.byte + | C_int64 _ -> Stype.int64 + | C_uint _ -> Stype.uint + | C_uint64 _ -> Stype.uint64 + | C_float _ -> Stype.float + | C_double _ -> Stype.double + | C_char _ -> Stype.char + | C_bool _ -> Stype.bool + | C_string _ -> Stype.string + | C_bytes _ -> Stype.bytes + | C_bigint _ -> Stype.bigint + in + Cexpr_const { c; ty; loc_ = loc } + : expr) + +let unit ?(loc = ghost_loc_) () = (Cexpr_unit { loc_ = loc } : expr) + +let prim ?(loc = ghost_loc_) ~ty (prim : Primitive.prim) args = + (match (prim, args) with + | ( Parith { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_arith operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | Parith { operand_type = _; operator = Neg }, Cexpr_const { c; _ } :: [] + -> ( + match Constant.eval_negation c with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | ( Pbitwise { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_bitwise operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | ( Pcomparison { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_comparison operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | Pnot, Cexpr_const { c = C_bool b; _ } :: [] -> const ~loc (C_bool (not b)) + | _ -> Cexpr_prim { prim; args; ty; loc_ = loc } + : expr) + +let and_ ~loc lhs rhs = + (match lhs with + | Cexpr_const { c = C_bool b; _ } -> if b then rhs else lhs + | _ -> Cexpr_and { lhs; rhs; loc_ = loc } + : expr) + +let or_ ~loc lhs rhs = + (match lhs with + | Cexpr_const { c = C_bool b; _ } -> if b then lhs else rhs + | _ -> Cexpr_or { lhs; rhs; loc_ = loc } + : expr) + +let unsaturated_prim ?(loc = ghost_loc_) ~ty prim = + (match Stype.type_repr ty with + | Tarrow { params_ty; ret_ty; is_async; err_ty = _ } as ty -> + let params, args = + Lst.map_split params_ty (fun ty -> + (let id = Ident.fresh "*x" in + ( { binder = id; ty; loc_ = ghost_loc_ }, + Cexpr_var + { id; ty; ty_args_ = [||]; prim = None; loc_ = ghost_loc_ } ) + : param * expr)) + in + let body : expr = + Cexpr_prim { prim; args; ty = ret_ty; loc_ = ghost_loc_ } + in + Cexpr_function + { func = { params; body; is_async }; ty; is_raw_ = false; loc_ = loc } + | _ -> assert false + : expr) + +let join_apply ?(loc = ghost_loc_) ~ty join args = + (Cexpr_apply + { + func = join; + args; + kind = Join; + ty; + ty_args_ = [||]; + prim = None; + loc_ = loc; + } + : expr) + +let rec let_ ?(loc = ghost_loc_) (name : Ident.t) (rhs : expr) (body : expr) = + (let ty = type_of_expr body in + match (rhs, name) with + | Cexpr_function { func; is_raw_ = false; _ }, Pident _ -> + Cexpr_letfn { name; fn = func; kind = Nonrec; body; ty; loc_ = loc } + | Cexpr_let { name = id2; rhs = rhs2; body = body2; ty = _; loc_ }, _ -> + if !Basic_config.no_opt then + Cexpr_let { name; rhs; body; ty; loc_ = loc } + else + let body = let_ name body2 body in + let_ id2 rhs2 body ~loc:loc_ + | _ -> Cexpr_let { name; rhs; body; ty; loc_ = loc } + : expr) let letfn ?(loc = ghost_loc_) ~kind name fn body = let ty = type_of_expr body in @@ -2659,348 +3160,451 @@ let bind ?(loc = ghost_loc_) (rhs : expr) (cont : Ident.t -> expr) = let id = Ident.fresh "*bind" in let_ ~loc id rhs (cont id) -let field ?(loc = ghost_loc_) ~ty ~pos record accessor : expr = - Cexpr_field { record; accessor; pos; ty; loc_ = loc } - -let raise ?(loc = ghost_loc_) ~ty msg : expr = - Cexpr_prim { prim = Praise; args = [ const (C_string msg) ]; ty; loc_ = loc } - -let if_ ?(loc = ghost_loc_) ~ifso ?ifnot cond : expr = - match cond with - | Cexpr_const { c = C_bool true; _ } -> ifso - | Cexpr_const { c = C_bool false; _ } -> ( - match ifnot with Some ifnot -> ifnot | None -> unit ~loc ()) - | _ -> ( - match (ifso, ifnot) with - | ( Cexpr_const { c = C_bool true; _ }, - Some (Cexpr_const { c = C_bool false; _ }) ) -> - cond - | ( Cexpr_const { c = C_bool false; _ }, - Some (Cexpr_const { c = C_bool true; _ }) ) -> - prim ~loc ~ty:Stype.bool Pnot [ cond ] - | _ -> - let ty = type_of_expr ifso in - Cexpr_if { cond; ifso; ifnot; ty; loc_ = loc }) - -let letrec ~loc (bindings : (Ident.t * fn) list) body : expr = - let ty = type_of_expr body in - Cexpr_letrec { bindings; body; ty; loc_ = loc } - -let switch_constr ?(loc = ghost_loc_) ~default obj cases : expr = - match obj with - | Cexpr_constr { constr = _; tag; args; ty = _ } -> - let rec select_case tag arg cases default = - match cases with - | [] -> ( - match default with Some default -> default | None -> assert false) - | (tag', param, action) :: rest -> - if Constr_info.equal tag' tag then - match param with - | None -> action - | Some param -> let_ ~loc param obj action - else select_case tag arg rest default - in - select_case tag args cases default - | _ -> - let ty = - match cases with - | (_, _, action0) :: _ -> type_of_expr action0 - | [] -> ( - match default with - | Some default -> type_of_expr default - | None -> assert false) - in - Cexpr_switch_constr { obj; cases; default; ty; loc_ = loc } - -let handle_error ?(loc = ghost_loc_) obj handle_kind ~ty : expr = - Cexpr_handle_error { obj; handle_kind; ty; loc_ = loc } - -let return ?(loc = ghost_loc_) expr ~return_kind ~ty : expr = - Cexpr_return { expr; ty; return_kind; loc_ = loc } - -let switch_constant ?(loc = ghost_loc_) ~default obj cases : expr = - match obj with - | Cexpr_const { c; _ } -> - let rec select_case c cases default = - match cases with - | [] -> default - | (c', action) :: rest -> - if Constant.equal c' c then action else select_case c rest default - in - select_case c cases default - | _ -> - let ty = type_of_expr default in - Cexpr_switch_constant { obj; cases; default; ty; loc_ = loc } +let field ?(loc = ghost_loc_) ~ty ~pos record accessor = + (match record with + | Cexpr_record { fields; _ } -> (List.nth fields pos).expr + | Cexpr_tuple { exprs; _ } -> List.nth exprs pos + | _ -> Cexpr_field { record; accessor; pos; ty; loc_ = loc } + : expr) + +let panic ?(loc = ghost_loc_) ty = + (Cexpr_prim { prim = Ppanic; args = []; ty; loc_ = loc } : expr) + +let if_ ?(loc = ghost_loc_) ~ifso ?ifnot cond = + (match cond with + | Cexpr_const { c = C_bool true; _ } -> ifso + | Cexpr_const { c = C_bool false; _ } -> ( + match ifnot with Some ifnot -> ifnot | None -> unit ~loc ()) + | _ -> ( + match (ifso, ifnot) with + | ( Cexpr_const { c = C_bool true; _ }, + Some (Cexpr_const { c = C_bool false; _ }) ) -> + cond + | ( Cexpr_const { c = C_bool false; _ }, + Some (Cexpr_const { c = C_bool true; _ }) ) -> + prim ~loc ~ty:Stype.bool Pnot [ cond ] + | _, Some ifnot when expr_equal ifso ifnot -> + Cexpr_sequence + { + exprs = + [ + Cexpr_prim + { + prim = Pignore; + args = [ cond ]; + ty = Stype.unit; + loc_ = loc; + }; + ]; + last_expr = ifso; + ty = type_of_expr ifso; + loc_ = loc; + } + | _ -> + let ty = type_of_expr ifso in + Cexpr_if { cond; ifso; ifnot; ty; loc_ = loc }) + : expr) + +let letrec ~loc (bindings : (Ident.t * fn) list) body = + (let ty = type_of_expr body in + Cexpr_letrec { bindings; body; ty; loc_ = loc } + : expr) + +let switch_constr ?(loc = ghost_loc_) ~default obj cases = + (match obj with + | Cexpr_constr { tag; args; ty = _ } -> + let rec select_case tag arg cases default = + match cases with + | [] -> ( + match default with Some default -> default | None -> assert false) + | (tag', param, action) :: rest -> + if Constr_info.equal tag' tag then + match param with + | None -> action + | Some param -> + let_ ~loc param + (prim ~loc + ~ty:(Type.make_constr_type (type_of_expr obj) ~tag) + (Pcast { kind = Enum_to_constr }) + [ obj ]) + action + else select_case tag arg rest default + in + select_case tag args cases default + | _ -> + let ty = + match cases with + | (_, _, action0) :: _ -> type_of_expr action0 + | [] -> ( + match default with + | Some default -> type_of_expr default + | None -> assert false) + in + Cexpr_switch_constr { obj; cases; default; ty; loc_ = loc } + : expr) + +let handle_error ?(loc = ghost_loc_) obj handle_kind ~ty = + (Cexpr_handle_error { obj; handle_kind; ty; loc_ = loc } : expr) + +let return ?(loc = ghost_loc_) expr ~return_kind ~ty = + (match expr with + | Cexpr_continue { args; ty = _; label; loc_ } -> + Cexpr_continue { args; ty; label; loc_ } + | _ -> Cexpr_return { expr; ty; return_kind; loc_ = loc } + : expr) + +let switch_constant ?(loc = ghost_loc_) ~default obj cases = + (match obj with + | Cexpr_const { c; _ } -> + let rec select_case c cases default = + match cases with + | [] -> default + | (c', action) :: rest -> + if Constant.equal c' c then action else select_case c rest default + in + select_case c cases default + | _ -> + let ty = type_of_expr default in + Cexpr_switch_constant { obj; cases; default; ty; loc_ = loc } + : expr) let var ?(loc = ghost_loc_) ?(ty_args_ = [||]) ~ty ?(prim = None) (id : Ident.t) - : expr = - Cexpr_var { id; ty; ty_args_; prim; loc_ = loc } - -let as_ ?(loc = ghost_loc_) ~trait ~obj_type (expr : expr) : expr = - let ty = type_of_expr expr in - match ty with - | T_trait inner_trait -> - if Type_path.equal inner_trait trait then expr - else Cexpr_as { expr; trait; obj_type; loc_ = loc } - | _ -> Cexpr_as { expr; trait; obj_type; loc_ = loc } - -let function_ ?(loc = ghost_loc_) ~ty (params : param list) (body : expr) : expr = - Cexpr_function { func = { params; body }; ty; loc_ = loc } - -let record ?(loc = ghost_loc_) ~ty (fields : field_def list) : expr = - Cexpr_record { fields; ty; loc_ = loc } - -let record_update ?(loc = ghost_loc_) record fields fields_num : expr = - Cexpr_record_update - { record; fields; fields_num; ty = type_of_expr record; loc_ = loc } - -let mutate ?(loc = ghost_loc_) ~pos record label field : expr = - Cexpr_mutate { record; label; field; pos; ty = Stype.unit; loc_ = loc } - -let fn params body : fn = { params; body } - -let rec sequence ?(loc = ghost_loc_) (expr1 : expr) (expr2 : expr) : expr = - let exception Exit in - let ty2 = type_of_expr expr2 in - let rec never_return (e : expr) (ty : Stype.t) : expr = - let go e = never_return e ty [@@inline] in - let go_opt e = - match e with None -> None | Some e -> Some (go e) - [@@inline] - in - match e with - | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) - | Cexpr_letfn t -> ( - match t.kind with - | Tail_join | Nontail_join -> - letfn ~loc:t.loc_ ~kind:t.kind t.name - (fn t.fn.params (go t.fn.body)) - (go t.body) - | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body) - ) - | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) - | Cexpr_sequence t -> sequence ~loc:t.loc_ t.expr1 (go t.expr2) - | Cexpr_if t -> ( - match t.ifnot with - | None -> raise_notrace Exit - | Some ifnot -> - if_ ~loc:t.loc_ ~ifso:(go t.ifso) ~ifnot:(go ifnot) t.cond) - | Cexpr_switch_constr t -> - let cases = - Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) - in - let default = go_opt t.default in - switch_constr ~loc:t.loc_ t.obj cases ~default - | Cexpr_switch_constant t -> - let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in - let default = go t.default in - switch_constant ~loc:t.loc_ ~default t.obj cases - | Cexpr_loop _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ - | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ | Cexpr_tuple _ - | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ - | Cexpr_array _ | Cexpr_assign _ | Cexpr_as _ | Cexpr_handle_error _ -> - raise_notrace Exit - | Cexpr_continue { args; ty = _; label; loc_ } -> - Cexpr_continue { args; ty; label; loc_ } - | Cexpr_break { arg; ty = _; label; loc_ } -> - Cexpr_break { arg; ty; label; loc_ } - | Cexpr_return { expr; ty = _; loc_; return_kind } -> - Cexpr_return { expr; loc_; ty; return_kind } - in - try never_return expr1 ty2 - with Exit -> ( - match expr1 with - | Cexpr_unit _ -> expr2 - | _ -> Cexpr_sequence { expr1; expr2; ty = ty2; loc_ = loc }) - -let constr ?(loc = ghost_loc_) ~ty (constr : constr) (tag : constr_tag) - (args : expr list) : expr = - Cexpr_constr { constr; tag; args; ty; loc_ = loc } - -let tuple ?(loc = ghost_loc_) ~ty (exprs : expr list) : expr = - Cexpr_tuple { exprs; ty; loc_ = loc } - -let array ?(loc = ghost_loc_) ~ty (exprs : expr list) : expr = - Cexpr_array { exprs; ty; loc_ = loc } - -let assign ?(loc = ghost_loc_) (var : Ident.t) (expr : expr) : expr = - Cexpr_assign { var; expr; ty = Stype.unit; loc_ = loc } - -let loop ~loc (params : param list) (body : expr) (args : expr list) label : - expr = - Cexpr_loop { params; body; args; ty = type_of_expr body; label; loc_ = loc } - -let break ~loc_ arg label ty : expr = Cexpr_break { arg; ty; label; loc_ } - -let continue ?(loc = ghost_loc_) args label ty : expr = - Cexpr_continue { args; ty; label; loc_ = loc } + (Cexpr_var { id; ty; ty_args_; prim; loc_ = loc } : expr) + +let as_ ?(loc = ghost_loc_) ~trait ~obj_type (expr : expr) = + (let ty = type_of_expr expr in + match ty with + | T_trait inner_trait -> + if Type_path.equal inner_trait trait then expr + else Cexpr_as { expr; trait; obj_type; loc_ = loc } + | _ -> Cexpr_as { expr; trait; obj_type; loc_ = loc } + : expr) + +let function_ ?(loc = ghost_loc_) ~ty ~is_async (params : param list) + (body : expr) = + (Cexpr_function + { func = { params; body; is_async }; ty; is_raw_ = false; loc_ = loc } + : expr) + +let raw_function ?(loc = ghost_loc_) ~ty ~is_async (params : param list) + (body : expr) = + (Cexpr_function + { func = { params; body; is_async }; ty; is_raw_ = true; loc_ = loc } + : expr) + +let record ?(loc = ghost_loc_) ~ty (fields : field_def list) = + (Cexpr_record { fields; ty; loc_ = loc } : expr) + +let record_update ?(loc = ghost_loc_) record fields fields_num = + (Cexpr_record_update + { record; fields; fields_num; ty = type_of_expr record; loc_ = loc } + : expr) + +let mutate ?(loc = ghost_loc_) ~pos record label field = + (Cexpr_mutate { record; label; field; pos; ty = Stype.unit; loc_ = loc } + : expr) + +let fn params body = ({ params; body; is_async = false } : fn) + +exception Exit + +let rec never_return (e : expr) (ty : Stype.t) = + (let go e = never_return e ty [@@inline] in + let go_opt e = + match e with None -> None | Some e -> Some (go e) + [@@inline] + in + match e with + | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) + | Cexpr_letfn t -> ( + match t.kind with + | Tail_join | Nontail_join -> + letfn ~loc:t.loc_ ~kind:t.kind t.name + (fn t.fn.params (go t.fn.body)) + (go t.body) + | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) + | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) + | Cexpr_sequence t -> sequence ~loc:t.loc_ t.exprs (go t.last_expr) + | Cexpr_if t -> ( + match t.ifnot with + | None -> raise_notrace Exit + | Some ifnot -> + if_ ~loc:t.loc_ ~ifso:(go t.ifso) ~ifnot:(go ifnot) t.cond) + | Cexpr_switch_constr t -> + let cases = + Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) + in + let default = go_opt t.default in + switch_constr ~loc:t.loc_ t.obj cases ~default + | Cexpr_switch_constant t -> + let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in + let default = go t.default in + switch_constant ~loc:t.loc_ ~default t.obj cases + | Cexpr_loop _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ + | Cexpr_and _ | Cexpr_or _ | Cexpr_function _ | Cexpr_apply _ + | Cexpr_constr _ | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ + | Cexpr_field _ | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ + | Cexpr_as _ | Cexpr_handle_error _ -> + raise_notrace Exit + | Cexpr_continue { args; ty = _; label; loc_ } -> + Cexpr_continue { args; ty; label; loc_ } + | Cexpr_break { arg; ty = _; label; loc_ } -> + Cexpr_break { arg; ty; label; loc_ } + | Cexpr_return { expr; ty = _; loc_; return_kind } -> + Cexpr_return { expr; loc_; ty; return_kind } + : expr) + +and sequence2 ?(loc = ghost_loc_) (expr1 : expr) (expr2 : expr) = + (let ty2 = type_of_expr expr2 in + try never_return expr1 ty2 + with Exit -> ( + match expr1 with + | Cexpr_unit _ -> expr2 + | _ -> ( + match expr2 with + | Cexpr_sequence { exprs; last_expr; ty; loc_ } -> + Cexpr_sequence { exprs = expr1 :: exprs; last_expr; ty; loc_ } + | _ -> + Cexpr_sequence + { exprs = [ expr1 ]; last_expr = expr2; ty = ty2; loc_ = loc })) + : expr) + +and sequence ?(loc = ghost_loc_) (exprs : expr list) (last_expr : expr) = + (let ty2 = type_of_expr last_expr in + let make_sequence rev_exprs last_expr = + if rev_exprs = [] then last_expr + else + match last_expr with + | Cexpr_sequence { exprs = exprs2; last_expr; ty; loc_ = loc2 } -> + let loc_ = Rloc.merge loc loc2 in + Cexpr_sequence + { exprs = List.rev_append rev_exprs exprs2; last_expr; ty; loc_ } + | _ -> + Cexpr_sequence + { exprs = List.rev rev_exprs; last_expr; ty = ty2; loc_ = loc } + [@@inline] + in + let rec loop last_expr rev_exprs = function + | expr1 :: remain -> ( + match never_return expr1 ty2 with + | exception Exit -> ( + match expr1 with + | Cexpr_unit _ -> loop last_expr rev_exprs remain + | _ -> loop last_expr (expr1 :: rev_exprs) remain) + | expr1 -> make_sequence rev_exprs expr1) + | [] -> make_sequence rev_exprs last_expr + in + loop last_expr [] exprs + : expr) + +let constr ?(loc = ghost_loc_) ~ty (tag : constr_tag) (args : expr list) = + (Cexpr_constr { tag; args; ty; loc_ = loc } : expr) + +let tuple ?(loc = ghost_loc_) ~ty (exprs : expr list) = + (Cexpr_tuple { exprs; ty; loc_ = loc } : expr) + +let array ?(loc = ghost_loc_) ~ty (exprs : expr list) = + (Cexpr_array { exprs; ty; loc_ = loc } : expr) + +let assign ?(loc = ghost_loc_) (var : Ident.t) (expr : expr) = + (Cexpr_assign { var; expr; ty = Stype.unit; loc_ = loc } : expr) + +let loop ~loc (params : param list) (body : expr) (args : expr list) label = + (Cexpr_loop { params; body; args; ty = type_of_expr body; label; loc_ = loc } + : expr) + +let break ~loc_ arg label ty = (Cexpr_break { arg; ty; label; loc_ } : expr) + +let continue ?(loc = ghost_loc_) args label ty = + (Cexpr_continue { args; ty; label; loc_ = loc } : expr) let apply ?(loc = ghost_loc_) ~ty ?(ty_args_ = [||]) ?(prim = None) ~kind - (func : Ident.t) (args : expr list) : expr = - Cexpr_apply { func; args; kind; ty; ty_args_; prim; loc_ = loc } - -let rec tail_map (e : expr) (f : expr -> expr) : expr = - let go e = tail_map e f [@@inline] in - let go_opt e = - match e with None -> None | Some e -> Some (go e) - [@@inline] - in - match e with - | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) - | Cexpr_letfn t -> ( - match t.kind with - | Tail_join | Nontail_join -> - letfn ~loc:t.loc_ ~kind:t.kind t.name - (fn t.fn.params (go t.fn.body)) - (go t.body) - | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) - | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) - | Cexpr_sequence t -> sequence ~loc:t.loc_ t.expr1 (go t.expr2) - | Cexpr_if t -> - if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond - | Cexpr_switch_constr t -> - let cases = - Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) - in - let default = go_opt t.default in - switch_constr ~loc:t.loc_ t.obj cases ~default - | Cexpr_switch_constant t -> - let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in - let default = go t.default in - switch_constant ~loc:t.loc_ ~default t.obj cases - | Cexpr_loop t -> loop ~loc:t.loc_ t.params (go t.body) t.args t.label - | Cexpr_return _ | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ - | Cexpr_prim _ | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ - | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ - | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ - | Cexpr_as _ | Cexpr_handle_error _ -> - f e + (func : Ident.t) (args : expr list) = + (Cexpr_apply { func; args; kind; ty; ty_args_; prim; loc_ = loc } : expr) + +let rec tail_map (e : expr) (f : expr -> expr) = + (let go e = tail_map e f [@@inline] in + let go_opt e = + match e with None -> None | Some e -> Some (go e) + [@@inline] + in + match e with + | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) + | Cexpr_letfn t -> ( + match t.kind with + | Tail_join | Nontail_join -> + letfn ~loc:t.loc_ ~kind:t.kind t.name + (fn t.fn.params (go t.fn.body)) + (go t.body) + | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) + | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) + | Cexpr_sequence t -> sequence ~loc:t.loc_ t.exprs (go t.last_expr) + | Cexpr_if t -> + if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond + | Cexpr_switch_constr t -> + let cases = + Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) + in + let default = go_opt t.default in + switch_constr ~loc:t.loc_ t.obj cases ~default + | Cexpr_switch_constant t -> + let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in + let default = go t.default in + switch_constant ~loc:t.loc_ ~default t.obj cases + | Cexpr_loop t -> loop ~loc:t.loc_ t.params (go t.body) t.args t.label + | Cexpr_and { lhs; rhs; loc_ } -> and_ ~loc:loc_ lhs (go rhs) + | Cexpr_or { lhs; rhs; loc_ } -> or_ ~loc:loc_ lhs (go rhs) + | Cexpr_return _ | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ + | Cexpr_prim _ | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ + | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ + | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ + | Cexpr_as _ | Cexpr_handle_error _ -> + f e + : expr) exception Not_all_tuple_tail -let rec tuple_map (e : expr) ~ty ~join : expr = - let go e = tuple_map e ~ty ~join [@@inline] in - let go_opt e = - match e with None -> None | Some e -> Some (go e) - [@@inline] - in - match e with - | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) - | Cexpr_letfn t -> ( - match t.kind with - | Tail_join | Nontail_join -> - letfn ~loc:t.loc_ ~kind:t.kind t.name - (fn t.fn.params (go t.fn.body)) - (go t.body) - | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) - | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) - | Cexpr_sequence t -> sequence ~loc:t.loc_ t.expr1 (go t.expr2) - | Cexpr_if t -> - if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond - | Cexpr_switch_constr t -> - let cases = - Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) - in - let default = go_opt t.default in - switch_constr ~loc:t.loc_ t.obj cases ~default - | Cexpr_switch_constant t -> - let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in - let default = go t.default in - switch_constant ~loc:t.loc_ ~default t.obj cases - | Cexpr_loop t -> loop ~loc:t.loc_ t.params (go t.body) t.args t.label - | Cexpr_tuple { exprs; ty = _; loc_ = loc } -> join_apply ~loc ~ty join exprs - | Cexpr_return t -> go t.expr - | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ - | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ | Cexpr_record _ - | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ | Cexpr_array _ - | Cexpr_assign _ | Cexpr_continue _ | Cexpr_as _ | Cexpr_handle_error _ -> - raise_notrace Not_all_tuple_tail +let rec tuple_map (e : expr) ~ty ~join = + (let go e = tuple_map e ~ty ~join [@@inline] in + let go_opt e = + match e with None -> None | Some e -> Some (go e) + [@@inline] + in + match e with + | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) + | Cexpr_letfn t -> ( + match t.kind with + | Tail_join | Nontail_join -> + letfn ~loc:t.loc_ ~kind:t.kind t.name + (fn t.fn.params (go t.fn.body)) + (go t.body) + | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) + | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) + | Cexpr_sequence t -> sequence ~loc:t.loc_ t.exprs (go t.last_expr) + | Cexpr_if t -> + if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond + | Cexpr_switch_constr t -> + let cases = + Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) + in + let default = go_opt t.default in + switch_constr ~loc:t.loc_ t.obj cases ~default + | Cexpr_switch_constant t -> + let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in + let default = go t.default in + switch_constant ~loc:t.loc_ ~default t.obj cases + | Cexpr_loop t -> loop ~loc:t.loc_ t.params (go t.body) t.args t.label + | Cexpr_tuple { exprs; ty = _; loc_ = loc } -> join_apply ~loc ~ty join exprs + | Cexpr_return t -> go t.expr + | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ + | Cexpr_and _ | Cexpr_or _ | Cexpr_function _ | Cexpr_apply _ + | Cexpr_constr _ | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ + | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ + | Cexpr_as _ | Cexpr_handle_error _ -> + raise_notrace Not_all_tuple_tail + : expr) let tuple_map (e : expr) ~join_ty ~join ~ok ~err = try ok (tuple_map e ~ty:join_ty ~join) with Not_all_tuple_tail -> err () let joinlet_tail ?(loc = ghost_loc_) (name : Ident.t) (params : param list) - (join_body : expr) (body : expr) : expr = - let default () : expr = - letfn ~loc name (fn params join_body) ~kind:Tail_join body - [@@inline] - in - match (body : expr) with - | Cexpr_apply { kind = Join; func; args; ty = _; prim = _ } - when Ident.equal name func -> - Lst.fold_right2 params args join_body (fun param arg body -> - let_ param.binder arg body) - | _ -> ( - match (params, join_body) with - | [], (Cexpr_const _ | Cexpr_unit _) -> - tail_map body (fun tail_expr -> - match tail_expr with - | Cexpr_apply { func; _ } when Ident.equal func name -> join_body - | _ -> tail_expr) - | [], _ -> ( - let num_shots = ref 0 in - try - tail_map body (fun tail_expr -> - match tail_expr with - | Cexpr_apply { func; _ } when Ident.equal func name -> - incr num_shots; - if !num_shots = 1 then join_body else raise_notrace Exit - | _ -> tail_expr) - with Exit -> default ()) - | _, _ -> default ()) - -let rec if_with_commute ?loc ~ifso ?ifnot cond : expr = - match cond with - | Cexpr_if { cond = cond1; ifso = ifso1; ifnot = ifnot1; ty = _ } -> ( - let exception Exit in - let tail_map_branch expr = - tail_map expr (fun tail_expr -> - match tail_expr with - | Cexpr_const { c = C_bool true; _ } -> ifso - | Cexpr_const { c = C_bool false; _ } -> ( - match ifnot with Some ifnot -> ifnot | None -> unit ?loc ()) - | _ -> raise_notrace Exit) - in - try - let ifso2 = tail_map_branch ifso1 in - let ifnot2 = - match ifnot1 with - | Some ifnot1 -> Some (tail_map_branch ifnot1) - | None -> None - in - if_ cond1 ~ifso:ifso2 ?ifnot:ifnot2 ?loc - with Exit -> if_ cond ~ifso ?ifnot ?loc) - | Cexpr_let { name; rhs; body; ty = _; loc_ } -> - let body = if_with_commute ~ifso ?ifnot body in - let_ name rhs body ~loc:loc_ - | Cexpr_sequence { expr1; expr2; loc_; _ } -> - sequence ~loc:loc_ expr1 (if_with_commute expr2 ?loc ~ifso ?ifnot) - | _ -> if_ cond ~ifso ?ifnot ?loc + (join_body : expr) (body : expr) = + (let default () = + (letfn ~loc name (fn params join_body) ~kind:Tail_join body : expr) + [@@inline] + in + match (body : expr) with + | Cexpr_apply { kind = Join; func; args; ty = _; prim = _ } + when Ident.equal name func -> + Lst.fold_right2 params args join_body (fun param -> + fun arg -> fun body -> let_ param.binder arg body) + | _ -> ( + match (params, join_body) with + | [], (Cexpr_const _ | Cexpr_unit _) -> + tail_map body (fun tail_expr -> + match tail_expr with + | Cexpr_apply { func; _ } when Ident.equal func name -> join_body + | _ -> tail_expr) + | [], _ -> ( + let num_shots = ref 0 in + try + tail_map body (fun tail_expr -> + match tail_expr with + | Cexpr_apply { func; _ } when Ident.equal func name -> + incr num_shots; + if !num_shots = 1 then join_body else raise_notrace Exit + | _ -> tail_expr) + with Exit -> default ()) + | _, _ -> default ()) + : expr) + +let rec if_with_commute ?loc ~ifso ?ifnot cond = + (match cond with + | Cexpr_if { cond = cond1; ifso = ifso1; ifnot = ifnot1; ty = _ } -> ( + let exception Exit in + let tail_map_branch expr = + tail_map expr (fun tail_expr -> + match tail_expr with + | Cexpr_const { c = C_bool true; _ } -> ifso + | Cexpr_const { c = C_bool false; _ } -> ( + match ifnot with Some ifnot -> ifnot | None -> unit ?loc ()) + | _ -> raise_notrace Exit) + in + try + let ifso2 = tail_map_branch ifso1 in + let ifnot2 = + match ifnot1 with + | Some ifnot1 -> Some (tail_map_branch ifnot1) + | None -> None + in + if_ cond1 ~ifso:ifso2 ?ifnot:ifnot2 ?loc + with Exit -> if_ cond ~ifso ?ifnot ?loc) + | Cexpr_let { name; rhs; body; ty = _; loc_ } -> + let body = if_with_commute ~ifso ?ifnot body in + let_ name rhs body ~loc:loc_ + | Cexpr_sequence { exprs; last_expr; loc_; _ } -> + sequence ~loc:loc_ exprs (if_with_commute last_expr ?loc ~ifso ?ifnot) + | _ -> if_ cond ~ifso ?ifnot ?loc + : expr) let if_ ?loc ~ifso ?ifnot cond = if_with_commute ?loc ~ifso ?ifnot cond module Map = struct class virtual ['a] mapbase = object - method visit_prim : 'a -> Primitive.prim -> Primitive.prim = fun _ e -> e - method visit_constr_tag : 'a -> constr_tag -> constr_tag = fun _ e -> e - method visit_constr : 'a -> constr -> constr = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_accessor : 'a -> accessor -> accessor = fun _ e -> e - method visit_location : 'a -> location -> location = fun _ e -> e + method visit_prim : 'a -> Primitive.prim -> Primitive.prim = + fun _ -> fun e -> e + + method visit_constr_tag : 'a -> constr_tag -> constr_tag = + fun _ -> fun e -> e + + method visit_constr : 'a -> constr -> constr = fun _ -> fun e -> e + method visit_label : 'a -> label -> label = fun _ -> fun e -> e + method visit_accessor : 'a -> accessor -> accessor = fun _ -> fun e -> e + method visit_location : 'a -> location -> location = fun _ -> fun e -> e method visit_absolute_loc : 'a -> absolute_loc -> absolute_loc = - fun _ e -> e - - method visit_binder : 'a -> binder -> binder = fun _ e -> e - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_loop_label : 'a -> loop_label -> loop_label = fun _ e -> e - method visit_typ : 'a -> typ -> typ = fun _ e -> e - method visit_type_path : 'a -> type_path -> type_path = fun _ e -> e - method visit_tvar_env : 'a -> tvar_env -> tvar_env = fun _ e -> e - method visit_func_stubs : 'a -> func_stubs -> func_stubs = fun _ e -> e - method visit_return_kind : 'a -> return_kind -> return_kind = fun _ e -> e + fun _ -> fun e -> e + + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + + method visit_loop_label : 'a -> loop_label -> loop_label = + fun _ -> fun e -> e + + method visit_typ : 'a -> typ -> typ = fun _ -> fun e -> e + + method visit_type_path : 'a -> type_path -> type_path = + fun _ -> fun e -> e + + method visit_tvar_env : 'a -> tvar_env -> tvar_env = fun _ -> fun e -> e + + method visit_func_stubs : 'a -> func_stubs -> func_stubs = + fun _ -> fun e -> e + + method visit_return_kind : 'a -> return_kind -> return_kind = + fun _ -> fun e -> e end type _unused @@ -3014,1005 +3618,1231 @@ module Map = struct inherit [_] mapbase method visit_Ctop_expr : _ -> expr -> bool -> absolute_loc -> top_item = - fun env _visitors_fexpr _visitors_fis_main _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fis_main - in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_expr - { - expr = _visitors_r0; - is_main = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> top_item = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ - in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_let - { - binder = _visitors_r0; - expr = _visitors_r1; - is_pub_ = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_main + in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + Ctop_expr + { + expr = _visitors_r0; + is_main = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> top_item = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + Ctop_let + { + binder = _visitors_r0; + expr = _visitors_r1; + is_pub_ = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Ctop_fn : _ -> top_fun_decl -> top_item = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - Ctop_fn _visitors_r0 - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - bool -> - absolute_loc -> - top_item = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_freturn_ty - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ - in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_stub - { - binder = _visitors_r0; - func_stubs = _visitors_r1; - params_ty = _visitors_r2; - return_ty = _visitors_r3; - is_pub_ = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + Ctop_fn _visitors_r0 + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + bool -> + absolute_loc -> + top_item = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_freturn_ty + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + Ctop_stub + { + binder = _visitors_r0; + func_stubs = _visitors_r1; + params_ty = _visitors_r2; + return_ty = _visitors_r3; + is_pub_ = _visitors_r4; + loc_ = _visitors_r5; + } method visit_top_item : _ -> top_item -> top_item = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main - _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty _visitors_fis_pub_ - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_fis_main + _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fis_pub_ _visitors_floc_ method visit_subtop_fun_decl : _ -> subtop_fun_decl -> subtop_fun_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.fn in - { binder = _visitors_r0; fn = _visitors_r1 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.fn in + { binder = _visitors_r0; fn = _visitors_r1 } method visit_top_fun_decl : _ -> top_fun_decl -> top_fun_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_subtop_fun_decl env)) - _visitors_this.subtops - in - let _visitors_r3 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_pub_ - in - let _visitors_r5 = - self#visit_absolute_loc env _visitors_this.loc_ - in - { - binder = _visitors_r0; - func = _visitors_r1; - subtops = _visitors_r2; - ty_params_ = _visitors_r3; - is_pub_ = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_subtop_fun_decl env)) + _visitors_this.subtops + in + let _visitors_r3 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_pub_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_this.loc_ + in + { + binder = _visitors_r0; + func = _visitors_r1; + subtops = _visitors_r2; + ty_params_ = _visitors_r3; + is_pub_ = _visitors_r4; + loc_ = _visitors_r5; + } method visit_To_result : _ -> handle_kind = fun env -> To_result method visit_Joinapply : _ -> var -> handle_kind = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - Joinapply _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + Joinapply _visitors_r0 method visit_Return_err : _ -> typ -> handle_kind = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - Return_err { ok_ty = _visitors_r0 } + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + Return_err { ok_ty = _visitors_r0 } method visit_handle_kind : _ -> handle_kind -> handle_kind = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> expr = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_const - { c = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_const + { c = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Cexpr_unit : _ -> location -> expr = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - Cexpr_unit { loc_ = _visitors_r0 } - - method visit_Cexpr_var - : _ -> var -> typ -> typ array -> prim option -> location -> expr = - fun env _visitors_fid _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - Basic_arr.map _visitors_this (self#visit_typ env)) - _visitors_fty_args_ - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_prim env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_var - { - id = _visitors_r0; - ty = _visitors_r1; - ty_args_ = _visitors_r2; - prim = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_as - : _ -> expr -> type_path -> typ -> location -> expr = - fun env _visitors_fexpr _visitors_ftrait _visitors_fobj_type - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_path env _visitors_ftrait in - let _visitors_r2 = self#visit_typ env _visitors_fobj_type in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_as - { - expr = _visitors_r0; - trait = _visitors_r1; - obj_type = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> expr = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - (fun p args ty loc -> prim ~loc ~ty p args) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> expr = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_let - { - name = _visitors_r0; - rhs = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> expr - = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_letfn - { - name = _visitors_r0; - fn = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - kind = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Cexpr_function : _ -> fn -> typ -> location -> expr = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_function - { func = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> expr = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_letrec - { - bindings = _visitors_r0; - body = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - typ -> - typ array -> - prim option -> - location -> - expr = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> - Basic_arr.map _visitors_this (self#visit_typ env)) - _visitors_fty_args_ - in - let _visitors_r5 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_prim env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Cexpr_apply - { - func = _visitors_r0; - args = _visitors_r1; - kind = _visitors_r2; - ty = _visitors_r3; - ty_args_ = _visitors_r4; - prim = _visitors_r5; - loc_ = _visitors_r6; - } - - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> expr + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + Cexpr_unit { loc_ = _visitors_r0 } + + method visit_Cexpr_var : + _ -> var -> typ -> typ array -> prim option -> location -> expr = + fun env -> + fun _visitors_fid -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + Basic_arr.map _visitors_this (self#visit_typ env)) + _visitors_fty_args_ + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_prim env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_var + { + id = _visitors_r0; + ty = _visitors_r1; + ty_args_ = _visitors_r2; + prim = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_as : + _ -> expr -> type_path -> typ -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fobj_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_path env _visitors_ftrait in + let _visitors_r2 = self#visit_typ env _visitors_fobj_type in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_as + { + expr = _visitors_r0; + trait = _visitors_r1; + obj_type = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> expr = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + (fun p -> fun args -> fun ty -> fun loc -> prim ~loc ~ty p args) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_let + { + name = _visitors_r0; + rhs = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> expr = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_letfn + { + name = _visitors_r0; + fn = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + kind = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> expr = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_constr - { - constr = _visitors_r0; - tag = _visitors_r1; - args = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_function + { + func = _visitors_r0; + ty = _visitors_r1; + is_raw_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_letrec + { + bindings = _visitors_r0; + body = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + typ -> + typ array -> + prim option -> + location -> + expr = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_fty_args_ -> + fun _visitors_fprim -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + Basic_arr.map _visitors_this (self#visit_typ env)) + _visitors_fty_args_ + in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_prim env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + Cexpr_apply + { + func = _visitors_r0; + args = _visitors_r1; + kind = _visitors_r2; + ty = _visitors_r3; + ty_args_ = _visitors_r4; + prim = _visitors_r5; + loc_ = _visitors_r6; + } + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> expr = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_constr + { + tag = _visitors_r0; + args = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_tuple - { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> expr = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_record - { fields = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ffields_num - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_record_update - { - record = _visitors_r0; - fields = _visitors_r1; - fields_num = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_field - { - record = _visitors_r0; - accessor = _visitors_r1; - pos = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_mutate - { - record = _visitors_r0; - label = _visitors_r1; - field = _visitors_r2; - pos = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_tuple + { + exprs = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> expr = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_record + { + fields = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_ffields_num + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_record_update + { + record = _visitors_r0; + fields = _visitors_r1; + fields_num = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun record -> + fun accessor -> + fun pos -> + fun ty -> fun loc -> field ~loc record accessor ~pos ~ty) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_mutate + { + record = _visitors_r0; + label = _visitors_r1; + field = _visitors_r2; + pos = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } method visit_Cexpr_array : _ -> expr list -> typ -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_array - { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_array + { + exprs = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> expr = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_assign - { - var = _visitors_r0; - expr = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> expr = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - (fun expr1 expr2 ty loc_ -> sequence ~loc:loc_ expr1 expr2) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> expr = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun cond ifso ifnot ty loc -> if_ ~loc cond ~ifso ?ifnot) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - expr = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_binder env) t) - | None -> None) - _visitors_c1 - in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - (_visitors_r0, _visitors_r1, _visitors_r2))) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun obj cases default ty loc -> - switch_constr ~loc obj cases ~default) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - expr = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun obj cases default ty loc -> - switch_constant ~loc obj cases ~default) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - expr = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_loop - { - params = _visitors_r0; - body = _visitors_r1; - args = _visitors_r2; - label = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> expr = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - (fun arg label ty loc_ -> break arg label ty ~loc_) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> expr = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_continue - { - args = _visitors_r0; - label = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> expr = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_handle_error - { - obj = _visitors_r0; - handle_kind = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> expr = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_return - { - expr = _visitors_r0; - return_kind = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_assign + { + var = _visitors_r0; + expr = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + (fun expr1 -> + fun expr2 -> + fun ty -> fun loc_ -> sequence ~loc:loc_ expr1 expr2) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun cond -> + fun ifso -> + fun ifnot -> fun ty -> fun loc -> if_ ~loc cond ~ifso ?ifnot) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_binder env) t) + | None -> None) + _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + (_visitors_r0, _visitors_r1, _visitors_r2))) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constr ~loc obj cases ~default) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun obj -> + fun cases -> + fun default -> + fun ty -> + fun loc -> switch_constant ~loc obj cases ~default) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_loop + { + params = _visitors_r0; + body = _visitors_r1; + args = _visitors_r2; + label = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> expr = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + (fun arg -> + fun label -> fun ty -> fun loc_ -> break arg label ty ~loc_) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> expr = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_continue + { + args = _visitors_r0; + label = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_handle_error + { + obj = _visitors_r0; + handle_kind = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_return + { + expr = _visitors_r0; + return_kind = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_and : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + (fun lhs -> fun rhs -> fun loc -> and_ ~loc lhs rhs) + _visitors_r0 _visitors_r1 _visitors_r2 + + method visit_Cexpr_or : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + (fun lhs -> fun rhs -> fun loc -> or_ ~loc lhs rhs) + _visitors_r0 _visitors_r1 _visitors_r2 method visit_expr : _ -> expr -> expr = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fty - _visitors_fty_args_ _visitors_fprim _visitors_floc_ - | Cexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - obj_type = _visitors_fobj_type; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fobj_type _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - ty = _visitors_fty; - ty_args_ = _visitors_fty_args_; - prim = _visitors_fprim; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fty _visitors_fty_args_ - _visitors_fprim _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fty + _visitors_fty_args_ _visitors_fprim _visitors_floc_ + | Cexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + obj_type = _visitors_fobj_type; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fobj_type _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + ty = _visitors_fty; + ty_args_ = _visitors_fty_args_; + prim = _visitors_fprim; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fty _visitors_fty_args_ + _visitors_fprim _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> fn = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - { params = _visitors_r0; body = _visitors_r1 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_async + in + { + params = _visitors_r0; + body = _visitors_r1; + is_async = _visitors_r2; + } method visit_param : _ -> param -> param = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Normal : _ -> typ -> apply_kind = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - Normal { func_ty = _visitors_r0 } + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + Normal { func_ty = _visitors_r0 } + + method visit_Async : _ -> typ -> apply_kind = + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + Async { func_ty = _visitors_r0 } method visit_Join : _ -> apply_kind = fun env -> Join method visit_apply_kind : _ -> apply_kind -> apply_kind = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Async { func_ty = _visitors_ffunc_ty } -> + self#visit_Async env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> field_def = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.pos - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_mut - in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - { - label = _visitors_r0; - pos = _visitors_r1; - is_mut = _visitors_r2; - expr = _visitors_r3; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.pos + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_mut + in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + { + label = _visitors_r0; + pos = _visitors_r1; + is_mut = _visitors_r2; + expr = _visitors_r3; + } end [@@@VISITORS.END] diff --git a/src/core_dce.ml b/src/core_dce.ml index 214fdab..96d4085 100644 --- a/src/core_dce.ml +++ b/src/core_dce.ml @@ -26,6 +26,8 @@ let rec is_pure (expr : Core.expr) = | Cexpr_handle_error { handle_kind = To_result; obj; _ } -> is_pure obj | Cexpr_prim { prim; args; _ } -> Primitive.is_pure prim && Lst.for_all args is_pure + | Cexpr_and { lhs; rhs; _ } -> is_pure lhs && is_pure rhs + | Cexpr_or { lhs; rhs; _ } -> is_pure lhs && is_pure rhs | Cexpr_as { expr; _ } -> is_pure expr | Cexpr_constr { args; _ } -> Lst.for_all args is_pure | Cexpr_tuple { exprs; _ } -> Lst.for_all exprs is_pure @@ -40,7 +42,8 @@ let rec is_pure (expr : Core.expr) = is_pure record && Lst.for_all fields (fun { expr; _ } -> is_pure expr) | Cexpr_field { record; _ } -> is_pure record | Cexpr_array { exprs; _ } -> Lst.for_all exprs is_pure - | Cexpr_sequence { expr1; expr2; _ } -> is_pure expr1 && is_pure expr2 + | Cexpr_sequence { exprs; last_expr; _ } -> + Lst.for_all exprs is_pure && is_pure last_expr | Cexpr_if { cond; ifso; ifnot; _ } -> ( is_pure cond && is_pure ifso && match ifnot with None -> true | Some x -> is_pure x) @@ -78,13 +81,14 @@ let dce_visitor = else body method! visit_Cexpr_letrec env bindings body _ty loc = - Lst.iter bindings (fun (name, fn) -> Dce_context.add_func env name fn); + Lst.iter bindings ~f:(fun (name, fn) -> Dce_context.add_func env name fn); let body = self#visit_expr env body in let bindings = - Lst.fold_right bindings [] (fun (name, _) acc -> - if Dce_context.used env name then - (name, Dce_context.get_analyzed_fn env name) :: acc - else acc) + Lst.fold_right bindings [] (fun (name, _) -> + fun acc -> + if Dce_context.used env name then + (name, Dce_context.get_analyzed_fn env name) :: acc + else acc) in if bindings = [] then body else Core.letrec ~loc bindings body @@ -111,17 +115,17 @@ let mark_used_and_process_def env id = let eliminate_dead_code (prog : Core.program) = let ctx = Dce_context.make () in - Lst.iter prog (fun top -> + Lst.iter prog ~f:(fun top -> match top with | Ctop_expr _ -> () | Ctop_let { binder; expr } -> Dce_context.add_value ctx binder expr | Ctop_fn { binder; func; subtops; _ } -> Dce_context.add_func ctx binder func; - Lst.iter subtops (fun { binder; fn } -> + Lst.iter subtops ~f:(fun { binder; fn } -> Dce_context.add_func ctx binder fn) | Ctop_stub _ -> ()); let analyzed_top_exprs = Vec.empty () in - Lst.iter prog (fun top -> + Lst.iter prog ~f:(fun top -> match top with | Ctop_expr { expr; is_main; loc_ } -> Vec.push analyzed_top_exprs @@ -160,17 +164,19 @@ let eliminate_dead_code (prog : Core.program) = else let func = Dce_context.get_analyzed_fn ctx binder in let subtops = - Lst.fold_right subtops [] - (fun { binder; fn = _ } acc : Core.subtop_fun_decl list -> - if Dce_context.used ctx binder then - { binder; fn = Dce_context.get_analyzed_fn ctx binder } - :: acc - else acc) + Lst.fold_right subtops [] (fun { binder; fn = _ } -> + fun acc -> + (if Dce_context.used ctx binder then + { binder; fn = Dce_context.get_analyzed_fn ctx binder } + :: acc + else acc + : Core.subtop_fun_decl list)) in Core.Ctop_fn { binder; func; subtops; ty_params_; is_pub_; loc_ } :: aux rest i | Ctop_stub { binder; _ } -> if Dce_context.used ctx binder then top :: aux rest i else aux rest i) + [@@tail_mod_cons] in aux prog 0 diff --git a/src/core_format.ml b/src/core_format.ml index 0e935f2..fe0a016 100644 --- a/src/core_format.ml +++ b/src/core_format.ml @@ -15,6 +15,7 @@ module Iter_utils = Basic_iter_utils module Arr = Basic_arr +module Lst = Basic_lst type method_array = Method_env.method_array @@ -65,7 +66,8 @@ include struct methods = methods__021_; ext_methods = ext_methods__023_; pkg_name = pkg_name__025_; - } -> + } + -> let bnds__006_ = ([] : _ Stdlib.List.t) in let bnds__006_ = let arg__026_ = Moon_sexp_conv.sexp_of_string pkg_name__025_ in @@ -135,7 +137,8 @@ include struct methods = methods__042_; ext_methods = ext_methods__044_; pkg_name = pkg_name__046_; - } -> + } + -> let bnds__027_ = ([] : _ Stdlib.List.t) in let bnds__027_ = let arg__047_ = Moon_sexp_conv.sexp_of_string pkg_name__046_ in @@ -188,47 +191,57 @@ end let magic_str = Basic_config.core_magic_str let export (type t) ~(action : t Action.t) ~(pkg_name : string) - ~(program : Core.program) ~(genv : Global_env.t) : t = - let methods = - Method_env.export ~export_private:true (Global_env.get_method_env genv) - in - let ext_methods = - Global_env.get_ext_method_env genv - |> Ext_method_env.iter |> Iter_utils.to_array - in - let types = Global_env.get_toplevel_types genv |> Typing_info.get_all_types in - let traits = - Global_env.get_toplevel_types genv |> Typing_info.get_all_traits - in - let serialized : serialized = - { program; types; traits; pkg_name; methods; ext_methods } - in - match action with - | Write_file path -> - Out_channel.with_open_bin path (fun oc -> - output_string oc magic_str; - Marshal.to_channel oc [| serialized |] []) - | Return_bytes -> - let magic_bytes = Bytes.of_string magic_str in - let serialized_bytes = Marshal.to_bytes [| serialized |] [] in - Bytes.cat magic_bytes serialized_bytes + ~(program : Core.program) ~(genv : Global_env.t) = + (let methods = + Method_env.export ~export_private:true (Global_env.get_method_env genv) + in + let ext_methods = + Iter_utils.to_array + (Ext_method_env.iter (Global_env.get_ext_method_env genv)) + in + let types = Typing_info.get_all_types (Global_env.get_toplevel_types genv) in + let local_types = Global_env.all_local_types genv in + let traits = + Typing_info.get_all_traits (Global_env.get_toplevel_types genv) + in + let serialized : serialized = + { + program; + types = Array.append local_types types; + traits; + pkg_name; + methods; + ext_methods; + } + in + match action with + | Write_file path -> + Out_channel.with_open_bin path (fun oc -> + output_string oc magic_str; + Marshal.to_channel oc [| serialized |] []) + | Return_bytes -> + let magic_bytes = Bytes.of_string magic_str in + let serialized_bytes = Marshal.to_bytes [| serialized |] [] in + Bytes.cat magic_bytes serialized_bytes + : t) -let of_string (bin : string) : t array = - if String.starts_with ~prefix:magic_str bin then - let magic_str_len = String.length Basic_config.core_magic_str in - Arr.map - (Marshal.from_string bin magic_str_len : serialized array) - (fun serialized -> - let methods = Method_env.import serialized.methods in - { - program = serialized.program; - types = serialized.types; - traits = serialized.traits; - methods; - ext_methods = Ext_method_env.of_array serialized.ext_methods; - pkg_name = serialized.pkg_name; - }) - else assert false +let of_string (bin : string) = + (if String.starts_with ~prefix:magic_str bin then + let magic_str_len = String.length Basic_config.core_magic_str in + Arr.map + (Marshal.from_string bin magic_str_len : serialized array) + (fun serialized -> + let methods = Method_env.import serialized.methods in + { + program = serialized.program; + types = serialized.types; + traits = serialized.traits; + methods; + ext_methods = Ext_method_env.of_array serialized.ext_methods; + pkg_name = serialized.pkg_name; + }) + else assert false + : t array) let import ~(path : string) : t array = try @@ -237,18 +250,20 @@ let import ~(path : string) : t array = with Sys_error _ -> raise (Arg.Bad ("cannot open file: " ^ path)) -let dump_serialized_from_t (t : t array) : S.t = - let t_to_serialized (t : t) : serialized = - { - program = t.program; - types = t.types; - traits = t.traits; - methods = Method_env.export ~export_private:true t.methods; - ext_methods = t.ext_methods |> Ext_method_env.iter |> Iter_utils.to_array; - pkg_name = t.pkg_name; - } - in - Moon_sexp_conv.sexp_of_array sexp_of_serialized (Arr.map t t_to_serialized) +let dump_serialized_from_t (t : t array) = + (let t_to_serialized (t : t) = + ({ + program = t.program; + types = t.types; + traits = t.traits; + methods = Method_env.export ~export_private:true t.methods; + ext_methods = Iter_utils.to_array (Ext_method_env.iter t.ext_methods); + pkg_name = t.pkg_name; + } + : serialized) + in + Moon_sexp_conv.sexp_of_array sexp_of_serialized (Arr.map t t_to_serialized) + : S.t) let bundle ~inputs ~path = let pkgs = @@ -259,7 +274,7 @@ let bundle ~inputs ~path = match Basic_config.input_magic_str ic with | Some s when String.equal s magic_str -> (Marshal.from_channel ic : serialized array) - | _ -> (raise (Arg.Bad ("invalid MoonBit object file: " ^ path)))) + | _ -> raise (Arg.Bad ("invalid MoonBit object file: " ^ path))) with Sys_error _ -> raise (Arg.Bad ("cannot open file: " ^ path))) |> Array.concat diff --git a/src/core_link.ml b/src/core_link.ml index a699a86..5f38d17 100644 --- a/src/core_link.ml +++ b/src/core_link.ml @@ -25,28 +25,30 @@ type output = { type linking_target = File_path of string | Core_format of Core_format.t array -let link ~(targets : linking_target Vec.t) : output = - let types = Hash_string.create 17 in - let methods = Hash_string.create 17 in - let ext_methods = Hash_string.create 17 in - let append_core (serialized : Core_format.t) acc = - Hash_string.add types serialized.pkg_name - (Typing_info.init_types serialized.types serialized.traits); - Hash_string.add methods serialized.pkg_name serialized.methods; - Hash_string.add ext_methods serialized.pkg_name serialized.ext_methods; - List.rev_append serialized.program acc - in - let items_rev = - Vec.fold_left - ~f:(fun items_acc target -> - let pkgs = - match target with - | File_path path -> Core_format.import ~path - | Core_format pkgs -> pkgs - in - Array.fold_left - (fun items_acc pkg -> append_core pkg items_acc) - items_acc pkgs) - [] targets - in - { linked_program = List.rev items_rev; types; methods; ext_methods } +let link ~(targets : linking_target Vec.t) = + (let types = Hash_string.create 17 in + let methods = Hash_string.create 17 in + let ext_methods = Hash_string.create 17 in + let append_core (serialized : Core_format.t) acc = + Hash_string.add types serialized.pkg_name + (Typing_info.init_types serialized.types serialized.traits); + Hash_string.add methods serialized.pkg_name serialized.methods; + Hash_string.add ext_methods serialized.pkg_name serialized.ext_methods; + List.rev_append serialized.program acc + in + let items_rev = + Vec.fold_left + ~f:(fun items_acc -> + fun target -> + let pkgs = + match target with + | File_path path -> Core_format.import ~path + | Core_format pkgs -> pkgs + in + Array.fold_left + (fun items_acc -> fun pkg -> append_core pkg items_acc) + items_acc pkgs) + [] targets + in + { linked_program = List.rev items_rev; types; methods; ext_methods } + : output) diff --git a/src/core_of_tast.ml b/src/core_of_tast.ml index 649e270..4300581 100644 --- a/src/core_of_tast.ml +++ b/src/core_of_tast.ml @@ -21,14 +21,17 @@ module Hash_string = Basic_hash_string module Syntax = Parsing_syntax let ghost_loc_ = Rloc.no_location +let true_expr : Core.expr = Core.const ~loc:ghost_loc_ (C_bool true) +let false_expr : Core.expr = Core.const ~loc:ghost_loc_ (C_bool false) let mutable_var_label : Syntax.label = { label_name = "val"; loc_ = ghost_loc_ } -let mutable_var_type (ty : Core.typ) : Core.typ = Builtin.type_ref ty +let mutable_var_type (ty : Core.typ) = (Builtin.type_ref ty : Core.typ) type foreach_context = { result_var : Ident.t; exit_join : Ident.t; mutable has_early_exit : bool; foreach_result_ty : Stype.t; + jump_outer_ctx : Foreach_util.jump_outer_ctx; } type return_context = @@ -46,12 +49,38 @@ type loop_context = mutable need_for_loop_join : bool; } | Foreach of foreach_context - | No_loop + +type labeled_loop_context = + (Foreach_util.labelled_jump_info option * loop_context) list + +let get_outer_labels (ctx : labeled_loop_context) = + (Lst.fold_right ctx [] (fun (item, _) -> + fun acc -> match item with None -> acc | Some info -> info :: acc) + : Foreach_util.labelled_jump_info list) + +let find_loop_ctx ~(label : Label.t option) (ctx : labeled_loop_context) = + (match label with + | None -> `Normal_jump (snd (List.hd ctx)) + | Some label -> + let rec find_loop_ctx = function + | [] -> assert false + | ((label_info : Foreach_util.labelled_jump_info option), loop_ctx) + :: tl -> ( + match label_info with + | Some label_info when Label.equal label_info.label label -> + `Normal_jump loop_ctx + | Some _ | None -> ( + match loop_ctx with + | Foreach foreach_ctx -> `Jump_out_foreach foreach_ctx + | For_loop_info _ | Loop_label _ -> find_loop_ctx tl)) + in + find_loop_ctx ctx + : [ `Normal_jump of loop_context | `Jump_out_foreach of foreach_context ]) type transl_context = { return_ctx : return_context; error_ctx : error_context option; - loop_ctx : loop_context; + loop_ctx : labeled_loop_context; error_ty : Stype.t option; return_ty : Stype.t; wrapper_info : Stype.t option; @@ -64,7 +93,7 @@ let wrap_ok_prim expr ~result_ty = | Cexpr_let { body; _ } | Cexpr_letfn { body; kind = Rec | Nonrec; _ } | Cexpr_letrec { body; _ } - | Cexpr_sequence { expr2 = body; _ } -> + | Cexpr_sequence { last_expr = body; _ } -> tail_is_optimizable body | Cexpr_letfn { body; kind = Tail_join | Nontail_join; fn; _ } -> tail_is_optimizable body || tail_is_optimizable fn.body @@ -74,19 +103,21 @@ let wrap_ok_prim expr ~result_ty = match ifnot with | Some ifnot -> tail_is_optimizable ifnot | None -> false) - | Cexpr_switch_constr { cases; _ } -> + | Cexpr_switch_constr { cases; default; _ } -> ( Lst.exists cases (fun (_, _, action) -> tail_is_optimizable action) - | Cexpr_switch_constant { cases; _ } -> + || match default with Some x -> tail_is_optimizable x | _ -> false) + | Cexpr_switch_constant { cases; default; _ } -> Lst.exists cases (fun (_, action) -> tail_is_optimizable action) + || tail_is_optimizable default | Cexpr_handle_error { handle_kind = Joinapply _ | Return_err _; _ } | Cexpr_return _ | Cexpr_apply { kind = Join; _ } -> true | Cexpr_loop _ | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ - | Cexpr_prim _ | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ - | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ - | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ - | Cexpr_as _ | Cexpr_handle_error _ -> + | Cexpr_prim _ | Cexpr_and _ | Cexpr_or _ | Cexpr_function _ | Cexpr_apply _ + | Cexpr_constr _ | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ + | Cexpr_field _ | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ + | Cexpr_continue _ | Cexpr_as _ | Cexpr_handle_error _ -> false in let ok_tag = Builtin.constr_ok.cs_tag in @@ -95,1095 +126,1466 @@ let wrap_ok_prim expr ~result_ty = (Primitive.Pmake_value_or_error { tag = ok_tag }) [ expr ] in - let rec push_ok_to_tail (expr : Core.expr) : Core.expr = - match expr with - | Cexpr_let { body; loc_; name; rhs; ty = _ } -> - Core.let_ ~loc:loc_ name rhs (push_ok_to_tail body) - | Cexpr_letfn - { name; body; kind = (Rec | Nonrec) as kind; fn; loc_; ty = _ } -> - Core.letfn ~loc:loc_ ~kind name fn (push_ok_to_tail body) - | Cexpr_letfn - { - name; - body; - kind = (Tail_join | Nontail_join) as kind; - fn; - loc_; - ty = _; - } -> - let fn = { fn with body = push_ok_to_tail fn.body } in - Core.letfn ~loc:loc_ ~kind name fn (push_ok_to_tail body) - | Cexpr_letrec { body; bindings; loc_; ty = _ } -> - Core.letrec ~loc:loc_ bindings (push_ok_to_tail body) - | Cexpr_sequence { expr2 = body; expr1; ty = _ } -> - Core.sequence expr1 (push_ok_to_tail body) - | Cexpr_if { ifso; ifnot; cond; loc_; ty = _ } -> - let ifnot = - match ifnot with - | Some ifnot -> push_ok_to_tail ifnot - | None -> push_ok_to_tail (Core.unit ()) - in - Core.if_ ~loc:loc_ cond ~ifso:(push_ok_to_tail ifso) ~ifnot - | Cexpr_switch_constr { cases; default; obj; loc_; ty = _ } -> - let cases = - Lst.map cases (fun (tag, arg, action) -> - (tag, arg, push_ok_to_tail action)) - in - let default = Option.map push_ok_to_tail default in - Core.switch_constr ~loc:loc_ obj cases ~default - | Cexpr_switch_constant { cases; default; obj; loc_; ty = _ } -> - let cases = - Lst.map cases (fun (c, action) -> (c, push_ok_to_tail action)) - in - let default = push_ok_to_tail default in - Core.switch_constant ~loc:loc_ ~default obj cases - | Cexpr_handle_error { obj; handle_kind = Joinapply _ | Return_err _; _ } -> - obj - | Cexpr_return { expr; return_kind; loc_; ty = _ } -> - Core.return ~loc:loc_ ~return_kind expr ~ty:result_ty - | Cexpr_apply { kind = Join; func; args; ty = _; ty_args_; prim; loc_ } -> - Core.apply ~loc:loc_ ~ty_args_ ~prim ~kind:Join func args ~ty:result_ty - | Cexpr_loop _ | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ - | Cexpr_prim _ | Cexpr_function _ | Cexpr_apply _ | Cexpr_constr _ - | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ - | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ - | Cexpr_as _ | Cexpr_handle_error _ -> - wrap_ok_expr expr + let rec push_ok_to_tail (expr : Core.expr) = + (match expr with + | Cexpr_let { body; loc_; name; rhs; ty = _ } -> + Core.let_ ~loc:loc_ name rhs (push_ok_to_tail body) + | Cexpr_letfn + { name; body; kind = (Rec | Nonrec) as kind; fn; loc_; ty = _ } -> + Core.letfn ~loc:loc_ ~kind name fn (push_ok_to_tail body) + | Cexpr_letfn + { + name; + body; + kind = (Tail_join | Nontail_join) as kind; + fn; + loc_; + ty = _; + } -> + let fn = { fn with body = push_ok_to_tail fn.body } in + Core.letfn ~loc:loc_ ~kind name fn (push_ok_to_tail body) + | Cexpr_letrec { body; bindings; loc_; ty = _ } -> + Core.letrec ~loc:loc_ bindings (push_ok_to_tail body) + | Cexpr_sequence { exprs; last_expr = body; ty = _ } -> + Core.sequence exprs (push_ok_to_tail body) + | Cexpr_if { ifso; ifnot; cond; loc_; ty = _ } -> + let ifnot = + match ifnot with + | Some ifnot -> push_ok_to_tail ifnot + | None -> push_ok_to_tail (Core.unit ()) + in + Core.if_ ~loc:loc_ cond ~ifso:(push_ok_to_tail ifso) ~ifnot + | Cexpr_switch_constr { cases; default; obj; loc_; ty = _ } -> + let cases = + Lst.map cases (fun (tag, arg, action) -> + (tag, arg, push_ok_to_tail action)) + in + let default = Option.map push_ok_to_tail default in + Core.switch_constr ~loc:loc_ obj cases ~default + | Cexpr_switch_constant { cases; default; obj; loc_; ty = _ } -> + let cases = + Lst.map cases (fun (c, action) -> (c, push_ok_to_tail action)) + in + let default = push_ok_to_tail default in + Core.switch_constant ~loc:loc_ ~default obj cases + | Cexpr_handle_error { obj; handle_kind = Return_err _; _ } -> obj + | Cexpr_return { expr; return_kind; loc_; ty = _ } -> + Core.return ~loc:loc_ ~return_kind expr ~ty:result_ty + | Cexpr_apply { kind = Join; func; args; ty = _; ty_args_; prim; loc_ } -> + Core.apply ~loc:loc_ ~ty_args_ ~prim ~kind:Join func args ~ty:result_ty + | Cexpr_loop _ | Cexpr_break _ | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ + | Cexpr_prim _ | Cexpr_and _ | Cexpr_or _ | Cexpr_function _ + | Cexpr_apply _ | Cexpr_constr _ | Cexpr_tuple _ | Cexpr_record _ + | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ | Cexpr_array _ + | Cexpr_assign _ | Cexpr_continue _ | Cexpr_as _ | Cexpr_handle_error _ -> + wrap_ok_expr expr + : Core.expr) in if tail_is_optimizable expr then push_ok_to_tail expr else wrap_ok_expr expr let name_of_default_arg ~label (name_of_fn : Basic_ident.t) = match name_of_fn with - | Pident _ | Plocal_method _ | Pdyntrait_method _ -> assert false + | Plocal_method _ -> assert false + | Pident _ -> assert false + | Pdyntrait_method _ -> assert false | Pdot (Qregular { pkg; name }) | Pdot (Qregular_implicit_pkg { pkg; name }) -> Ident.of_qual_ident (Qregular { pkg; - name = Stdlib.String.concat "" [ name; "."; label; ".default" ]; + name = + Stdlib.String.concat "" + [ name; "."; label; ".default" ] [@merlin.hide]; }) | Pdot (Qmethod { self_typ; name }) -> Ident.of_qual_ident (Qmethod { self_typ; - name = Stdlib.String.concat "" [ name; "."; label; ".default" ]; + name = + Stdlib.String.concat "" + [ name; "."; label; ".default" ] [@merlin.hide]; }) | Pdot (Qext_method _) -> assert false let rec transl_expr ~(is_tail : bool) ~(need_wrap_ok : bool) - ~(global_env : Global_env.t) (ctx : transl_context) (texpr : Typedtree.expr) - : Core.expr = - let go_tail ~need_wrap_ok texpr = - transl_expr ~is_tail ~need_wrap_ok ~global_env ctx texpr - [@@inline] - in - let go_nontail texpr = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx texpr - [@@inline] - in - let wrap_ok core_expr = - if need_wrap_ok then - match ctx.wrapper_info with - | Some result_ty -> wrap_ok_prim core_expr ~result_ty - | None -> core_expr - else core_expr - [@@inline] - in - match texpr with - | Texpr_constant { c; ty = _; loc_ } -> ( - match c with - | C_bigint { v; _ } -> - let func = - match[@warning "-fragile-match"] - Global_env.find_dot_method global_env - ~type_name:Type_path.Builtin.type_path_bigint - ~method_name:"from_string" - with - | method_info :: [] -> - Typedtree.Texpr_method - { - type_name = - Tname_path - { - name = Type_path.Builtin.type_path_bigint; - kind = Type; - loc_; - }; - meth = - { - var_id = Basic_ident.of_qual_ident method_info.id; - loc_; - }; - prim = method_info.prim; - ty = method_info.typ; - ty_args_ = [||]; - arity_ = Some method_info.arity_; - loc_; - } - | _ -> assert false - in - let arg : Typedtree.argument = + ~(global_env : Global_env.t) ~(tvar_env : Tvar_env.t) (ctx : transl_context) + (texpr : Typedtree.expr) = + (let go_tail ~need_wrap_ok texpr = + transl_expr ~is_tail ~need_wrap_ok ~global_env ctx texpr ~tvar_env + [@@inline] + in + let go_nontail texpr = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx texpr + ~tvar_env + [@@inline] + in + let wrap_ok core_expr = + if need_wrap_ok then + match ctx.wrapper_info with + | Some result_ty -> wrap_ok_prim core_expr ~result_ty + | None -> core_expr + else core_expr + [@@inline] + in + match texpr with + | Texpr_constant { c; ty = _; loc_ } -> ( + match c with + | C_bigint { v; _ } -> + let func = + match[@warning "-fragile-match"] + Global_env.find_dot_method global_env + ~type_name:Type_path.Builtin.type_path_bigint + ~method_name:"from_string" + with + | method_info :: [] -> + Typedtree.Texpr_method + { + type_name = + Tname_path + { + name = Type_path.Builtin.type_path_bigint; + kind = Type; + loc_; + }; + meth = + { + var_id = Basic_ident.of_qual_ident method_info.id; + loc_; + }; + prim = method_info.prim; + ty = method_info.typ; + ty_args_ = [||]; + arity_ = Some method_info.arity_; + loc_; + } + | _ -> assert false + in + let arg : Typedtree.argument = + { + arg_value = + Texpr_constant + { + c = Constant.C_string (Basic_bigint.to_string v); + ty = Stype.string; + name_ = None; + loc_; + }; + arg_kind = Positional; + } + in + wrap_ok + (transl_apply ~global_env ~tvar_env ~ctx ~kind:`Normal ~loc_ + ~ty:Stype.bigint func [ arg ]) + | _ -> wrap_ok (Core.const ~loc:loc_ c)) + | Texpr_unit { loc_ } -> wrap_ok (Core.unit ~loc:loc_ ()) + | Texpr_ident { id = _; kind = Prim prim; ty; loc_ } + | Texpr_method { type_name = _; meth = _; prim = Some prim; ty; loc_ } + when not (Primitive.is_intrinsic prim) -> + wrap_ok (Core.unsaturated_prim ~loc:loc_ ~ty prim) + | Texpr_unresolved_method + { trait_name; method_name; self_type = self_ty; ty = expect_ty; loc_ } + -> ( + match[@warning "-fragile-match"] trait_name with + | Tname_path { name = trait; _ } | Tname_alias { name = trait; _ } -> ( + match + transl_trait_method ~global_env ~trait ~self_ty ~expect_ty + ~method_name + with + | `Prim prim -> + wrap_ok (Core.unsaturated_prim ~loc:loc_ ~ty:expect_ty prim) + | `Regular (id, ty_args_, prim) -> + wrap_ok (Core.var ~loc:loc_ ~ty:expect_ty ~ty_args_ ~prim id)) + | _ -> assert false) + | Texpr_ident { id = { var_id }; kind = Mutable; ty; ty_args_; loc_ } -> + wrap_ok + (Core.field ~ty ~pos:0 + (Core.var ~loc:loc_ ~ty:(mutable_var_type ty) ~ty_args_ + (Ident.of_ident var_id)) + (Label mutable_var_label)) + | Texpr_ident { id = { var_id }; kind = Normal; ty; ty_args_; loc_ } -> + wrap_ok (Core.var ~loc:loc_ ~ty ~ty_args_ (Ident.of_ident var_id)) + | Texpr_ident + { id = { var_id }; kind = Value_constr tag; ty; ty_args_; loc_ } -> + let constr_ty = Type.make_constr_type ty ~tag in + wrap_ok + (Core.prim ~ty + (Pcast { kind = Constr_to_enum }) + [ + Core.var ~loc:loc_ ~ty:constr_ty ~ty_args_ (Ident.of_ident var_id); + ]) + | Texpr_ident { id = { var_id }; kind = Prim prim; ty; ty_args_; loc_ } -> + wrap_ok + (Core.var ~loc:loc_ ~ty ~ty_args_ ~prim:(Some prim) + (Ident.of_ident var_id)) + | Texpr_method { type_name = _; meth; prim; ty; ty_args_; loc_ } -> + wrap_ok + (Core.var ~loc:loc_ ~ty ~ty_args_ ~prim (Ident.of_ident meth.var_id)) + | Texpr_as { expr; trait; ty = _; is_implicit = _; loc_ } -> ( + match trait with + | Tname_path { kind = Trait; name = trait } + | Tname_alias { kind = Trait; name = trait } -> + let obj_type = + Stype.type_repr (Typedtree_util.type_of_typed_expr expr) + in + let expr = go_nontail expr in + let expr_ty = Stype.type_repr (Core.type_of_expr expr) in + wrap_ok + (match expr_ty with + | T_trait expr_trait -> + if Type_path.equal expr_trait trait then expr + else Core.as_ ~loc:loc_ ~trait ~obj_type expr + | _ -> Core.as_ ~loc:loc_ ~trait ~obj_type expr) + | Tname_tvar _ | Tname_path _ | Tname_alias _ -> assert false) + | Texpr_let { pat; pat_binders; rhs; body; ty; loc_ } -> + Transl_match.transl_let ~global_env pat ~pat_binders (go_nontail rhs) + (go_tail ~need_wrap_ok body) + ~ty ~loc:loc_ + | Texpr_letmut { binder; konstraint = _; expr; body; ty = _; loc_ } -> + let expr = go_nontail expr in + let name = Ident.of_ident binder.binder_id in + Core.let_ ~loc:loc_ name + (Core.record + ~ty:(mutable_var_type (Core.type_of_expr expr)) + [ { label = mutable_var_label; pos = 0; expr; is_mut = true } ]) + (go_tail ~need_wrap_ok body) + | Texpr_function { func; ty; is_raw_; loc_ } -> + let ({ params; body; is_async } : Core.fn) = + transl_fn ~base:ctx.base func ~global_env ~tvar_env + in + if is_raw_ then + wrap_ok (Core.raw_function ~loc:loc_ ~ty ~is_async params body) + else wrap_ok (Core.function_ ~loc:loc_ ~ty ~is_async params body) + | Texpr_apply { kind_ = Dot_return_self; _ } + | Texpr_exclamation { expr = Texpr_apply { kind_ = Dot_return_self; _ }; _ } + -> + let rec desugar_cascade (expr : Typedtree.expr) + (k : Typedtree.expr -> Core.expr) = + match expr with + | Texpr_apply + { + func; + args = { arg_value = self; arg_kind = Positional } :: args; + ty = _; + kind_ = Dot_return_self; + loc_; + } -> + desugar_cascade self (fun actual_self -> + let args : Typedtree.argument list = + { arg_value = actual_self; arg_kind = Positional } :: args + in + let apply = + transl_apply ~global_env ~tvar_env ~ctx ~kind:`Normal ~loc_ + ~ty:Stype.unit func args + in + Core.sequence2 apply (k actual_self)) + | Texpr_exclamation + { + expr = + Texpr_apply + { + func; + args = { arg_value = self; arg_kind = Positional } :: args; + ty = _; + kind_ = Dot_return_self; + loc_ = apply_loc; + }; + convert_to_result; + ty = _; + loc_; + } -> + assert (not convert_to_result); + desugar_cascade self (fun actual_self -> + let args : Typedtree.argument list = + { arg_value = actual_self; arg_kind = Positional } :: args + in + let desugared_expr : Typedtree.expr = + Texpr_exclamation + { + expr = + Texpr_apply + { + func; + args; + ty = Stype.unit; + kind_ = Dot; + loc_ = apply_loc; + }; + convert_to_result; + ty = Stype.unit; + loc_; + } + in + let apply = go_nontail desugared_expr in + Core.sequence2 apply (k actual_self)) + | Texpr_ident { kind = Normal | Prim _ | Value_constr _; _ } -> k expr + | _ -> + let ty = Typedtree_util.type_of_typed_expr expr in + let tast_id = Basic_ident.fresh "self" in + let tast_self : Typedtree.expr = + Texpr_ident + { + id = { var_id = tast_id; loc_ = ghost_loc_ }; + ty_args_ = [||]; + arity_ = None; + kind = Normal; + ty; + loc_ = ghost_loc_; + } + in + let id = Ident.of_ident tast_id in + Core.let_ id (go_nontail expr) (k tast_self) + in + desugar_cascade texpr (fun self -> go_tail ~need_wrap_ok self) + | Texpr_apply { func = Texpr_constr _; args; ty } + when Global_env.is_newtype global_env ty -> ( + match[@warning "-fragile-match"] args with + | arg :: [] -> + wrap_ok + (Core.prim ~ty + (Pcast { kind = Make_newtype }) + [ go_nontail arg.arg_value ]) + | _ -> assert false) + | Texpr_and { lhs; rhs; loc_ } when Typedtree_util.cond_contains_is lhs -> + wrap_ok + (transl_cond_contain_is lhs ~global_env ~tvar_env ~ctx + ~true_case:(go_tail ~need_wrap_ok:false rhs) + ~false_case:false_expr ~loc_ ~in_pattern_guard:false) + | Texpr_or { lhs; rhs; loc_ } when Typedtree_util.cond_contains_is lhs -> + wrap_ok + (transl_cond_contain_is lhs ~global_env ~tvar_env ~ctx + ~true_case:true_expr + ~false_case:(go_tail ~need_wrap_ok:false rhs) + ~loc_ ~in_pattern_guard:false) + | Texpr_apply { func; args; ty; loc_ } -> + wrap_ok + (transl_apply ~global_env ~tvar_env ~ctx ~kind:`Normal ~loc_ ~ty func + args) + | Texpr_letrec { bindings; body; ty = _; loc_ } -> + let bindings = + Lst.map bindings (fun (binder, fn) -> + ( Ident.of_ident binder.binder_id, + transl_fn ~global_env ~base:ctx.base fn ~tvar_env )) + in + let body = go_tail ~need_wrap_ok body in + let fn_groups = Core_util.group_local_fn_bindings bindings in + Lst.fold_right fn_groups body (fun fn_group -> + fun body -> + match fn_group with + | Non_rec (name, fn) -> + Core.letfn ~loc:loc_ ~kind:Nonrec name fn body + | Rec ((name, fn) :: []) -> + Core.letfn ~loc:loc_ ~kind:Rec name fn body + | Rec bindings -> Core.letrec ~loc:loc_ bindings body) + | Texpr_letfn { binder; fn; body; is_rec; ty = _; loc_ } -> + let name = Ident.of_ident binder.binder_id in + let ({ params; body = fn_body; is_async } : Core.fn) = + transl_fn ~base:ctx.base ~global_env fn ~tvar_env + in + let body = go_tail ~need_wrap_ok body in + let kind = if is_rec then Core.Rec else Nonrec in + Core.letfn ~loc:loc_ ~kind name { params; body = fn_body; is_async } body + | Texpr_constr { type_name = _; constr = _; tag; ty; loc_ } -> + wrap_ok + (match Stype.type_repr ty with + | Tarrow { params_ty; ret_ty; is_async = _; err_ty = _ } -> + let params, args = + Lst.map_split params_ty (fun ty -> + let id = Ident.fresh "*x" in + let param : Core.param = + { binder = id; ty; loc_ = ghost_loc_ } + in + let arg = Core.var ~ty id in + (param, arg)) + in + let body : Core.expr = + if Global_env.is_newtype global_env ret_ty then + Core.prim ~ty:ret_ty (Pcast { kind = Make_newtype }) args + else Core.constr ~ty:ret_ty tag args + in + Core.function_ ~loc:loc_ ~ty params body ~is_async:false + | ty -> ( + match tag with + | Constr_tag_regular { repr_ = Integer value; _ } -> + let c = + Constant.C_int { v = Int32.of_int value; repr = None } + in + Core.const ~loc:loc_ c + | _ -> Core.constr ~loc:loc_ ~ty tag [])) + | Texpr_tuple { exprs; ty; loc_ } -> + wrap_ok (Core.tuple ~loc:loc_ ~ty (Lst.map exprs go_nontail)) + | Texpr_record { type_name = _; fields; ty; loc_ } -> + let fields = + Lst.map fields (transl_field_def ~global_env ~tvar_env ctx) + in + wrap_ok (Core.record ~loc:loc_ ~ty fields) + | Texpr_record_update { type_name = _; record; fields; all_fields; ty; loc_ } + -> + let fields_num = List.length all_fields in + if fields_num <= 6 then + Core.bind (go_nontail record) (fun record_id -> + let record_var = Core.var ~ty record_id in + let fields = + Lst.map all_fields (fun f -> + let pos = f.pos in + match + Lst.find_first fields (fun (Field_def { pos = p; _ }) -> + p = pos) + with + | Some field -> + transl_field_def ~global_env ~tvar_env ctx field + | None -> + let label : Parsing_syntax.label = + { label_name = f.field_name; loc_ = ghost_loc_ } + in + let accessor : Parsing_syntax.accessor = Label label in + let field = + Core.field ~ty:f.ty_field record_var ~pos accessor + in + let is_mut = f.mut in + { label; expr = field; pos; is_mut }) + in + wrap_ok (Core.record ~loc:loc_ ~ty fields)) + else + let record = go_nontail record in + let fields = + Lst.map fields (transl_field_def ~global_env ~tvar_env ctx) + in + wrap_ok (Core.record_update ~loc:loc_ record fields fields_num) + | Texpr_field { record; accessor = Newtype; pos = _; ty; loc_ } -> + let core_record = go_nontail record in + let newtype_info = + Option.get + (Global_env.get_newtype_info global_env + (Typedtree_util.type_of_typed_expr record)) + in + wrap_ok + (if newtype_info.recursive then + Core.prim ~loc:loc_ ~ty + (Pcast { kind = Unfold_rec_newtype }) + [ core_record ] + else Core.field ~loc:loc_ ~ty ~pos:0 core_record Newtype) + | Texpr_field { record; accessor; pos; ty; loc_ } -> + wrap_ok + (match record with + | Texpr_ident + { + id = { var_id }; + kind = Value_constr tag; + ty = var_ty; + ty_args_; + loc_; + } -> + Core.prim ~ty + (Penum_field { index = pos; tag }) + [ + Core.var + ~ty:(Type.make_constr_type var_ty ~tag) + ~ty_args_ ~loc:loc_ (Ident.of_ident var_id); + ] + | _ -> + let core_record = go_nontail record in + Core.field ~loc:loc_ ~ty ~pos core_record accessor) + | Texpr_mutate { record; label; field; pos; augmented_by; ty; loc_ } -> ( + let ty_field = Typedtree_util.type_of_typed_expr field in + match record with + | Texpr_ident + { + id = { var_id }; + kind = Value_constr tag; + ty = var_ty; + ty_args_; + loc_; + } -> + let core_record = + Core.var + ~ty:(Type.make_constr_type var_ty ~tag) + ~ty_args_ ~loc:loc_ (Ident.of_ident var_id) + in + let core_field = go_nontail field in + let rhs = + match augmented_by with + | None -> core_field + | Some fn -> + let lhs = + Core.prim ~ty:ty_field + (Penum_field { index = pos; tag }) + [ core_record ] + in + make_apply ~global_env ~tvar_env ~loc:ghost_loc_ ~ty:ty_field + ctx fn [ lhs; core_field ] + in + wrap_ok + (Core.prim ~loc:loc_ ~ty + (Pset_enum_field { index = pos; tag }) + [ core_record; rhs ]) + | _ -> ( + let core_record = go_nontail record in + let core_field = go_nontail field in + match augmented_by with + | None -> + wrap_ok (Core.mutate ~loc:loc_ ~pos core_record label core_field) + | Some fn -> + Core.bind core_record (fun var -> + let core_record = + Core.var ~ty:(Core.type_of_expr core_record) var + in + let lhs = + Core.field ~loc:loc_ ~ty:ty_field ~pos core_record + (Label label) + in + let rhs = + make_apply ~loc:ghost_loc_ ~ty:ty_field ~global_env + ~tvar_env ctx fn [ lhs; core_field ] + in + wrap_ok (Core.mutate ~loc:loc_ ~pos core_record label rhs)))) + | Texpr_array { exprs; ty; is_fixed_array = true; loc_ } -> + wrap_ok (Core.array ~loc:loc_ ~ty (Lst.map exprs go_nontail)) + | Texpr_array { exprs; ty; is_fixed_array = false; loc_ } -> + wrap_ok (Core_util.make_array_make (Lst.map exprs go_nontail) ~loc_ ~ty) + | Texpr_assign { var; expr; augmented_by; ty = _; loc_ } -> + let expr = go_nontail expr in + let id = Ident.of_ident var.var_id in + let ty = Core.type_of_expr expr in + let mut_var_ty = mutable_var_type ty in + let var : Core.expr = Core.var ~loc:var.loc_ ~ty:mut_var_ty id in + let rhs = + match augmented_by with + | None -> expr + | Some fn -> + let lhs = + Core.field ~ty ~pos:0 + (Core.var ~loc:loc_ ~ty:mut_var_ty id) + (Label mutable_var_label) + in + make_apply ~loc:ghost_loc_ ~ty ~global_env ~tvar_env ctx fn + [ lhs; expr ] + in + wrap_ok (Core.mutate ~loc:loc_ ~pos:0 var mutable_var_label rhs) + | Texpr_sequence { exprs; last_expr; ty = _; loc_ = _ } -> + let exprs = Lst.map exprs go_nontail in + let last_expr = go_tail ~need_wrap_ok last_expr in + Core.sequence exprs last_expr + | Texpr_if { cond; ifso; ifnot; ty = _; loc_ } -> + wrap_ok + (if Typedtree_util.cond_contains_is cond then + let ifso = go_tail ~need_wrap_ok:false ifso in + let ifnot = + match ifnot with + | Some ifnot -> (go_tail ~need_wrap_ok:false) ifnot + | None -> Core.unit () + in + transl_cond_contain_is cond ~global_env ~tvar_env ~ctx + ~true_case:ifso ~false_case:ifnot ~loc_ ~in_pattern_guard:false + else + let cond = go_nontail cond in + let ifso = go_tail ~need_wrap_ok:false ifso in + let ifnot = Option.map (go_tail ~need_wrap_ok:false) ifnot in + Core.if_ ~loc:loc_ cond ~ifso ?ifnot) + | Texpr_is { pat = _; expr = _; pat_binders = _; loc_ } as cond -> + wrap_ok + (transl_cond_contain_is cond ~global_env ~tvar_env ~ctx + ~true_case:true_expr ~false_case:false_expr ~loc_ + ~in_pattern_guard:false) + | Texpr_match { expr; cases; ty; loc_ } -> + let cases = transform_cases ~is_tail ~global_env ~tvar_env ~ctx cases in + wrap_ok + (Transl_match.transl_match ~global_env (go_nontail expr) cases ~ty + ~loc:loc_) + | Texpr_try { body; catch; catch_all; try_else; ty; err_ty; loc_ } -> + let try_join = Ident.fresh "*try" in + let try_join_param_id = Ident.fresh "*try_err" in + let join_param_var = Core.var ~ty:err_ty try_join_param_id in + let error_ctx = { raise_join = try_join; need_raise_join = false } in + let try_ctx = + { ctx with error_ctx = Some error_ctx; error_ty = Some err_ty } + in + let body = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env try_ctx body + ~tvar_env + in + let catch_cases = + if catch_all then + let binder_id = Basic_ident.fresh "*catchall" in + let binder : Typedtree.binder = { binder_id; loc_ = ghost_loc_ } in + let var : Typedtree.var = + { var_id = binder_id; loc_ = ghost_loc_ } + in + let pat : Typedtree.pat = + Tpat_var { binder; ty = err_ty; loc_ = ghost_loc_ } + in + let pat_binders : Typedtree.pat_binders = + [ { binder; binder_typ = err_ty } ] + in + let error_value : Typedtree.expr = + Texpr_ident + { + id = var; + ty_args_ = [||]; + arity_ = None; + kind = Normal; + ty = err_ty; + loc_ = ghost_loc_; + } + in + let action : Typedtree.expr = + Texpr_raise { error_value; ty; loc_ = ghost_loc_ } + in + let catch_all_case : Typedtree.match_case = + { pat; pat_binders; action; guard = None } + in + transform_cases + (catch @ [ catch_all_case ]) + ~is_tail ~global_env ~tvar_env ~ctx + else transform_cases catch ~is_tail ~global_env ~tvar_env ~ctx + in + let catch_body = + Transl_match.transl_match ~global_env join_param_var catch_cases ~ty + ~loc:loc_ + in + let body = + match try_else with + | None -> body + | Some try_else -> + let try_else_cases = + transform_cases try_else ~is_tail ~global_env ~tvar_env ~ctx + in + Core.bind ~loc:loc_ body (fun tmp -> + let tmp_var = Core.var ~ty:(Core.type_of_expr body) tmp in + Transl_match.transl_match ~global_env tmp_var try_else_cases + ~ty ~loc:loc_) + in + wrap_ok + (Core.letfn ~kind:Nontail_join try_join { - arg_value = - Texpr_constant - { - c = Constant.C_string (Basic_bigint.to_string v); - ty = Stype.string; - name_ = None; - loc_; - }; - arg_kind = Positional; + params = + [ + { binder = try_join_param_id; ty = err_ty; loc_ = ghost_loc_ }; + ]; + body = catch_body; + is_async = false; } - in - transl_apply ~global_env ~ctx ~kind:`Normal ~loc_ ~ty:Stype.bigint - func [ arg ] - |> wrap_ok - | _ -> Core.const ~loc:loc_ c |> wrap_ok) - | Texpr_unit { loc_ } -> Core.unit ~loc:loc_ () |> wrap_ok - | Texpr_ident { id = _; kind = Prim prim; ty; loc_ } - | Texpr_method { type_name = _; meth = _; prim = Some prim; ty; loc_ } - when not (Primitive.is_intrinsic prim) -> - Core.unsaturated_prim ~loc:loc_ ~ty prim |> wrap_ok - | Texpr_unresolved_method - { trait_name; method_name; self_type = self_ty; ty = expect_ty; loc_ } - -> ( - let trait = trait_name.name in - match - transl_trait_method ~global_env ~trait ~self_ty ~expect_ty ~method_name - with - | `Prim prim -> - Core.unsaturated_prim ~loc:loc_ ~ty:expect_ty prim |> wrap_ok - | `Regular (id, ty_args_, prim) -> - Core.var ~loc:loc_ ~ty:expect_ty ~ty_args_ ~prim id |> wrap_ok) - | Texpr_ident { id = { var_id }; kind = Mutable; ty; ty_args_; loc_ } -> - Core.field ~ty ~pos:0 - (Core.var ~loc:loc_ ~ty:(mutable_var_type ty) ~ty_args_ - (Ident.of_ident var_id)) - (Label mutable_var_label) - |> wrap_ok - | Texpr_ident { id = { var_id }; kind = Normal; ty; ty_args_; loc_ } -> - Core.var ~loc:loc_ ~ty ~ty_args_ (Ident.of_ident var_id) |> wrap_ok - | Texpr_ident { id = { var_id }; kind = Value_constr tag; ty; ty_args_; loc_ } - -> - let constr_ty = Type.make_constr_type ty ~tag in - Core.prim ~ty - (Pcast { kind = Constr_to_enum }) - [ Core.var ~loc:loc_ ~ty:constr_ty ~ty_args_ (Ident.of_ident var_id) ] - |> wrap_ok - | Texpr_ident { id = { var_id }; kind = Prim prim; ty; ty_args_; loc_ } -> - Core.var ~loc:loc_ ~ty ~ty_args_ ~prim:(Some prim) (Ident.of_ident var_id) - |> wrap_ok - | Texpr_method { type_name = _; meth; prim; ty; ty_args_; loc_ } -> - Core.var ~loc:loc_ ~ty ~ty_args_ ~prim (Ident.of_ident meth.var_id) - |> wrap_ok - | Texpr_as { expr; trait; ty = _; is_implicit = _; loc_ } -> ( - match trait with - | Tname_path { kind = Trait; name = trait } - | Tname_alias { kind = Trait; name = trait } -> - let obj_type = - Stype.type_repr (Typedtree_util.type_of_typed_expr expr) - in - let expr = go_nontail expr in - let expr_ty = Stype.type_repr (Core.type_of_expr expr) in - (match expr_ty with - | T_trait expr_trait -> - if Type_path.equal expr_trait trait then expr - else Core.as_ ~loc:loc_ ~trait ~obj_type expr - | _ -> Core.as_ ~loc:loc_ ~trait ~obj_type expr) - |> wrap_ok - | Tname_tvar _ | Tname_path _ | Tname_alias _ -> assert false) - | Texpr_let { pat; pat_binders; rhs; body; ty; loc_ } -> - Transl_match.transl_let ~global_env pat ~pat_binders (go_nontail rhs) - (go_tail ~need_wrap_ok body) - ~ty ~loc:loc_ - | Texpr_letmut { binder; konstraint = _; expr; body; ty = _; loc_ } -> - let expr = go_nontail expr in - let name = Ident.of_ident binder.binder_id in - Core.let_ ~loc:loc_ name - (Core.record - ~ty:(mutable_var_type (Core.type_of_expr expr)) - [ { label = mutable_var_label; pos = 0; expr; is_mut = true } ]) - (go_tail ~need_wrap_ok body) - | Texpr_function { func; ty; loc_ } -> - let ({ params; body } : Core.fn) = - transl_fn ~base:ctx.base func ~global_env - in - Core.function_ ~loc:loc_ ~ty params body |> wrap_ok - | Texpr_apply { kind_ = Dot_return_self; _ } - | Texpr_exclamation { expr = Texpr_apply { kind_ = Dot_return_self; _ }; _ } - -> - let rec desugar_cascade (expr : Typedtree.expr) - (k : Typedtree.expr -> Core.expr) = - match expr with - | Texpr_apply - { - func; - args = { arg_value = self; arg_kind = Positional } :: args; - ty = _; - kind_ = Dot_return_self; - loc_; - } -> - desugar_cascade self (fun actual_self -> - let args : Typedtree.argument list = - { arg_value = actual_self; arg_kind = Positional } :: args - in - let apply = - transl_apply ~global_env ~ctx ~kind:`Normal ~loc_ - ~ty:Stype.unit func args - in - Core.sequence apply (k actual_self)) - | Texpr_exclamation - { - expr = - Texpr_apply + body) + | Texpr_while { loop_cond; loop_body; while_else; ty; loc_; label } -> + let label, label_key = + match label with + | None -> (Label.fresh "*while", None) + | Some label -> + let break_type = + match while_else with + | None -> None + | Some while_else -> + Some (Typedtree_util.type_of_typed_expr while_else) + in + let continue_types = [] in + ( label.label, + Some + ({ + label = label.label; + break_type; + continue_types; + need_extra_no_payload_continue = false; + } + : Foreach_util.labelled_jump_info) ) + in + let ctx = + { ctx with loop_ctx = (label_key, Loop_label label) :: ctx.loop_ctx } + in + let body = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx + loop_body ~tvar_env + in + let body_with_continue = + Core.sequence2 body (Core.continue [] label ty) + in + let ifnot = Option.map (go_tail ~need_wrap_ok:false) while_else in + if Typedtree_util.cond_contains_is loop_cond then + let false_case = + match ifnot with None -> Core.unit () | Some ifnot -> ifnot + in + let body = + transl_cond_contain_is loop_cond ~global_env ~tvar_env ~ctx + ~true_case:body_with_continue ~false_case ~loc_ + ~in_pattern_guard:false + in + Core.loop ~loc:loc_ [] body [] label + else + wrap_ok + (let cond = go_nontail loop_cond in + Core.loop ~loc:loc_ [] + (Core.if_ cond ~ifso:body_with_continue ?ifnot) + [] label) + | Texpr_break { arg; ty; loc_; label } -> + if is_tail then + match arg with + | None -> Core.unit () + | Some arg -> go_tail ~need_wrap_ok:false arg + else + let arg = Option.map (go_tail ~need_wrap_ok:false) arg in + let label = + match label with None -> None | Some label -> Some label.label + in + transl_break ctx arg ~ty ~label ~loc_ + | Texpr_continue { args; ty; loc_; label } -> + let args = Lst.map args go_nontail in + let label = + match label with None -> None | Some label -> Some label.label + in + transl_continue ctx args ~ty ~label ~loc_ + | Texpr_loop { params; body; args; ty; loc_; label } -> + let params = + Lst.map params (fun p -> + (match p with + | Param { binder; ty; konstraint = _; kind = _ } -> { - func; - args = { arg_value = self; arg_kind = Positional } :: args; - ty = _; - kind_ = Dot_return_self; - loc_ = apply_loc; - }; - convert_to_result; - ty = _; - loc_; - } -> - assert (not convert_to_result); - desugar_cascade self (fun actual_self -> - let args : Typedtree.argument list = - { arg_value = actual_self; arg_kind = Positional } :: args - in - let desugared_expr : Typedtree.expr = - Texpr_exclamation - { - expr = - Texpr_apply - { - func; - args; - ty = Stype.unit; - kind_ = Dot; - loc_ = apply_loc; - }; - convert_to_result; - ty = Stype.unit; - loc_; - } - in - let apply = go_nontail desugared_expr in - Core.sequence apply (k actual_self)) - | Texpr_ident { kind = Normal | Prim _ | Value_constr _; _ } -> k expr - | _ -> - let ty = Typedtree_util.type_of_typed_expr expr in - let tast_id = Basic_ident.fresh "self" in - let tast_self : Typedtree.expr = - Texpr_ident + binder = Ident.of_ident binder.binder_id; + ty; + loc_ = binder.loc_; + } + | Discard_positional_param _ -> assert false + : Core.param)) + in + let label, label_key = + match label with + | None -> (Label.fresh "*loop", None) + | Some label -> + let break_type = Some ty in + let continue_types = + Lst.map args Typedtree_util.type_of_typed_expr + in + ( label.label, + Some + ({ + label = label.label; + break_type; + continue_types; + need_extra_no_payload_continue = false; + } + : Foreach_util.labelled_jump_info) ) + in + let ctx = + { ctx with loop_ctx = (label_key, Loop_label label) :: ctx.loop_ctx } + in + let body = + transl_expr ~is_tail ~need_wrap_ok:false ~global_env ctx body ~tvar_env + in + wrap_ok (Core.loop ~loc:loc_ params body (Lst.map args go_nontail) label) + | Texpr_for { binders; condition; steps; body; for_else; ty; loc_; label } -> + let params, init_values = + Lst.fold_right binders ([], []) (fun (binder, init) -> + fun (params, init_values) -> + let param : Core.param = { - id = { var_id = tast_id; loc_ = ghost_loc_ }; - ty_args_ = [||]; - arity_ = None; - kind = Normal; - ty; - loc_ = ghost_loc_; + binder = Ident.of_ident binder.binder_id; + ty = Typedtree_util.type_of_typed_expr init; + loc_ = binder.loc_; } - in - let id = Ident.of_ident tast_id in - Core.let_ id (go_nontail expr) (k tast_self) - in - desugar_cascade texpr (fun self -> go_tail ~need_wrap_ok self) - | Texpr_apply { func = Texpr_constr _; args; ty } - when Global_env.is_newtype global_env ty -> ( - match[@warning "-fragile-match"] args with - | arg :: [] -> - Core.prim ~ty - (Pcast { kind = Make_newtype }) - [ go_nontail arg.arg_value ] - |> wrap_ok - | _ -> assert false) - | Texpr_apply { func; args; ty; loc_ } -> - transl_apply ~global_env ~ctx ~kind:`Normal ~loc_ ~ty func args |> wrap_ok - | Texpr_letrec { bindings; body; ty = _; loc_ } -> - let bindings = - Lst.map bindings (fun (binder, fn) -> - ( Ident.of_ident binder.binder_id, - transl_fn ~global_env ~base:ctx.base fn )) - in - let body = go_tail ~need_wrap_ok body in - let fn_groups = Core_util.group_local_fn_bindings bindings in - Lst.fold_right fn_groups body (fun fn_group body -> - match fn_group with - | Non_rec (name, fn) -> Core.letfn ~loc:loc_ ~kind:Nonrec name fn body - | Rec ((name, fn) :: []) -> - Core.letfn ~loc:loc_ ~kind:Rec name fn body - | Rec bindings -> Core.letrec ~loc:loc_ bindings body) - | Texpr_letfn { binder; fn; body; is_rec; ty = _; loc_ } -> - let name = Ident.of_ident binder.binder_id in - let ({ params; body = fn_body } : Core.fn) = - transl_fn ~base:ctx.base ~global_env fn - in - let body = go_tail ~need_wrap_ok body in - let kind = if is_rec then Core.Rec else Nonrec in - Core.letfn ~loc:loc_ ~kind name { params; body = fn_body } body - | Texpr_constr { constr; tag; ty; loc_ } -> - (match Stype.type_repr ty with - | Tarrow { params_ty; ret_ty; err_ty = _ } -> - let params, args = - Lst.map_split params_ty (fun ty -> - let id = Ident.fresh "*x" in - let param : Core.param = - { binder = id; ty; loc_ = ghost_loc_ } - in - let arg = Core.var ~ty id in - (param, arg)) + in + (param :: params, go_nontail init :: init_values)) + in + let steps = + Lst.map params (fun p -> + match + Lst.find_opt steps (fun (step_binder, step_expr) -> + if Ident.equal p.binder (Ident.of_ident step_binder.var_id) + then Some step_expr + else None) + with + | None -> Core.var ~ty:p.ty p.binder + | Some step -> go_nontail step) + in + let body_loc = Typedtree.loc_of_typed_expr body in + let continue_join = Ident.fresh "*continue" in + let label, label_key = + match label with + | None -> (Label.fresh "*for", None) + | Some label -> + let break_type = + match for_else with + | None -> None + | Some for_else -> + Some (Typedtree_util.type_of_typed_expr for_else) + in + let continue_types = + Lst.map binders (fun (_, b) -> + Typedtree_util.type_of_typed_expr b) + in + ( label.label, + Some + ({ + label = label.label; + break_type; + continue_types; + need_extra_no_payload_continue = true; + } + : Foreach_util.labelled_jump_info) ) + in + let loop_info = + For_loop_info { continue_join; need_for_loop_join = false; label } + in + let ctx = + { ctx with loop_ctx = (label_key, loop_info) :: ctx.loop_ctx } + in + let body = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ~tvar_env + ctx body + in + let continue = Core.continue steps label ty in + let body_with_continue = + match loop_info with + | For_loop_info { need_for_loop_join = true; _ } -> + let apply = Core.join_apply ~ty continue_join [] in + Core.letfn ~kind:Nontail_join continue_join + { params = []; body = continue; is_async = false } + (Core.sequence2 ~loc:body_loc body apply) + | For_loop_info { need_for_loop_join = false; _ } -> + Core.sequence2 ~loc:body_loc body continue + | Loop_label _ | Foreach _ -> assert false + in + let ifnot = Option.map (go_tail ~need_wrap_ok:false) for_else in + let loop_body = + match condition with + | None -> body_with_continue + | Some cond -> + Core.if_ ~loc:body_loc ~ifso:body_with_continue ?ifnot + (go_nontail cond) + in + wrap_ok (Core.loop ~loc:loc_ params loop_body init_values label) + | Texpr_foreach + { binders; elem_tys; expr; body; else_block; ty; loc_; label } -> + let expr = go_nontail expr in + let result_var = Ident.fresh "*foreach_result" in + let jump_outer_ctx = + Foreach_util.make_jump_outer_ctx ~global_env ~tvar_env + (get_outer_labels ctx.loop_ctx) + in + let foreach_result_ty = + Foreach_util.type_foreach_result ty ctx.return_ty + (match ctx.error_ty with + | None -> Stype.unit + | Some err_ty -> err_ty) + jump_outer_ctx.payload_type + in + let exit_join = Ident.fresh "*foreach_exit" in + let body_err_ctx = + match ctx.error_ty with + | None -> None + | Some _ -> + Some + { + raise_join = Ident.fresh "*foreach_raise"; + need_raise_join = false; + } + in + let label_key = + match label with + | None -> None + | Some label -> + let break_type = + match else_block with + | None -> None + | Some else_block -> + Some (Typedtree_util.type_of_typed_expr else_block) + in + let continue_types = [] in + Some + ({ + label = label.label; + break_type; + continue_types; + need_extra_no_payload_continue = false; + } + : Foreach_util.labelled_jump_info) + in + let loop_ctx = + { + result_var; + exit_join; + has_early_exit = false; + foreach_result_ty; + jump_outer_ctx; + } + in + let body = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ~tvar_env + { + ctx with + loop_ctx = (label_key, Foreach loop_ctx) :: ctx.loop_ctx; + return_ctx = Foreach_return loop_ctx; + error_ctx = body_err_ctx; + } + body + in + let body = Core.sequence2 body Foreach_util.iter_result_continue in + let body = + match body_err_ctx with + | Some { need_raise_join = true; raise_join } -> ( + match[@warning "-fragile-match"] ctx.error_ty with + | Some error_ty -> + loop_ctx.has_early_exit <- true; + (match ctx.error_ctx with + | None -> () + | Some error_ctx -> error_ctx.need_raise_join <- true); + let err_value_param = Ident.fresh "*foreach_error" in + let err_value = + Core.constr ~ty:foreach_result_ty Foreach_util.error.cs_tag + [ Core.var ~ty:error_ty err_value_param ] + in + Core.letfn ~kind:Nontail_join raise_join + { + params = + [ + { + binder = err_value_param; + ty = error_ty; + loc_ = ghost_loc_; + }; + ]; + body = + Core.sequence2 + (Core.mutate ~pos:0 + (Core.var + ~ty:(mutable_var_type loop_ctx.foreach_result_ty) + loop_ctx.result_var) + mutable_var_label err_value) + Foreach_util.iter_result_end; + is_async = false; + } + body + | _ -> assert false) + | _ -> body + in + let body = + if loop_ctx.has_early_exit then + (let exit_join_param = Ident.fresh "*foreach_body_result" in + Core.letfn ~kind:Nontail_join exit_join + { + params = + [ + { + binder = exit_join_param; + ty = Stype.type_iter_result; + loc_ = ghost_loc_; + }; + ]; + body = Core.var ~ty:Stype.type_iter_result exit_join_param; + is_async = false; + }) + body + else body + in + let callback = + let params = + Lst.map2 binders elem_tys (fun binder -> + fun ty -> + (match binder with + | None -> { binder = Ident.fresh "*_"; ty; loc_ = ghost_loc_ } + | Some { binder_id; loc_ } -> + { binder = Ident.of_ident binder_id; ty; loc_ } + : Core.param)) + in + Core.function_ + ~ty: + (Builtin.type_arrow elem_tys Stype.type_iter_result ~err_ty:None + ~is_async:false) + ~is_async:false params body + in + let main_loop = + Core.bind ~loc:loc_ expr (fun expr_id -> + Core.apply expr_id [ callback ] ~ty:Stype.type_iter_result + ~loc:loc_ + ~kind: + (Normal + { + func_ty = + Builtin.type_arrow + [ Core.type_of_expr callback ] + Stype.type_iter_result ~err_ty:None ~is_async:false; + })) + in + let main_loop = Core.prim ~ty:Stype.unit Pignore [ main_loop ] in + if not loop_ctx.has_early_exit then + match else_block with + | None -> wrap_ok main_loop + | Some else_block -> + Core.sequence2 main_loop (go_tail ~need_wrap_ok else_block) + else + let postprocess = + let break_value = Ident.fresh "*break" in + let return_value = Ident.fresh "*return" in + let jump_outer_value = Ident.fresh "*jump_outer" in + let error_case = + match body_err_ctx with + | Some _ -> ( + match[@warning "-fragile-match"] ctx.error_ty with + | Some error_ty -> + let error_value = Ident.fresh "*error" in + ( Foreach_util.error.cs_tag, + Some error_value, + transl_raise ctx + (Foreach_util.get_first_enum_field error_value + Foreach_util.error.cs_tag ~ty:error_ty + ~constr_ty:foreach_result_ty) + ~ty ~loc_:ghost_loc_ ) + | _ -> assert false) + | None -> (Foreach_util.error.cs_tag, None, Core.prim ~ty Ppanic []) + in + let handle_jump_outer = + if Label.Map.is_empty jump_outer_ctx.constrs then + Core.prim ~ty Ppanic [] + else + let generate_cases (label : Label.t) + ({ + break_tag; + continue_tag; + break_type; + continue_types; + extra_continue_tag; + _; + } : + Foreach_util.jump_outer_constr_info) = + let break_binder, break_value = + match break_type with + | None -> (None, None) + | Some break_ty -> + let break_id = Ident.fresh "*break" in + let break_payload = + Foreach_util.get_first_enum_field break_id break_tag + ~constr_ty:jump_outer_ctx.payload_type ~ty:break_ty + in + (Some break_id, Some break_payload) + in + let break_case = + transl_break ctx break_value ~ty ~loc_ ~label:(Some label) + in + let continue_binder, continue_values = + if continue_types = [] then (None, []) + else + let id = Ident.fresh "*continue" in + let constr_ty = + Type.make_constr_type jump_outer_ctx.payload_type + ~tag:continue_tag + in + let v = Core.var ~ty:constr_ty id in + ( Some id, + Lst.mapi continue_types (fun i -> + fun ty -> + Core.prim ~ty + (Penum_field { index = i; tag = continue_tag }) + [ v ]) ) + in + let continue_case = + transl_continue ctx continue_values ~ty ~label:(Some label) + ~loc_ + in + match extra_continue_tag with + | Some extra_continue_tag -> + let extra_continue_case = + transl_continue ctx [] ~ty ~label:(Some label) ~loc_ + in + [ + (break_tag, break_binder, break_case); + (continue_tag, continue_binder, continue_case); + (extra_continue_tag, None, extra_continue_case); + ] + | None -> + [ + (break_tag, break_binder, break_case); + (continue_tag, continue_binder, continue_case); + ] + in + let cases = + Label.Map.fold jump_outer_ctx.constrs [] (fun label -> + fun info -> + fun acc -> Lst.append (generate_cases label info) acc) + in + Core.switch_constr + (Foreach_util.get_first_enum_field jump_outer_value + Foreach_util.jump_outer.cs_tag + ~ty:jump_outer_ctx.payload_type ~constr_ty:foreach_result_ty) + ~default:None cases + in + let jump_outer_case = + ( Foreach_util.jump_outer.cs_tag, + Some jump_outer_value, + handle_jump_outer ) + in + wrap_ok + (Core.switch_constr + (Core.field ~ty:foreach_result_ty ~pos:0 + (Core.var + ~ty:(mutable_var_type foreach_result_ty) + result_var) + (Label mutable_var_label)) + ~default:None + [ + ( Foreach_util.continue.cs_tag, + None, + match else_block with + | None -> Core.unit () + | Some else_block -> go_nontail else_block ); + ( Foreach_util.break.cs_tag, + Some break_value, + Foreach_util.get_first_enum_field break_value + Foreach_util.break.cs_tag ~ty ~constr_ty:foreach_result_ty + ); + ( Foreach_util.return.cs_tag, + Some return_value, + transl_return ~is_tail ctx + (Foreach_util.get_first_enum_field return_value + Foreach_util.return.cs_tag ~ty:ctx.return_ty + ~constr_ty:foreach_result_ty) + ~ty ~loc_:ghost_loc_ ); + error_case; + jump_outer_case; + ]) + in + Core.let_ result_var + (Core.record + ~ty:(mutable_var_type foreach_result_ty) + [ + { + label = mutable_var_label; + pos = 0; + is_mut = true; + expr = + Core.constr ~ty:foreach_result_ty + Foreach_util.continue.cs_tag []; + }; + ]) + (Core.sequence2 main_loop postprocess) + | Texpr_return { return_value; ty; loc_ } -> + let return_value = + match return_value with + | Some rt -> go_nontail rt + | None -> Core.unit () + in + if need_wrap_ok then + match ctx.wrapper_info with + | Some result_ty -> wrap_ok_prim return_value ~result_ty + | None -> assert false + else transl_return ctx ~is_tail return_value ~ty ~loc_ + | Texpr_raise { error_value; ty; loc_ } -> + let error_value = go_nontail error_value in + let ty = + if need_wrap_ok then + match ctx.wrapper_info with + | Some result_ty -> result_ty + | None -> ty + else ty + in + transl_raise ctx error_value ~ty ~loc_ + | Texpr_exclamation { expr; ty; loc_; convert_to_result } -> ( + let expr = go_nontail expr in + let result_ty = Core.type_of_expr expr in + let ok_ty, _ = + match result_ty with + | T_constr { type_constructor; tys = [ ok_ty; err_ty ] } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_multi_value_result -> + (ok_ty, err_ty) + | _ -> assert false + in + if convert_to_result then + wrap_ok (Core.handle_error ~loc:loc_ expr To_result ~ty) + else if need_wrap_ok then expr + else + match ctx.error_ctx with + | Some error_ctx -> + error_ctx.need_raise_join <- true; + Core.handle_error ~loc:loc_ expr (Joinapply error_ctx.raise_join) + ~ty:ok_ty + | None -> + let ctx_ok_ty = ctx.return_ty in + Core.handle_error ~loc:loc_ expr + (Return_err { ok_ty = ctx_ok_ty }) + ~ty:ok_ty) + | Texpr_hole { ty; loc_; kind = _ } -> + Core.panic ~loc:loc_ + (if need_wrap_ok then Option.get ctx.wrapper_info else ty) + | Texpr_constraint { expr; _ } -> go_tail ~need_wrap_ok expr + | Texpr_pipe + { + lhs = expr; + ty; + rhs = + Pipe_partial_apply + { + args; + func = + ( Texpr_ident _ | Texpr_method _ | Texpr_unresolved_method _ + | Texpr_constr _ ) as func; + loc_ = rhs_loc_; + }; + loc_ = _; + } + when Lst.for_all args (fun { arg_kind; _ } -> arg_kind = Positional) -> + wrap_ok + (transl_apply ~global_env ~tvar_env ~ctx ~ty ~loc_:rhs_loc_ + ~kind:(`Pipe (Typedtree.loc_of_typed_expr expr)) + func + ({ arg_value = expr; arg_kind = Positional } :: args)) + | Texpr_pipe { lhs = expr; rhs = body; ty; loc_ } -> + let var_id = Basic_ident.fresh "*lhs" in + let body = + let arg = + Typedtree.Texpr_ident + { + id = { var_id; loc_ = ghost_loc_ }; + kind = Normal; + ty = Typedtree_util.type_of_typed_expr expr; + ty_args_ = [||]; + arity_ = None; + loc_ = ghost_loc_; + } + in + match body with + | Typedtree.Pipe_partial_apply { func; args; loc_ } -> + wrap_ok + (transl_apply ~global_env ~tvar_env ~ctx ~ty ~loc_ + ~kind:(`Pipe (Typedtree.loc_of_typed_expr expr)) + func + ({ arg_value = arg; arg_kind = Positional } :: args)) + | _ -> assert false + in + Core.let_ ~loc:loc_ (Ident.of_ident var_id) (go_nontail expr) body + | Texpr_interp { elems; ty = _ } -> + let core_elems = + Lst.map elems (function + | Interp_lit s -> Core.const (C_string s) + | Interp_expr { expr; to_string } -> + transl_apply ~global_env ~tvar_env ~ctx ~kind:`Normal + ~ty:Stype.string + ~loc_:(Typedtree.loc_of_typed_expr expr) + to_string + [ { arg_value = expr; arg_kind = Positional } ]) + in + wrap_ok + (match core_elems with + | [] -> Core.const (C_string "") + | x :: xs -> + Lst.fold_left xs x (fun acc -> + fun x -> + Core.prim ~ty:Stype.string + (Pccall { func_name = "add_string"; arity = 2 }) + [ acc; x ])) + | Texpr_guard { cond; otherwise; body; loc_ = loc; ty } -> + let body = go_tail ~need_wrap_ok:false body in + let ifnot = + match otherwise with + | Some expr -> go_tail ~need_wrap_ok:false expr + | None -> Core.prim ~loc ~ty Primitive.Ppanic [] + in + wrap_ok + (if Typedtree_util.cond_contains_is cond then + transl_cond_contain_is cond ~global_env ~tvar_env ~ctx + ~true_case:body ~false_case:ifnot ~loc_:loc + ~in_pattern_guard:false + else + let cond = go_nontail cond in + let ifnot = Some ifnot in + Core.if_ ~loc cond ~ifso:body ?ifnot) + | Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; loc_; ty } -> + let ok_case = + { Typedtree.pat; pat_binders; action = body; guard = None } + in + let fail_cases = + match otherwise with Some cases -> cases | None -> [] + in + let expr = + Typedtree.Texpr_match + { + expr = rhs; + cases = ok_case :: fail_cases; + ty; + loc_; + match_loc_ = loc_; + } + in + go_tail ~need_wrap_ok expr + | Texpr_array_as_view { array; ty; loc_ } -> + let array = go_nontail array in + Core.bind array (fun arr_id -> + let arr_ty = Core.type_of_expr array in + let array = Core.var ~ty:arr_ty arr_id in + Core_util.make_array_unsafe_as_view array ~ty ~loc_) + | Texpr_and { lhs; rhs; loc_ } -> + let lhs = go_nontail lhs in + let rhs = go_nontail rhs in + wrap_ok (Core.and_ ~loc:loc_ lhs rhs) + | Texpr_or { lhs; rhs; loc_ } -> + let lhs = go_nontail lhs in + let rhs = go_nontail rhs in + wrap_ok (Core.or_ ~loc:loc_ lhs rhs) + : Core.expr) + +and transform_cases (cases : Typedtree.match_case list) ~(is_tail : bool) + ~(global_env : Global_env.t) ~(tvar_env : Tvar_env.t) + ~(ctx : transl_context) = + (let go_expr expr = + transl_expr ctx ~need_wrap_ok:false ~global_env ~tvar_env ~is_tail expr + [@@inline] + in + let rec go (cases : Typedtree.match_case list) = + (match cases with + | [] -> [] + | { pat; pat_binders; action; guard } :: rest -> + let guard, guard_binders = + match guard with + | None -> (None, []) + | Some guard -> + let loc = Typedtree.loc_of_typed_expr guard in + let guard_binders = Typedtree_util.pat_binders_of_cond guard in + ( Some + (if Typedtree_util.cond_contains_is guard then + fun ~true_case -> + fun ~false_case -> + transl_cond_contain_is guard ~global_env ~tvar_env ~ctx + ~true_case ~false_case ~loc_:loc + ~in_pattern_guard:true + else fun ~true_case -> + fun ~false_case -> + Core.if_ ~loc (go_expr guard) ~ifso:true_case + ?ifnot:(Some false_case)), + guard_binders ) in - let body : Core.expr = - if Global_env.is_newtype global_env ret_ty then - Core.prim ~ty:ret_ty (Pcast { kind = Make_newtype }) args - else Core.constr ~ty:ret_ty constr tag args + let case : Transl_match.case = + { + pat; + pat_binders; + action = go_expr action; + guard; + guard_binders; + inline_action = false; + } in - Core.function_ ~loc:loc_ ~ty params body - | ty -> - if Typeutil.is_only_tag_enum ty then - let tag = - match tag with - | Constr_tag_regular { index = tag; _ } -> tag - | Extensible_tag _ -> failwith "unimplemented" - in - let c = Constant.C_int { v = Int32.of_int tag; repr = None } in - Core.const ~loc:loc_ c - else Core.constr ~loc:loc_ ~ty constr tag []) - |> wrap_ok - | Texpr_tuple { exprs; ty; loc_ } -> - Core.tuple ~loc:loc_ ~ty (List.map go_nontail exprs) |> wrap_ok - | Texpr_record { type_name = _; fields; ty; loc_ } -> - let fields = List.map (transl_field_def ~global_env ctx) fields in - Core.record ~loc:loc_ ~ty fields |> wrap_ok - | Texpr_record_update { type_name = _; record; fields; all_fields; ty; loc_ } - -> - let fields_num = List.length all_fields in - if fields_num <= 6 then - Core.bind - (transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx record) - (fun record_id -> - let record_var = Core.var ~ty record_id in - let fields = - Lst.map all_fields (fun f -> - let pos = f.pos in - match - Lst.find_first fields (fun (Field_def { pos = p; _ }) -> - p = pos) - with - | Some field -> transl_field_def ~global_env ctx field - | None -> - let label : Parsing_syntax.label = - { label_name = f.field_name; loc_ = ghost_loc_ } - in - let accessor : Parsing_syntax.accessor = Label label in - let field = - Core.field ~ty:f.ty_field record_var ~pos accessor - in - let is_mut = f.mut in - { label; expr = field; pos; is_mut }) - in - Core.record ~loc:loc_ ~ty fields |> wrap_ok) - else - let record = go_nontail record in - let fields = List.map (transl_field_def ~global_env ctx) fields in - Core.record_update ~loc:loc_ record fields fields_num |> wrap_ok - | Texpr_field { record; accessor = Newtype; pos = _; ty; loc_ } -> - let core_record = go_nontail record in - let newtype_info = - Global_env.get_newtype_info global_env - (Typedtree_util.type_of_typed_expr record) - |> Option.get - in - (if newtype_info.recursive then - Core.prim ~loc:loc_ ~ty - (Pcast { kind = Unfold_rec_newtype }) - [ core_record ] - else Core.field ~loc:loc_ ~ty ~pos:0 core_record Newtype) - |> wrap_ok - | Texpr_field { record; accessor; pos; ty; loc_ } -> - (match record with - | Texpr_ident + case :: go rest + : Transl_match.case list) + [@@tail_mod_cons] + in + go cases + : Transl_match.case list) + +and transl_cond_contain_is (cond : Typedtree.expr) ~global_env ~tvar_env ~ctx + ~(true_case : Core.expr) ~(false_case : Core.expr) + ~(in_pattern_guard : bool) ~loc_ = + let go_nontail expr = + transl_expr ~global_env ~is_tail:false ~need_wrap_ok:false ctx expr + ~tvar_env + [@@inline] + in + let go_cond cond ~true_case ~false_case = + transl_cond_contain_is cond ~global_env ~tvar_env ~ctx ~true_case + ~false_case ~loc_ ~in_pattern_guard + [@@inline] + in + match cond with + | Texpr_is { pat; expr; pat_binders; loc_ = _ } -> + let ty = Core.type_of_expr true_case in + let pat_ty = Typedtree_util.type_of_pat pat in + let cases : Transl_match.case list = + [ { - id = { var_id }; - kind = Value_constr tag; - ty = var_ty; - ty_args_; - loc_; - } -> - Core.prim ~ty - (Penum_field { index = pos; tag }) - [ - Core.var - ~ty:(Type.make_constr_type var_ty ~tag) - ~ty_args_ ~loc:loc_ (Ident.of_ident var_id); - ] - | _ -> - let core_record = go_nontail record in - Core.field ~loc:loc_ ~ty ~pos core_record accessor) - |> wrap_ok - | Texpr_mutate { record; label; field; pos; augmented_by; ty; loc_ } -> ( - let ty_field = Typedtree_util.type_of_typed_expr field in - match record with - | Texpr_ident + pat; + pat_binders; + action = true_case; + guard = None; + guard_binders = []; + inline_action = in_pattern_guard; + }; { - id = { var_id }; - kind = Value_constr tag; - ty = var_ty; - ty_args_; - loc_; - } -> - let core_record = - Core.var - ~ty:(Type.make_constr_type var_ty ~tag) - ~ty_args_ ~loc:loc_ (Ident.of_ident var_id) - in - let core_field = go_nontail field in - let rhs = - match augmented_by with - | None -> core_field - | Some fn -> - let lhs = - Core.prim ~ty:ty_field - (Penum_field { index = pos; tag }) - [ core_record ] - in - make_apply ~global_env ~loc:ghost_loc_ ~ty:ty_field ctx fn - [ lhs; core_field ] - in - Core.prim ~loc:loc_ ~ty - (Pset_enum_field { index = pos; tag }) - [ core_record; rhs ] - |> wrap_ok - | _ -> ( - let core_record = go_nontail record in - let core_field = go_nontail field in - match augmented_by with - | None -> - Core.mutate ~loc:loc_ ~pos core_record label core_field |> wrap_ok - | Some fn -> - Core.bind core_record (fun var -> - let core_record = - Core.var ~ty:(Core.type_of_expr core_record) var - in - let lhs = - Core.field ~loc:loc_ ~ty:ty_field ~pos core_record - (Label label) - in - let rhs = - make_apply ~loc:ghost_loc_ ~ty:ty_field ~global_env ctx fn - [ lhs; core_field ] - in - Core.mutate ~loc:loc_ ~pos core_record label rhs |> wrap_ok))) - | Texpr_array { exprs; ty; is_fixed_array = true; loc_ } -> - Core.array ~loc:loc_ ~ty (List.map go_nontail exprs) |> wrap_ok - | Texpr_array { exprs; ty; is_fixed_array = false; loc_ } -> - Core.prim ~loc:loc_ ~ty Parray_make (List.map go_nontail exprs) |> wrap_ok - | Texpr_assign { var; expr; augmented_by; ty = _; loc_ } -> - let expr = go_nontail expr in - let id = Ident.of_ident var.var_id in - let ty = Core.type_of_expr expr in - let mut_var_ty = mutable_var_type ty in - let var : Core.expr = Core.var ~loc:var.loc_ ~ty:mut_var_ty id in - let rhs = - match augmented_by with - | None -> expr - | Some fn -> - let lhs = - Core.field ~ty ~pos:0 - (Core.var ~loc:loc_ ~ty:mut_var_ty id) - (Label mutable_var_label) - in - make_apply ~loc:ghost_loc_ ~ty ~global_env ctx fn [ lhs; expr ] - in - Core.mutate ~loc:loc_ ~pos:0 var mutable_var_label rhs |> wrap_ok - | Texpr_sequence { expr1; expr2; ty = _; loc_ } -> - let expr1 = go_nontail expr1 in - let expr2 = go_tail ~need_wrap_ok expr2 in - Core.sequence ~loc:loc_ expr1 expr2 - | Texpr_if { cond; ifso; ifnot; ty = _; loc_ } -> - let cond = go_nontail cond in - let ifso = go_tail ~need_wrap_ok:false ifso in - let ifnot = Option.map (go_tail ~need_wrap_ok:false) ifnot in - Core.if_ ~loc:loc_ cond ~ifso ?ifnot |> wrap_ok - | Texpr_match { expr; cases; ty; loc_ } -> - let cases = - Lst.map cases (fun { pat; pat_binders; action } -> - (pat, pat_binders, go_tail ~need_wrap_ok:false action)) + pat = Tpat_any { ty = pat_ty; loc_ = ghost_loc_ }; + pat_binders = []; + action = false_case; + guard = None; + guard_binders = []; + inline_action = false; + }; + ] in Transl_match.transl_match ~global_env (go_nontail expr) cases ~ty ~loc:loc_ - |> wrap_ok - | Texpr_try { body; catch; catch_all; try_else; ty; err_ty; loc_ } -> - let try_join = Ident.fresh "*try" in - let try_join_param_id = Ident.fresh "*try_err" in - let join_param_var = Core.var ~ty:err_ty try_join_param_id in - let error_ctx = { raise_join = try_join; need_raise_join = false } in - let try_ctx = - { ctx with error_ctx = Some error_ctx; error_ty = Some err_ty } - in - let body = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env try_ctx body - in - let catch_cases = - if catch_all then - let binder_id = Basic_ident.fresh "*catchall" in - let binder : Typedtree.binder = { binder_id; loc_ = ghost_loc_ } in - let var : Typedtree.var = { var_id = binder_id; loc_ = ghost_loc_ } in - let pat : Typedtree.pat = - Tpat_var { binder; ty = err_ty; loc_ = ghost_loc_ } + | Texpr_and { lhs; rhs; loc_ } -> ( + match false_case with + | Cexpr_const _ | Cexpr_apply { kind = Join; _ } -> + let new_true_case = go_cond rhs ~true_case ~false_case in + go_cond lhs ~true_case:new_true_case ~false_case + | _ -> + let binder = Ident.fresh "*else" in + let new_false_case = + Core.join_apply binder [] ~ty:(Core.type_of_expr true_case) in - let pat_binders : Typedtree.pat_binders = - [ { binder; binder_typ = err_ty } ] + let new_true_case = + go_cond rhs ~true_case ~false_case:new_false_case in - let error_value : Typedtree.expr = - Texpr_ident - { - id = var; - ty_args_ = [||]; - arity_ = None; - kind = Normal; - ty = err_ty; - loc_ = ghost_loc_; - } + let body = + go_cond lhs ~true_case:new_true_case ~false_case:new_false_case in - let action : Typedtree.expr = - Texpr_raise { error_value; ty; loc_ = ghost_loc_ } + Core.joinlet_tail ~loc:loc_ binder [] false_case body) + | Texpr_or { lhs; rhs; loc_ } -> ( + match true_case with + | Cexpr_const _ | Cexpr_apply { kind = Join; _ } -> + let new_false_case = go_cond rhs ~true_case ~false_case in + go_cond lhs ~true_case ~false_case:new_false_case + | _ -> + let binder = Ident.fresh "*ifso" in + let new_true_case = + Core.join_apply binder [] ~ty:(Core.type_of_expr true_case) in - let catch_all_case : Typedtree.match_case = - { pat; pat_binders; action } + let new_false_case = + go_cond rhs ~true_case:new_true_case ~false_case in - Lst.map (catch @ [ catch_all_case ]) - (fun { pat; pat_binders; action } -> - (pat, pat_binders, go_tail ~need_wrap_ok:false action)) - else - Lst.map catch (fun { pat; pat_binders; action } -> - (pat, pat_binders, go_tail ~need_wrap_ok:false action)) - in - let catch_body = - Transl_match.transl_match ~global_env join_param_var catch_cases ~ty - ~loc:loc_ - in - let body = - match try_else with - | None -> body - | Some try_else -> - let try_else_cases = - Lst.map try_else (fun { pat; pat_binders; action } -> - (pat, pat_binders, go_tail ~need_wrap_ok:false action)) - in - Core.bind ~loc:loc_ body (fun tmp -> - let tmp_var = Core.var ~ty:(Core.type_of_expr body) tmp in - Transl_match.transl_match ~global_env tmp_var try_else_cases ~ty - ~loc:loc_) - in - Core.letfn ~kind:Nontail_join try_join - { - params = - [ { binder = try_join_param_id; ty = err_ty; loc_ = ghost_loc_ } ]; - body = catch_body; - } - body - |> wrap_ok - | Texpr_while { loop_cond; loop_body; while_else; ty; loc_ } -> - let label = Label.fresh "*while" in - let ctx = { ctx with loop_ctx = Loop_label label } in - let cond = go_nontail loop_cond in - let body = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx loop_body - in - let body_with_continue = Core.sequence body (Core.continue [] label ty) in - let ifnot = Option.map (go_tail ~need_wrap_ok) while_else in - Core.loop ~loc:loc_ [] - (Core.if_ cond ~ifso:body_with_continue ?ifnot) - [] label - |> wrap_ok - | Texpr_break { arg; ty; loc_ } -> ( - if is_tail then - match arg with - | None -> Core.unit () - | Some arg -> go_tail ~need_wrap_ok:false arg - else - match ctx.loop_ctx with - | Loop_label label | For_loop_info { label; _ } -> - Core.break ~loc_ - (Option.map (go_tail ~need_wrap_ok:false) arg) - label ty - | Foreach loop_ctx -> - let arg = - match arg with - | None -> Core.unit () - | Some arg -> go_tail ~need_wrap_ok:false arg - in - let break_value = - Core.constr ~ty:loop_ctx.foreach_result_ty - { - extra_info = No_extra_info; - constr_name = { name = "Break"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Foreach_util.break.cs_tag [ arg ] - in - loop_ctx.has_early_exit <- true; - Core.sequence - (Core.mutate ~pos:0 - (Core.var - ~ty:(mutable_var_type loop_ctx.foreach_result_ty) - loop_ctx.result_var) - mutable_var_label break_value) - (Core.join_apply ~ty loop_ctx.exit_join - [ Foreach_util.iter_result_end ]) - | No_loop -> assert false) - | Texpr_continue { args; ty; loc_ } -> ( - match ctx.loop_ctx with - | No_loop -> assert false - | Loop_label label -> - Core.continue ~loc:loc_ (Lst.map args go_nontail) label ty - | For_loop_info for_loop_ctx -> - if args = [] then ( - for_loop_ctx.need_for_loop_join <- true; - Core.join_apply ~loc:loc_ ~ty for_loop_ctx.continue_join []) - else - Core.continue ~loc:loc_ (Lst.map args go_nontail) for_loop_ctx.label - ty - | Foreach loop_ctx -> - loop_ctx.has_early_exit <- true; - Core.join_apply ~ty loop_ctx.exit_join - [ Foreach_util.iter_result_continue ]) - | Texpr_loop { params; body; args; ty = _; loc_ } -> - let params = - Lst.map params - (fun (Param { binder; ty; konstraint = _; kind = _ }) : Core.param -> - { binder = Ident.of_ident binder.binder_id; ty; loc_ = binder.loc_ }) - in - let label = Label.fresh "*loop" in - let ctx = { ctx with loop_ctx = Loop_label label } in - let body = - transl_expr ~is_tail ~need_wrap_ok:false ~global_env ctx body - in - Core.loop ~loc:loc_ params body (Lst.map args go_nontail) label |> wrap_ok - | Texpr_for { binders; condition; steps; body; for_else; ty; loc_ } -> - let params, init_values = - Lst.split_map binders (fun (binder, init) -> - ( ({ - binder = Ident.of_ident binder.binder_id; - ty = Typedtree_util.type_of_typed_expr init; - loc_ = binder.loc_; - } - : Core.param), - go_nontail init )) - in - let steps = - Lst.map params (fun p -> - match - Lst.find_opt steps (fun (step_binder, step_expr) -> - if Ident.equal p.binder (Ident.of_ident step_binder.var_id) - then Some step_expr - else None) - with - | None -> Core.var ~ty:p.ty p.binder - | Some step -> go_nontail step) - in - let body_loc = Typedtree.loc_of_typed_expr body in - let continue_join = Ident.fresh "*continue" in - let label = Label.fresh "*for" in - let ctx = - { - ctx with - loop_ctx = - For_loop_info { continue_join; need_for_loop_join = false; label }; - } - in - let body = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx body - in - let continue = Core.continue steps label ty in - let body_with_continue = - match ctx.loop_ctx with - | For_loop_info { need_for_loop_join = true; _ } -> - let apply = Core.join_apply ~ty continue_join [] in - Core.letfn ~kind:Nontail_join continue_join - { params = []; body = continue } - (Core.sequence ~loc:body_loc body apply) - | For_loop_info { need_for_loop_join = false; _ } -> - Core.sequence ~loc:body_loc body continue - | No_loop | Loop_label _ | Foreach _ -> assert false - in - let ifnot = Option.map (go_tail ~need_wrap_ok:false) for_else in - let loop_body = - match condition with - | None -> body_with_continue - | Some cond -> - Core.if_ ~loc:body_loc ~ifso:body_with_continue ?ifnot - (go_nontail cond) - in - Core.loop ~loc:loc_ params loop_body init_values label |> wrap_ok - | Texpr_foreach { binders; elem_tys; expr; body; else_block; ty; loc_ } -> - let expr = go_nontail expr in - let result_var = Ident.fresh "*foreach_result" in - let foreach_result_ty = - Foreach_util.type_foreach_result ty ctx.return_ty - (match ctx.error_ty with None -> Stype.unit | Some err_ty -> err_ty) - in - let exit_join = Ident.fresh "*foreach_exit" in - let body_err_ctx = - match ctx.error_ty with - | None -> None - | Some _ -> - Some - { - raise_join = Ident.fresh "*foreach_raise"; - need_raise_join = false; - } - in - let loop_ctx = - { result_var; exit_join; has_early_exit = false; foreach_result_ty } - in - let body = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env - { - ctx with - loop_ctx = Foreach loop_ctx; - return_ctx = Foreach_return loop_ctx; - error_ctx = body_err_ctx; - } - body - in - let body = Core.sequence body Foreach_util.iter_result_continue in - let body = - match body_err_ctx with - | Some { need_raise_join = true; raise_join } -> ( - match[@warning "-fragile-match"] ctx.error_ty with - | Some error_ty -> - loop_ctx.has_early_exit <- true; - (match ctx.error_ctx with - | None -> () - | Some error_ctx -> error_ctx.need_raise_join <- true); - let err_value_param = Ident.fresh "*foreach_error" in - let err_value = - Core.constr ~ty:foreach_result_ty - { - extra_info = No_extra_info; - constr_name = { name = "Error"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Foreach_util.error.cs_tag - [ Core.var ~ty:error_ty err_value_param ] - in - Core.letfn ~kind:Nontail_join raise_join - { - params = - [ - { - binder = err_value_param; - ty = error_ty; - loc_ = ghost_loc_; - }; - ]; - body = - Core.sequence - (Core.mutate ~pos:0 - (Core.var - ~ty:(mutable_var_type loop_ctx.foreach_result_ty) - loop_ctx.result_var) - mutable_var_label err_value) - Foreach_util.iter_result_end; - } - body - | _ -> assert false) - | _ -> body - in - let body = - if loop_ctx.has_early_exit then - (let exit_join_param = Ident.fresh "*foreach_body_result" in - Core.letfn ~kind:Nontail_join exit_join - { - params = - [ - { - binder = exit_join_param; - ty = Stype.type_iter_result; - loc_ = ghost_loc_; - }; - ]; - body = Core.var ~ty:Stype.type_iter_result exit_join_param; - }) - body - else body - in - let callback = - let params = - Lst.map2 binders elem_tys (fun binder ty : Core.param -> - match binder with - | None -> { binder = Ident.fresh "*_"; ty; loc_ = ghost_loc_ } - | Some { binder_id; loc_ } -> - { binder = Ident.of_ident binder_id; ty; loc_ }) - in - Core.function_ - ~ty:(Builtin.type_arrow elem_tys Stype.type_iter_result ~err_ty:None) - params body - in - let main_loop = - Core.bind ~loc:loc_ expr (fun expr_id -> - Core.apply expr_id [ callback ] ~ty:Stype.type_iter_result ~loc:loc_ - ~kind: - (Normal - { - func_ty = - Builtin.type_arrow - [ Core.type_of_expr callback ] - Stype.type_iter_result ~err_ty:None; - })) - in - let main_loop = Core.prim ~ty:Stype.unit Pignore [ main_loop ] in - if not loop_ctx.has_early_exit then - match else_block with - | None -> main_loop |> wrap_ok - | Some else_block -> - Core.sequence main_loop (go_tail ~need_wrap_ok else_block) - else - let postprocess = - let break_value = Ident.fresh "*break" in - let return_value = Ident.fresh "*return" in - let error_case = - match body_err_ctx with - | Some _ -> ( - match[@warning "-fragile-match"] ctx.error_ty with - | Some error_ty -> - let error_value = Ident.fresh "*error" in - ( Foreach_util.error.cs_tag, - Some error_value, - transl_raise ctx - (Foreach_util.get_first_enum_field error_value - Foreach_util.error ~ty:error_ty - ~constr_ty:foreach_result_ty) - ~ty ~loc_:ghost_loc_ ) - | _ -> assert false) - | None -> (Foreach_util.error.cs_tag, None, Core.prim ~ty Ppanic []) + let body = + go_cond lhs ~true_case:new_true_case ~false_case:new_false_case in - Core.switch_constr - (Core.field ~ty:foreach_result_ty ~pos:0 - (Core.var ~ty:(mutable_var_type foreach_result_ty) result_var) - (Label mutable_var_label)) - ~default:None - [ - ( Foreach_util.continue.cs_tag, - None, - match else_block with - | None -> Core.unit () - | Some else_block -> go_nontail else_block ); - ( Foreach_util.break.cs_tag, - Some break_value, - Foreach_util.get_first_enum_field break_value Foreach_util.break - ~ty ~constr_ty:foreach_result_ty ); - ( Foreach_util.return.cs_tag, - Some return_value, - transl_return ~is_tail ctx - (Foreach_util.get_first_enum_field return_value - Foreach_util.return ~ty:ctx.return_ty - ~constr_ty:foreach_result_ty) - ~ty ~loc_:ghost_loc_ ); - error_case; - ] - |> wrap_ok - in - Core.let_ result_var - (Core.record - ~ty:(mutable_var_type foreach_result_ty) - [ - { - label = mutable_var_label; - pos = 0; - is_mut = true; - expr = - Core.constr ~ty:foreach_result_ty - { - extra_info = No_extra_info; - constr_name = { name = "Continue"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Foreach_util.continue.cs_tag []; - }; - ]) - (Core.sequence main_loop postprocess) - | Texpr_return { return_value; ty; loc_ } -> - let return_value = - match return_value with - | Some rt -> - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx rt - | None -> Core.unit () - in - if need_wrap_ok then - match ctx.wrapper_info with - | Some result_ty -> wrap_ok_prim return_value ~result_ty - | None -> assert false - else transl_return ctx ~is_tail return_value ~ty ~loc_ - | Texpr_raise { error_value; ty; loc_ } -> - let error_value = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx - error_value - in - let ty = - if need_wrap_ok then - match ctx.wrapper_info with Some result_ty -> result_ty | None -> ty - else ty - in - transl_raise ctx error_value ~ty ~loc_ - | Texpr_exclamation { expr; ty; loc_; convert_to_result } -> ( - let expr = go_nontail expr in - let result_ty = Core.type_of_expr expr in - let ok_ty, _ = - match result_ty with - | T_constr { type_constructor; tys = [ ok_ty; err_ty ] } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_multi_value_result -> - (ok_ty, err_ty) - | _ -> assert false - in - if convert_to_result then - Core.handle_error ~loc:loc_ expr To_result ~ty |> wrap_ok - else if need_wrap_ok then expr - else - match ctx.error_ctx with - | Some error_ctx -> - error_ctx.need_raise_join <- true; - Core.handle_error ~loc:loc_ expr (Joinapply error_ctx.raise_join) - ~ty:ok_ty - | None -> - let ctx_ok_ty = ctx.return_ty in - Core.handle_error ~loc:loc_ expr - (Return_err { ok_ty = ctx_ok_ty }) - ~ty:ok_ty) - | Texpr_hole { ty; loc_; kind } -> - let msg = - match kind with - | Synthesized | Incomplete -> "hole in expr" - | Todo -> "todo in expr" - in - Core.raise ~loc:loc_ ~ty msg - | Texpr_constraint { expr; _ } -> go_tail ~need_wrap_ok expr - | Texpr_pipe - { - lhs = expr; - ty; - rhs = - Pipe_partial_apply - { - args; - func = - ( Texpr_ident _ | Texpr_method _ | Texpr_unresolved_method _ - | Texpr_constr { constr = _; tag = _; ty = _; loc_ = _ } ) as - func; - loc_ = rhs_loc_; - }; - loc_ = _; - } - when Lst.for_all args (fun { arg_kind; _ } -> arg_kind = Positional) -> - transl_apply ~global_env ~ctx ~ty ~loc_:rhs_loc_ - ~kind:(`Pipe (Typedtree.loc_of_typed_expr expr)) - func - ({ arg_value = expr; arg_kind = Positional } :: args) - |> wrap_ok - | Texpr_pipe { lhs = expr; rhs = body; ty; loc_ } -> - let var_id = Basic_ident.fresh "*lhs" in - let body = - let arg = - Typedtree.Texpr_ident - { - id = { var_id; loc_ = ghost_loc_ }; - kind = Normal; - ty = Typedtree_util.type_of_typed_expr expr; - ty_args_ = [||]; - arity_ = None; - loc_ = ghost_loc_; - } - in - match body with - | Typedtree.Pipe_partial_apply { func; args; loc_ } -> - transl_apply ~global_env ~ctx ~ty ~loc_ - ~kind:(`Pipe (Typedtree.loc_of_typed_expr expr)) - func - ({ arg_value = arg; arg_kind = Positional } :: args) - |> wrap_ok - | _ -> assert false - in - Core.let_ ~loc:loc_ (Ident.of_ident var_id) (go_nontail expr) body - | Texpr_interp { elems; ty = _ } -> - let core_elems = - Lst.map elems (function - | Interp_lit s -> Core.const (C_string s) - | Interp_expr { expr; to_string } -> - transl_apply ~global_env ~ctx ~kind:`Normal ~ty:Stype.string - ~loc_:(Typedtree.loc_of_typed_expr expr) - to_string - [ { arg_value = expr; arg_kind = Positional } ]) - in - (match core_elems with - | [] -> Core.const (C_string "") - | x :: xs -> - Lst.fold_left xs x (fun acc x -> - Core.prim ~ty:Stype.string - (Pccall { func_name = "add_string"; arity = 2 }) - [ acc; x ])) - |> wrap_ok - | Texpr_guard { cond; otherwise; body; loc_ = loc; ty } -> - let cond = go_nontail cond in - let body = go_tail ~need_wrap_ok:false body in - let ifnot = - Some - (match otherwise with - | Some expr -> go_tail ~need_wrap_ok:false expr - | None -> Core.prim ~loc ~ty Primitive.Ppanic []) - in - Core.if_ ~loc cond ~ifso:body ?ifnot |> wrap_ok - | Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; loc_; ty } -> - let ok_case = { Typedtree.pat; pat_binders; action = body } in - let fail_cases = - match otherwise with Some cases -> cases | None -> [] - in - let expr = - Typedtree.Texpr_match - { - expr = rhs; - cases = ok_case :: fail_cases; - ty; - loc_; - match_loc_ = loc_; - } - in - transl_expr ~global_env ~is_tail ~need_wrap_ok ctx expr + Core.joinlet_tail ~loc:loc_ binder [] true_case body) + | _ -> ( + match false_case with + | Cexpr_unit _ -> + Core.if_ ~loc:loc_ (go_nontail cond) ~ifso:true_case ?ifnot:None + | _ -> + Core.if_ ~loc:loc_ (go_nontail cond) ~ifso:true_case + ?ifnot:(Some false_case)) -and transl_apply ~global_env ~ctx ~(kind : [ `Normal | `Pipe of Rloc.t ]) ~ty - ~loc_ func args = +and transl_apply ~global_env ~tvar_env ~ctx + ~(kind : [ `Normal | `Pipe of Rloc.t ]) ~ty ~loc_ func args = let go_nontail expr = transl_expr ~global_env ~is_tail:false ~need_wrap_ok:false ctx expr + ~tvar_env + [@@inline] + in + let make_apply args = + match Stype.type_repr (Typedtree_util.type_of_typed_expr func) with + | Tarrow { err_ty = Some err_ty; _ } -> + let result_ty = Stype.make_multi_value_result_ty ~ok_ty:ty ~err_ty in + make_apply ~global_env ~tvar_env ctx func args ~loc:loc_ ~ty:result_ty + | _ -> make_apply ~global_env ~tvar_env ctx func args ~loc:loc_ ~ty [@@inline] in - let labelled_args = Hash_string.create 17 in - let positional_args = Vec.empty () in - Lst.iter args (fun arg -> - let carg = go_nontail arg.arg_value in - match arg.arg_kind with - | Positional -> Vec.push positional_args carg - | Labelled label | Labelled_pun label -> - Hash_string.add labelled_args label.label_name (false, carg) - | Labelled_option { label; question_loc = _ } - | Labelled_option_pun { label; question_loc = _ } -> - Hash_string.add labelled_args label.label_name (true, carg)); - let arg_bindings : (Ident.t * Core.expr * Core.expr) Vec.t = Vec.empty () in - let need_let = ref false in let process_labelled_args ~func_ty ~make_default_arg arity = match[@warning "-fragile-match"] Stype.type_repr func_ty with - | (Tarrow { params_ty; ret_ty = _; err_ty = _ } : Stype.t) -> + | Tarrow { params_ty; ret_ty = _; err_ty = _; is_async = _ } -> + let labelled_args = Hash_string.create 17 in + let positional_args = Vec.empty () in + Lst.iter args ~f:(fun arg -> + match arg.arg_kind with + | Positional -> Vec.push positional_args arg.arg_value + | Labelled label + | Labelled_pun label + | Labelled_option { label; question_loc = _ } + | Labelled_option_pun { label; question_loc = _ } -> + Hash_string.add labelled_args label.label_name arg); + let arg_bindings : (Ident.t * Core.expr * Core.expr) Vec.t = + Vec.empty () + in + let need_let = ref false in let loc_of_args = Fn_arity.to_list_map arity (fun param_kind -> match (kind, param_kind) with | `Pipe lhs_loc, Positional 0 -> lhs_loc | _, Positional index -> - Core.loc_of_expr (Vec.get positional_args index) + Typedtree.loc_of_typed_expr (Vec.get positional_args index) | ( _, ( Labelled { label; _ } | Optional { label; _ } @@ -1191,112 +1593,96 @@ and transl_apply ~global_env ~ctx ~(kind : [ `Normal | `Pipe of Rloc.t ]) ~ty | Question_optional { label } ) ) -> ( match Hash_string.find_opt labelled_args label with | None -> ghost_loc_ - | Some (_, expr) -> Core.loc_of_expr expr)) + | Some arg -> Typedtree.loc_of_typed_expr arg.arg_value)) in - Fn_arity.iter2 arity params_ty (fun param_kind param_ty -> - let arg_expr = - match param_kind with - | Optional { label; depends_on } -> ( - match Hash_string.find_opt labelled_args label with - | Some (_, arg_expr) -> arg_expr - | None -> - let args_of_default_fn = - Lst.map depends_on (fun index -> - need_let := true; - let _, arg_id_expr, _ = - Vec.get arg_bindings index - in - arg_id_expr) - in - let default_arg = - make_default_arg label param_ty args_of_default_fn - in - Hash_string.add labelled_args label (false, default_arg); - default_arg) - | Question_optional { label } -> ( - match Hash_string.find_opt labelled_args label with - | None -> - Core.constr - { - extra_info = No_extra_info; - constr_name = { name = "None"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Builtin.constr_none.cs_tag [] - ~ty:(Builtin.type_option param_ty) - | Some (true, arg_expr) -> arg_expr - | Some (false, arg_expr) -> - Core.constr - { - extra_info = No_extra_info; - constr_name = { name = "Some"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Builtin.constr_some.cs_tag [ arg_expr ] - ~ty:(Builtin.type_option param_ty)) - | Autofill { label } -> ( - match Hash_string.find_opt labelled_args label with - | Some (_, arg_expr) -> arg_expr - | None when Type.same_type param_ty Stype.type_sourceloc -> - let arg_expr = - Core.const - (C_string (Rloc.loc_range_string ~base:ctx.base loc_)) - in - Hash_string.add labelled_args label (false, arg_expr); - arg_expr - | None when Type.same_type param_ty Stype.type_argsloc -> - let loc_of_args_expr = - Lst.map loc_of_args (fun loc -> - if Rloc.is_no_location loc then - Core.constr - ~ty:(Builtin.type_option Stype.type_sourceloc) - { - constr_name = - { name = "None"; loc_ = ghost_loc_ }; - extra_info = No_extra_info; - loc_ = ghost_loc_; - } - Builtin.constr_none.cs_tag [] - else - Core.constr - ~ty:(Builtin.type_option Stype.type_sourceloc) - { - constr_name = - { name = "Some"; loc_ = ghost_loc_ }; - extra_info = No_extra_info; - loc_ = ghost_loc_; - } - Builtin.constr_some.cs_tag - [ - Core.const - (C_string - (Rloc.loc_range_string ~base:ctx.base loc)); - ]) - in - let loc_of_args_array = - Core.prim - ~ty: - (Builtin.type_array - (Builtin.type_option Stype.type_sourceloc)) - Parray_make loc_of_args_expr - in - Hash_string.add labelled_args label - (false, loc_of_args_array); - loc_of_args_array - | None -> assert false) - | Positional index -> Vec.get positional_args index - | Labelled { label; _ } -> - snd (Hash_string.find_exn labelled_args label) - in - let arg_id = Ident.fresh "arg" in - let arg_id_expr = - Core.var ~ty:(Core.type_of_expr arg_expr) arg_id - in - Vec.push arg_bindings (arg_id, arg_id_expr, arg_expr)) + Fn_arity.iter2 arity params_ty (fun param_kind -> + fun param_ty -> + let arg_expr = + match param_kind with + | Optional { label; depends_on } -> ( + match Hash_string.find_opt labelled_args label with + | Some arg -> go_nontail arg.arg_value + | None -> + let args_of_default_fn = + Lst.map depends_on (fun index -> + need_let := true; + let _, arg_id_expr, _ = + Vec.get arg_bindings index + in + arg_id_expr) + in + make_default_arg label param_ty args_of_default_fn) + | Question_optional { label } -> ( + match Hash_string.find_opt labelled_args label with + | None -> + Core.constr Builtin.constr_none.cs_tag [] + ~ty:(Builtin.type_option param_ty) + | Some + { + arg_kind = Labelled_option _ | Labelled_option_pun _; + arg_value; + } -> + go_nontail arg_value + | Some { arg_kind = _; arg_value } -> + Core.constr Builtin.constr_some.cs_tag + [ go_nontail arg_value ] + ~ty:(Builtin.type_option param_ty)) + | Autofill { label } -> ( + match Hash_string.find_opt labelled_args label with + | Some arg -> go_nontail arg.arg_value + | None when Type.same_type param_ty Stype.type_sourceloc -> + Core.const + (C_string (Rloc.loc_range_string ~base:ctx.base loc_)) + | None when Type.same_type param_ty Stype.type_argsloc -> + let loc_of_args_expr = + Lst.map loc_of_args (fun loc -> + if Rloc.is_no_location loc then + Core.constr + ~ty:(Builtin.type_option Stype.type_sourceloc) + Builtin.constr_none.cs_tag [] + else + Core.constr + ~ty:(Builtin.type_option Stype.type_sourceloc) + Builtin.constr_some.cs_tag + [ + Core.const + (C_string + (Rloc.loc_range_string ~base:ctx.base + loc)); + ]) + in + let ty = + Builtin.type_array + (Builtin.type_option Stype.type_sourceloc) + in + Core_util.make_array_make loc_of_args_expr ~loc_ ~ty + | None -> assert false) + | Positional index -> go_nontail (Vec.get positional_args index) + | Labelled { label; _ } -> + go_nontail + (Hash_string.find_exn labelled_args label).arg_value + in + let arg_id = Ident.fresh "arg" in + let arg_id_expr = + Core.var ~ty:(Core.type_of_expr arg_expr) arg_id + in + Vec.push arg_bindings (arg_id, arg_id_expr, arg_expr)); + if !need_let then + let apply_expr = + make_apply + (Vec.map_into_list arg_bindings + ~unorder:(fun (_, arg_id_expr, _) -> arg_id_expr)) + in + Vec.fold_right arg_bindings apply_expr ~f:(fun (id, _, rhs) -> + fun body -> Core.let_ id rhs body) + else + make_apply + (Vec.map_into_list arg_bindings ~unorder:(fun (_, _, arg_expr) -> + arg_expr)) | _ -> assert false [@@inline] in - (match func with + match func with | Texpr_ident { arity_ = Some arity; id = { var_id = id }; ty_args_; ty = func_ty; _ } | Texpr_method @@ -1310,7 +1696,7 @@ and transl_apply ~global_env ~ctx ~(kind : [ `Normal | `Pipe of Rloc.t ]) ~ty func_ty = Builtin.type_arrow (Lst.map args Core.type_of_expr) - param_ty ~err_ty:None; + param_ty ~err_ty:None ~is_async:false; }) ~ty:param_ty ~ty_args_ (name_of_default_arg ~label id) @@ -1321,51 +1707,43 @@ and transl_apply ~global_env ~ctx ~(kind : [ `Normal | `Pipe of Rloc.t ]) ~ty | Texpr_unresolved_method { arity_ = Some arity_; ty = func_ty; _ } when not (Fn_arity.is_simple arity_) -> process_labelled_args ~func_ty - ~make_default_arg:(fun _ _ _ -> assert false) + ~make_default_arg:(fun _ -> fun _ -> fun _ -> assert false) arity_ - | _ -> ()); - let args = - if Vec.is_empty arg_bindings then ( - assert (Hash_string.length labelled_args = 0); - Vec.to_list positional_args) - else if !need_let then - Vec.map_into_list arg_bindings (fun (_, arg_id_expr, _) -> arg_id_expr) - else Vec.map_into_list arg_bindings (fun (_, _, arg_expr) -> arg_expr) - in - let apply_expr = - match Stype.type_repr (Typedtree_util.type_of_typed_expr func) with - | Tarrow { err_ty = Some err_ty; _ } -> - let result_ty = Stype.make_multi_value_result_ty ~ok_ty:ty ~err_ty in - make_apply ~global_env ctx func args ~loc:loc_ ~ty:result_ty - | _ -> make_apply ~global_env ctx func args ~loc:loc_ ~ty - in - if !need_let then - Vec.fold_right arg_bindings apply_expr ~f:(fun (id, _, rhs) body -> - Core.let_ id rhs body) - else apply_expr + | _ -> make_apply (Lst.map args (fun arg -> go_nontail arg.arg_value)) -and make_apply ~global_env ctx (func : Typedtree.expr) (args : Core.expr list) - ~loc ~ty = +and make_apply ~global_env ~tvar_env ctx (func : Typedtree.expr) + (args : Core.expr list) ~loc ~ty = let make_apply () = match transl_expr ~global_env ~is_tail:false ~need_wrap_ok:false ctx func + ~tvar_env with - | Cexpr_var { id = func; ty = func_ty; ty_args_; prim } -> - Core.apply ~loc ~ty_args_ ~kind:(Normal { func_ty }) ~ty ~prim func args - | func -> + | Cexpr_var { id = func; ty = func_ty; ty_args_; prim } -> ( + match[@warning "-fragile-match"] Stype.type_repr func_ty with + | Tarrow { is_async; _ } -> + let kind : Core.apply_kind = + if is_async then Async { func_ty } else Normal { func_ty } + in + Core.apply ~loc ~ty_args_ ~kind ~ty ~prim func args + | _ -> assert false) + | func -> ( let id = Ident.fresh "*func" in let func_ty = Core.type_of_expr func in - let app : Core.expr = - Core.apply ~loc ~kind:(Normal { func_ty }) ~ty id args - in - Core.let_ id func app + match[@warning "-fragile-match"] Stype.type_repr func_ty with + | Tarrow { is_async; _ } -> + let kind : Core.apply_kind = + if is_async then Async { func_ty } else Normal { func_ty } + in + let app : Core.expr = Core.apply ~loc ~kind ~ty id args in + Core.let_ id func app + | _ -> assert false) [@@inline] in match func with | Texpr_ident { id = _; kind = Prim prim; ty = _ } | Texpr_method { type_name = _; meth = _; prim = Some prim; ty = _ } -> ( match prim with - | Pintrinsic intrinsic when not !Basic_config.debug -> ( + | Pintrinsic intrinsic when not !Basic_config.no_opt -> ( match Core_util.try_apply_intrinsic intrinsic args ~loc ~ty with | Some result -> result | None -> make_apply ()) @@ -1373,83 +1751,97 @@ and make_apply ~global_env ctx (func : Typedtree.expr) (args : Core.expr list) | _ -> Core.prim ~loc ~ty prim args) | Texpr_unresolved_method { trait_name; method_name; self_type = self_ty; ty = func_ty } -> ( - let trait = trait_name.name in - match - transl_trait_method ~global_env ~trait ~self_ty ~expect_ty:func_ty - ~method_name - with - | `Prim prim -> Core.prim ~loc ~ty prim args - | `Regular (id, ty_args_, prim) -> - Core.apply ~loc ~ty ~kind:(Normal { func_ty }) ~ty_args_ ~prim id args - ) + match[@warning "-fragile-match"] trait_name with + | Tname_path { name = trait; _ } | Tname_alias { name = trait; _ } -> ( + match + transl_trait_method ~global_env ~trait ~self_ty ~expect_ty:func_ty + ~method_name + with + | `Prim prim -> Core.prim ~loc ~ty prim args + | `Regular (id, ty_args_, prim) -> + Core.apply ~loc ~ty + ~kind:(Normal { func_ty }) + ~ty_args_ ~prim id args) + | _ -> assert false) | Texpr_ident { id = { var_id = Pdot qual_name }; kind = _; ty = _; ty_args_ } -> ( match Core_util.specialize qual_name ty_args_ with | Some prim -> Core.prim ~loc ~ty prim args | None -> make_apply ()) - | Texpr_constr { constr; tag; ty = _ } -> + | Texpr_constr { tag; type_name = _; constr = _; ty = _ } -> if Global_env.is_newtype global_env ty then Core.prim ~ty (Pcast { kind = Make_newtype }) args - else Core.constr ~loc ~ty constr tag args + else Core.constr ~loc ~ty tag args | _ -> make_apply () -and transl_fn ~global_env ~base (fn : Typedtree.fn) : Core.fn = - let params = - Lst.map fn.params - (fun (Param { binder; ty; konstraint = _; kind = _ }) : Core.param -> - { binder = Ident.of_ident binder.binder_id; ty; loc_ = binder.loc_ }) - in - let err_type = - match Stype.type_repr fn.ty with - | Tarrow { err_ty; _ } -> err_ty - | _ -> assert false - in - let return_value_ty = Typedtree_util.type_of_typed_expr fn.body in - let wrapper_info = - match err_type with - | None -> None - | Some err_ty -> - Some (Stype.make_multi_value_result_ty ~ok_ty:return_value_ty ~err_ty) - in - let ctx = - { - return_ctx = No_return; - error_ctx = None; - loop_ctx = No_loop; - return_ty = return_value_ty; - error_ty = err_type; - wrapper_info; - base; - } - in - let need_wrap_ok = match err_type with Some _ -> true | None -> false in - let body = transl_expr ~is_tail:true ~need_wrap_ok ~global_env ctx fn.body in - { params; body } +and transl_fn ~global_env ~tvar_env ~base (fn : Typedtree.fn) = + (let params = + Lst.map fn.params (fun p -> + (match p with + | Param { binder; ty; konstraint = _; kind = _ } -> + { + binder = Ident.of_ident binder.binder_id; + ty; + loc_ = binder.loc_; + } + | Discard_positional_param { ty; loc_; _ } -> + { binder = Ident.fresh "*discard_"; ty; loc_ } + : Core.param)) + in + match[@warning "-fragile-match"] Stype.type_repr fn.ty with + | Tarrow { is_async; err_ty = err_type; _ } -> + let return_value_ty = Typedtree_util.type_of_typed_expr fn.body in + let wrapper_info = + match err_type with + | None -> None + | Some err_ty -> + Some + (Stype.make_multi_value_result_ty ~ok_ty:return_value_ty ~err_ty) + in + let ctx = + { + return_ctx = No_return; + error_ctx = None; + loop_ctx = []; + return_ty = return_value_ty; + error_ty = err_type; + wrapper_info; + base; + } + in + let need_wrap_ok = + match err_type with Some _ -> true | None -> false + in + let body = + transl_expr ~is_tail:true ~need_wrap_ok ~global_env ~tvar_env ctx + fn.body + in + { params; body; is_async } + | _ -> assert false + : Core.fn) -and transl_field_def ~global_env (ctx : transl_context) - (field : Typedtree.field_def) : Core.field_def = - let (Field_def { label; expr; pos; is_mut; is_pun = _ }) = field in - { - label; - expr = transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ctx expr; - pos; - is_mut; - } +and transl_field_def ~global_env ~tvar_env (ctx : transl_context) + (field : Typedtree.field_def) = + (let (Field_def { label; expr; pos; is_mut; is_pun = _ }) = field in + { + label; + expr = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env ~tvar_env ctx + expr; + pos; + is_mut; + } + : Core.field_def) and transl_return ctx ~is_tail return_value ~ty ~loc_ = match ctx.return_ctx with | Foreach_return loop_ctx -> let return_value = - Core.constr ~ty:loop_ctx.foreach_result_ty - { - extra_info = No_extra_info; - constr_name = { name = "Return"; loc_ = ghost_loc_ }; - loc_ = ghost_loc_; - } - Foreach_util.return.cs_tag [ return_value ] + Core.constr ~ty:loop_ctx.foreach_result_ty Foreach_util.return.cs_tag + [ return_value ] in loop_ctx.has_early_exit <- true; - Core.sequence + Core.sequence2 (Core.mutate ~pos:0 (Core.var ~ty:(mutable_var_type loop_ctx.foreach_result_ty) @@ -1488,6 +1880,90 @@ and transl_raise ctx error_value ~ty ~loc_ = ~return_kind:(Error_result { is_error = true; return_ty = result_ty }) ~ty ~loc:loc_ +and transl_break ctx arg ~ty ~loc_ ~label = + match find_loop_ctx ~label ctx.loop_ctx with + | `Normal_jump (Loop_label label) | `Normal_jump (For_loop_info { label; _ }) + -> + Core.break ~loc_ arg label ty + | `Normal_jump (Foreach loop_ctx) -> + let arg = match arg with None -> Core.unit () | Some arg -> arg in + let break_value = + Core.constr ~ty:loop_ctx.foreach_result_ty Foreach_util.break.cs_tag + [ arg ] + in + loop_ctx.has_early_exit <- true; + Core.sequence2 + (Core.mutate ~pos:0 + (Core.var + ~ty:(mutable_var_type loop_ctx.foreach_result_ty) + loop_ctx.result_var) + mutable_var_label break_value) + (Core.join_apply ~ty loop_ctx.exit_join + [ Foreach_util.iter_result_end ]) + | `Jump_out_foreach foreach_ctx -> + let arg = match arg with None -> [] | Some arg -> [ arg ] in + let ({ break_tag; _ } : Foreach_util.jump_outer_constr_info) = + Label.Map.find_exn foreach_ctx.jump_outer_ctx.constrs (Option.get label) + in + let payload_value = + Core.constr ~ty:foreach_ctx.jump_outer_ctx.payload_type break_tag arg + in + let jump_outer_value = + Core.constr ~ty:foreach_ctx.foreach_result_ty + Foreach_util.jump_outer.cs_tag [ payload_value ] + in + let iter_result_var = + Core.var + ~ty:(mutable_var_type foreach_ctx.foreach_result_ty) + foreach_ctx.result_var + in + foreach_ctx.has_early_exit <- true; + Core.sequence2 + (Core.mutate ~pos:0 iter_result_var mutable_var_label jump_outer_value) + (Core.join_apply ~ty foreach_ctx.exit_join + [ Foreach_util.iter_result_end ]) + +and transl_continue ctx args ~ty ~label ~loc_ = + match find_loop_ctx ~label ctx.loop_ctx with + | `Normal_jump (Loop_label label) -> Core.continue ~loc:loc_ args label ty + | `Normal_jump (For_loop_info for_loop_ctx) -> + if args = [] then ( + for_loop_ctx.need_for_loop_join <- true; + Core.join_apply ~loc:loc_ ~ty for_loop_ctx.continue_join []) + else Core.continue ~loc:loc_ args for_loop_ctx.label ty + | `Normal_jump (Foreach loop_ctx) -> + loop_ctx.has_early_exit <- true; + Core.join_apply ~ty loop_ctx.exit_join + [ Foreach_util.iter_result_continue ] + | `Jump_out_foreach foreach_ctx -> + let ({ continue_tag; extra_continue_tag; _ } + : Foreach_util.jump_outer_constr_info) = + Label.Map.find_exn foreach_ctx.jump_outer_ctx.constrs (Option.get label) + in + let payload_value = + match extra_continue_tag with + | Some extra_continue_tag when args = [] -> + Core.constr ~ty:foreach_ctx.jump_outer_ctx.payload_type + extra_continue_tag [] + | _ -> + Core.constr ~ty:foreach_ctx.jump_outer_ctx.payload_type continue_tag + args + in + let jump_outer_value = + Core.constr ~ty:foreach_ctx.foreach_result_ty + Foreach_util.jump_outer.cs_tag [ payload_value ] + in + let iter_result_var = + Core.var + ~ty:(mutable_var_type foreach_ctx.foreach_result_ty) + foreach_ctx.result_var + in + foreach_ctx.has_early_exit <- true; + Core.sequence2 + (Core.mutate ~pos:0 iter_result_var mutable_var_label jump_outer_value) + (Core.join_apply ~ty foreach_ctx.exit_join + [ Foreach_util.iter_result_end ]) + and transl_trait_method ~global_env ~trait ~method_name ~(self_ty : Stype.t) ~(expect_ty : Stype.t) = let resolve_by_path (type_name : Type_path.t) = @@ -1496,7 +1972,7 @@ and transl_trait_method ~global_env ~trait ~method_name ~(self_ty : Stype.t) with | None -> assert false | Some mi -> ( - let actual_ty, ty_args = + let actual_ty, _, ty_args = Poly_type.instantiate_method_no_constraint mi in Ctype.unify_exn expect_ty actual_ty; @@ -1515,26 +1991,16 @@ and transl_trait_method ~global_env ~trait ~method_name ~(self_ty : Stype.t) `Regular (id, [||], None) | T_constr { type_constructor; _ } -> resolve_by_path type_constructor | T_builtin builtin -> resolve_by_path (Stype.tpath_of_builtin builtin) - | T_trait object_trait -> ( - let trait_decl = - Global_env.find_trait_by_path global_env object_trait |> Option.get - in - match - Lst.find_first_with_index trait_decl.closure_methods - (fun (actual_trait, method_decl) -> - Type_path.equal actual_trait trait - && method_decl.method_name = method_name) - with - | Some (method_index, _) -> - `Prim (Pcall_object_method { method_index; method_name }) - | None -> resolve_by_path object_trait) - | Tvar _ | Tarrow _ | T_blackhole -> assert false + | T_trait object_trait -> resolve_by_path object_trait + | Tarrow _ -> assert false + | Tvar _ -> assert false + | T_blackhole -> assert false let dummy_ctx ~base = { return_ctx = No_return; error_ctx = None; - loop_ctx = No_loop; + loop_ctx = []; return_ty = Stype.unit; error_ty = None; wrapper_info = None; @@ -1549,7 +2015,7 @@ let transl_top_expr expr ~global_env ~base = { return_ctx; error_ctx = None; - loop_ctx = No_loop; + loop_ctx = []; return_ty = Typedtree_util.type_of_typed_expr expr; error_ty = None; wrapper_info = None; @@ -1557,7 +2023,8 @@ let transl_top_expr expr ~global_env ~base = } in let body = - transl_expr ~is_tail:true ~need_wrap_ok:false ~global_env ctx expr + transl_expr ~is_tail:true ~need_wrap_ok:false ~global_env + ~tvar_env:Tvar_env.empty ctx expr in match[@warning "-fragile-match"] return_ctx with | Normal_return return_ctx -> @@ -1569,6 +2036,7 @@ let transl_top_expr expr ~global_env ~base = { binder = return_value_id; ty = Stype.unit; loc_ = ghost_loc_ }; ]; body = Core.var ~ty_args_:[||] ~ty:Stype.unit return_value_id; + is_async = false; } body else body @@ -1578,86 +2046,125 @@ let generate_default_exprs ~global_env ~(fn_binder : Typedtree.binder) ~is_pub ~ty_params_ ~(params : Typedtree.params) ~arity ~base = let prev_params : Core.param Vec.t = Vec.empty () in let default_exprs = Vec.empty () in - Fn_arity.iter2 arity params (fun param_kind (Param { binder; kind; ty; _ }) -> - match (param_kind, kind) with - | Optional { label = _; depends_on }, Optional expr -> - let subst = Ident.Hash.create 16 in - let params = - Lst.map depends_on (fun index -> - let param = Vec.get prev_params index in - let new_binder = Ident.rename param.binder in - Ident.Hash.add subst param.binder new_binder; - { param with binder = new_binder }) - in - Vec.push prev_params - { binder = Ident.of_ident binder.binder_id; ty; loc_ = binder.loc_ }; - let cexpr = - transl_expr ~is_tail:true ~need_wrap_ok:false ~global_env - (dummy_ctx ~base) expr - |> Core_util.substitute ~subst - in - Vec.push default_exprs - (Core.Ctop_fn - { - binder = - name_of_default_arg - ~label:(Basic_ident.base_name binder.binder_id) - fn_binder.binder_id; - ty_params_; - is_pub_ = is_pub; - loc_ = base; - func = { params; body = cexpr }; - subtops = []; - }) - | _, Optional _ -> assert false - | _, (Positional | Labelled | Autofill | Question_optional) -> - Vec.push prev_params - { binder = Ident.of_ident binder.binder_id; ty; loc_ = binder.loc_ }); + Fn_arity.iter2 arity params (fun param_kind -> + fun param -> + match (param_kind, param) with + | ( Optional { label = _; depends_on }, + Param { kind = Optional expr; binder; ty; _ } ) -> + let subst = Ident.Hash.create 16 in + let params = + Lst.map depends_on (fun index -> + let param = Vec.get prev_params index in + let new_binder = Ident.rename param.binder in + Ident.Hash.add subst param.binder new_binder; + { param with binder = new_binder }) + in + Vec.push prev_params + { + binder = Ident.of_ident binder.binder_id; + ty; + loc_ = binder.loc_; + }; + let cexpr = + Core_util.substitute ~subst + (transl_expr ~is_tail:true ~need_wrap_ok:false ~global_env + ~tvar_env:ty_params_ (dummy_ctx ~base) expr) + in + Vec.push default_exprs + (Core.Ctop_fn + { + binder = + name_of_default_arg + ~label:(Basic_ident.base_name binder.binder_id) + fn_binder.binder_id; + ty_params_; + is_pub_ = is_pub; + loc_ = base; + func = { params; body = cexpr; is_async = false }; + subtops = []; + }) + | _, Param { kind = Optional _; _ } -> assert false + | ( _, + Param + { + kind = Positional | Labelled | Autofill | Question_optional; + binder; + ty; + _; + } ) -> + Vec.push prev_params + { + binder = Ident.of_ident binder.binder_id; + ty; + loc_ = binder.loc_; + } + | _, Discard_positional_param _ -> ()); Vec.to_list default_exprs [@@inline] -let transl_impl ~global_env (impl : Typedtree.impl) : Core.top_item list = - match impl with - | Timpl_expr { expr; is_main; expr_id = _; loc_ } -> - [ - Ctop_expr - { expr = transl_top_expr ~global_env ~base:loc_ expr; is_main; loc_ }; - ] - | Timpl_letdef { binder; konstraint = _; expr; is_pub; loc_ } -> - let binder = Ident.of_ident binder.binder_id in - let expr = - transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env - (dummy_ctx ~base:loc_) expr - in - [ Ctop_let { binder; expr; is_pub_ = is_pub; loc_ } ] - | Timpl_fun_decl - { - fun_decl = { kind = _; fn_binder; fn; is_pub; ty_params_ }; - arity_; - loc_; - } -> - let binder = Ident.of_ident fn_binder.binder_id in - let func = transl_fn ~base:loc_ ~global_env fn in - Ctop_fn { binder; func; subtops = []; ty_params_; is_pub_ = is_pub; loc_ } - :: generate_default_exprs ~fn_binder ~global_env ~is_pub ~ty_params_ - ~arity:arity_ ~params:fn.params ~base:loc_ - | Timpl_stub_decl { func_stubs; binder; is_pub; loc_; params; arity_; ret } - -> ( - let default_exprs = - generate_default_exprs ~fn_binder:binder ~global_env ~is_pub - ~ty_params_:Tvar_env.empty ~arity:arity_ ~params ~base:loc_ - in - let binder = Ident.of_ident binder.binder_id in - let params_ty = Lst.map params (fun (Param { ty; _ }) -> ty) in - let return_ty = Option.map Typedtree_util.stype_of_typ ret in - match func_stubs with - | Intrinsic -> default_exprs - | Func_stub func_stubs -> - Ctop_stub - { binder; func_stubs; params_ty; return_ty; is_pub_ = is_pub; loc_ } - :: default_exprs) +let transl_impl ~global_env (impl : Typedtree.impl) = + (match impl with + | Timpl_expr { expr; is_main; expr_id = _; loc_ } -> + [ + Ctop_expr + { expr = transl_top_expr ~global_env ~base:loc_ expr; is_main; loc_ }; + ] + | Timpl_letdef { binder; konstraint = _; expr; is_pub; loc_; attrs = _ } -> + let binder = Ident.of_ident binder.binder_id in + let expr = + transl_expr ~is_tail:false ~need_wrap_ok:false ~global_env + ~tvar_env:Tvar_env.empty (dummy_ctx ~base:loc_) expr + in + [ Ctop_let { binder; expr; is_pub_ = is_pub; loc_ } ] + | Timpl_fun_decl + { + fun_decl = + { + kind = _; + fn_binder; + fn; + is_pub; + ty_params_; + constraint_names = _; + attrs = _; + }; + arity_; + loc_; + } -> + let binder = Ident.of_ident fn_binder.binder_id in + let func = transl_fn ~base:loc_ ~global_env ~tvar_env:ty_params_ fn in + Ctop_fn + { binder; func; subtops = []; ty_params_; is_pub_ = is_pub; loc_ } + :: generate_default_exprs ~fn_binder ~global_env ~is_pub ~ty_params_ + ~arity:arity_ ~params:fn.params ~base:loc_ + | Timpl_stub_decl { func_stubs; binder; is_pub; loc_; params; arity_; ret } + -> ( + let default_exprs = + generate_default_exprs ~fn_binder:binder ~global_env ~is_pub + ~ty_params_:Tvar_env.empty ~arity:arity_ ~params ~base:loc_ + in + let binder = Ident.of_ident binder.binder_id in + let params_ty = + Lst.map params + (fun (Param { ty; _ } | Discard_positional_param { ty; _ }) -> ty) + in + let return_ty = Option.map Typedtree_util.stype_of_typ ret in + match func_stubs with + | Intrinsic -> default_exprs + | Func_stub func_stubs -> + Ctop_stub + { + binder; + func_stubs; + params_ty; + return_ty; + is_pub_ = is_pub; + loc_; + } + :: default_exprs) + : Core.top_item list) -let transl ~(global_env : Global_env.t) (output : Typedtree.output) : - Core.program = - let (Output { value_defs; type_defs = _; trait_defs = _ }) = output in - Lst.concat_map value_defs (transl_impl ~global_env) +let transl ~(global_env : Global_env.t) (output : Typedtree.output) = + (let (Output { value_defs; _ }) = output in + Lst.concat_map value_defs (transl_impl ~global_env) + : Core.program) diff --git a/src/core_util.ml b/src/core_util.ml index 9cd99fd..5e49d00 100644 --- a/src/core_util.ml +++ b/src/core_util.ml @@ -19,217 +19,232 @@ module Ident_hashmap = Ident.Hash module VI = Basic_vec_int module Vec = Basic_vec module Lst = Basic_lst +module Type_path = Basic_type_path -let specialize (qual_name : Basic_qual_ident.t) (ty_args : Core.typ array) : - Primitive.prim option = - match qual_name with - | Qregular { pkg; name } when pkg = Basic_config.builtin_package -> ( - match name with - | "op_lt" -> ( - match Type.classify_as_builtin ty_args.(0) with - | `Int -> Some Primitive.lt_int - | `Int64 -> Some Primitive.lt_int64 - | `UInt -> Some Primitive.lt_uint - | `UInt64 -> Some Primitive.lt_uint64 - | `Double -> Some Primitive.lt_double - | `Float -> Some Primitive.lt_float - | `Char -> Some Primitive.lt_int - | `Byte -> Some Primitive.lt_int - | `Other -> None) - | "op_le" -> ( - match Type.classify_as_builtin ty_args.(0) with - | `Int -> Some Primitive.le_int - | `Int64 -> Some Primitive.le_int64 - | `UInt -> Some Primitive.le_uint - | `UInt64 -> Some Primitive.le_uint64 - | `Float -> Some Primitive.le_float - | `Double -> Some Primitive.le_double - | `Char -> Some Primitive.le_int - | `Byte -> Some Primitive.le_int - | `Other -> None) - | "op_ge" -> ( - match Type.classify_as_builtin ty_args.(0) with - | `Int -> Some Primitive.ge_int - | `Int64 -> Some Primitive.ge_int64 - | `UInt -> Some Primitive.ge_uint - | `UInt64 -> Some Primitive.ge_uint64 - | `Float -> Some Primitive.ge_float - | `Double -> Some Primitive.ge_double - | `Char -> Some Primitive.ge_int - | `Byte -> Some Primitive.ge_int - | `Other -> None) - | "op_gt" -> ( - match Type.classify_as_builtin ty_args.(0) with - | `Int -> Some Primitive.gt_int - | `Int64 -> Some Primitive.gt_int64 - | `UInt -> Some Primitive.gt_uint - | `UInt64 -> Some Primitive.gt_uint64 - | `Float -> Some Primitive.gt_float - | `Double -> Some Primitive.gt_double - | `Char -> Some Primitive.gt_int - | `Byte -> Some Primitive.gt_int - | `Other -> None) - | "op_notequal" -> ( - match Type.classify_as_builtin ty_args.(0) with - | `Int -> Some Primitive.ne_int - | `Int64 -> Some Primitive.ne_int64 - | `UInt -> Some Primitive.ne_uint - | `UInt64 -> Some Primitive.ne_uint64 - | `Float -> Some Primitive.ne_float - | `Double -> Some Primitive.ne_double - | `Char -> Some Primitive.ne_int - | `Byte -> Some Primitive.ne_int - | `Other -> None) - | _ -> None) - | _ -> None +let specialize (qual_name : Basic_qual_ident.t) (ty_args : Core.typ array) = + (match qual_name with + | Qregular { pkg; name } when pkg = Basic_config.builtin_package -> ( + match name with + | "op_lt" -> ( + match Type.classify_as_builtin ty_args.(0) with + | `Int -> Some Primitive.lt_int + | `Int64 -> Some Primitive.lt_int64 + | `UInt -> Some Primitive.lt_uint + | `UInt64 -> Some Primitive.lt_uint64 + | `Double -> Some Primitive.lt_double + | `Float -> Some Primitive.lt_float + | `Char -> Some Primitive.lt_int + | `Byte | `Int16 | `UInt16 -> Some Primitive.lt_int + | `Other -> None) + | "op_le" -> ( + match Type.classify_as_builtin ty_args.(0) with + | `Int -> Some Primitive.le_int + | `Int64 -> Some Primitive.le_int64 + | `UInt -> Some Primitive.le_uint + | `UInt64 -> Some Primitive.le_uint64 + | `Float -> Some Primitive.le_float + | `Double -> Some Primitive.le_double + | `Char -> Some Primitive.le_int + | `Byte | `Int16 | `UInt16 -> Some Primitive.le_int + | `Other -> None) + | "op_ge" -> ( + match Type.classify_as_builtin ty_args.(0) with + | `Int -> Some Primitive.ge_int + | `Int64 -> Some Primitive.ge_int64 + | `UInt -> Some Primitive.ge_uint + | `UInt64 -> Some Primitive.ge_uint64 + | `Float -> Some Primitive.ge_float + | `Double -> Some Primitive.ge_double + | `Char -> Some Primitive.ge_int + | `Byte | `Int16 | `UInt16 -> Some Primitive.ge_int + | `Other -> None) + | "op_gt" -> ( + match Type.classify_as_builtin ty_args.(0) with + | `Int -> Some Primitive.gt_int + | `Int64 -> Some Primitive.gt_int64 + | `UInt -> Some Primitive.gt_uint + | `UInt64 -> Some Primitive.gt_uint64 + | `Float -> Some Primitive.gt_float + | `Double -> Some Primitive.gt_double + | `Char -> Some Primitive.gt_int + | `Byte | `Int16 | `UInt16 -> Some Primitive.gt_int + | `Other -> None) + | "op_notequal" -> ( + match Type.classify_as_builtin ty_args.(0) with + | `Int -> Some Primitive.ne_int + | `Int64 -> Some Primitive.ne_int64 + | `UInt -> Some Primitive.ne_uint + | `UInt64 -> Some Primitive.ne_uint64 + | `Float -> Some Primitive.ne_float + | `Double -> Some Primitive.ne_double + | `Char -> Some Primitive.ne_int + | `Byte | `Int16 | `UInt16 -> Some Primitive.ne_int + | `Other -> None) + | _ -> None) + | _ -> None + : Primitive.prim option) -let specializable (qual_name : Basic_qual_ident.t) (ty_args : Core.typ array) : - bool = - Option.is_some (specialize qual_name ty_args) +let specializable (qual_name : Basic_qual_ident.t) (ty_args : Core.typ array) = + (match specialize qual_name ty_args with Some _ -> true | _ -> false : bool) type fn_group = | Non_rec of (Ident.t * Core.fn) | Rec of (Ident.t * Core.fn) list -let free_vars ~(exclude : Ident.Set.t) (fn : Core.fn) : Stype.t Ident.Map.t = - let go_ident ~env ~acc (id : Ident.t) ty = - match id with - | Pident _ | Pmutable_ident _ -> - if Ident_set.mem env id then acc else Ident.Map.add acc id ty - | Pdot _ | Plocal_method _ -> acc - in - let rec go_func ~env ~acc (func : Core.fn) = - let new_env = - Lst.fold_left func.params env (fun env p -> Ident_set.add env p.binder) - in - go ~env:new_env ~acc func.body - and go ~env ~acc (expr : Core.expr) = - match expr with - | Cexpr_const _ -> acc - | Cexpr_unit _ -> acc - | Cexpr_var { id; ty; prim = _ } -> go_ident ~env ~acc id ty - | Cexpr_as { expr; trait = _; obj_type = _ } -> go ~env ~acc expr - | Cexpr_prim { prim = _; args; ty = _ } -> - Lst.fold_left args acc (fun acc arg -> go ~env ~acc arg) - | Cexpr_let { name; rhs; body; ty = _ } -> - let new_env = Ident_set.add env name in - let new_acc = go ~env ~acc rhs in - go ~env:new_env ~acc:new_acc body - | Cexpr_letfn { name; fn; body; ty = _; kind = _ } -> - let new_env = Ident_set.add env name in - let new_acc = go_func ~env:new_env ~acc fn in - go ~env:new_env ~acc:new_acc body - | Cexpr_function { func; ty = _ } -> go_func ~env ~acc func - | Cexpr_apply { func; args; kind; ty = _; prim = _ } -> - let new_acc = - match kind with - | Normal { func_ty } -> go_ident ~env ~acc func func_ty - | Join -> acc - in - Lst.fold_left args new_acc (fun acc arg -> go ~env ~acc arg) - | Cexpr_letrec { bindings; body; ty = _ } -> - let new_env = - Lst.fold_left bindings env (fun env (binder, _) -> - Ident_set.add env binder) - in - let new_acc = - Lst.fold_left bindings acc (fun acc (_, fn) -> - go_func ~env:new_env ~acc fn) - in - go ~env:new_env ~acc:new_acc body - | Cexpr_constr { constr = _; tag = _; args; ty = _ } -> - Lst.fold_left args acc (fun acc arg -> go ~env ~acc arg) - | Cexpr_tuple { exprs; ty = _ } -> - Lst.fold_left exprs acc (fun acc expr -> go ~env ~acc expr) - | Cexpr_record { fields; ty = _ } -> - Lst.fold_left fields acc (fun acc field -> go ~env ~acc field.expr) - | Cexpr_record_update { record; fields; fields_num = _; ty = _ } -> - let new_acc = go ~env ~acc record in - Lst.fold_left fields new_acc (fun acc field -> go ~env ~acc field.expr) - | Cexpr_field { record; accessor = _; pos = _; ty = _ } -> - go ~env ~acc record - | Cexpr_mutate { record; label = _; field; pos = _; ty = _ } -> - let new_acc = go ~env ~acc record in - go ~env ~acc:new_acc field - | Cexpr_array { exprs; ty = _ } -> - Lst.fold_left exprs acc (fun acc expr -> go ~env ~acc expr) - | Cexpr_assign { var; expr; ty = _ } -> - let new_acc = go_ident ~env ~acc var (Core.type_of_expr expr) in - go ~env ~acc:new_acc expr - | Cexpr_sequence { expr1; expr2; ty = _ } -> - let new_acc = go ~env ~acc expr1 in - go ~env ~acc:new_acc expr2 - | Cexpr_if { cond; ifso; ifnot; ty = _ } -> ( - let acc1 = go ~env ~acc cond in - let acc2 = go ~env ~acc:acc1 ifso in - match ifnot with Some ifnot -> go ~env ~acc:acc2 ifnot | None -> acc2) - | Cexpr_switch_constr { obj; cases; default; ty = _ } -> ( - let acc1 = go ~env ~acc obj in - let acc2 = - Lst.fold_left cases acc1 (fun acc (_tag, binder, case) -> - let new_env = - match binder with - | None -> env - | Some binder -> Ident_set.add env binder - in - go ~env:new_env ~acc case) - in - match default with - | Some default -> go ~env ~acc:acc2 default - | None -> acc2) - | Cexpr_switch_constant { obj; cases; default; ty = _ } -> - let acc1 = go ~env ~acc obj in - let acc2 = - Lst.fold_left cases acc1 (fun acc (_const, case) -> go ~env ~acc case) - in - go ~env ~acc:acc2 default - | Cexpr_loop { params; body; args; ty = _; label = _ } -> - let new_env = - Lst.fold_left params env (fun env p -> Ident_set.add env p.binder) - in - let new_acc = - Lst.fold_left args acc (fun acc arg -> go ~env ~acc arg) - in - go ~env:new_env ~acc:new_acc body - | Cexpr_break { arg; ty = _; label = _ } -> ( - match arg with Some arg -> go ~env ~acc arg | None -> acc) - | Cexpr_continue { args; ty = _; label = _ } -> - Lst.fold_left args acc (fun acc arg -> go ~env ~acc arg) - | Cexpr_handle_error { obj; ty = _; handle_kind = _ } -> go ~env ~acc obj - | Cexpr_return { expr; _ } -> go ~env ~acc expr - in - let init_env = - Lst.fold_left fn.params exclude (fun env p -> Ident_set.add env p.binder) - in - go ~env:init_env ~acc:Ident.Map.empty fn.body - -let group_local_fn_bindings (bindings : (Ident.t * Core.fn) list) : - fn_group list = - let n = List.length bindings in - let binding_array = Array.of_list bindings in - let binder_index_map = - Ident_hashmap.of_list - (List.mapi (fun i (binder, _) -> (binder, i)) bindings) - in - let adjacency_array = - Array.init n (fun src -> - let _, src_fn = binding_array.(src) in - let dst_binders = free_vars ~exclude:Ident_set.empty src_fn in - let dst_vec = VI.empty () in - Ident.Map.iter dst_binders (fun dst_binder _ -> - let dst = Ident_hashmap.find_opt binder_index_map dst_binder in - match dst with Some dst -> VI.push dst_vec dst | None -> ()); - dst_vec) - in - let scc = Basic_scc.graph adjacency_array in - Vec.map_into_list scc (fun group -> - if VI.length group = 1 then - let i = VI.get group 0 in - let binder, fn = binding_array.(i) in - if Ident.Map.mem (free_vars ~exclude:Ident_set.empty fn) binder then - Rec [ (binder, fn) ] - else Non_rec (binder, fn) - else Rec (VI.map_into_list group (fun i -> binding_array.(i)))) +let free_vars ~(exclude : Ident.Set.t) (fn : Core.fn) = + (let go_ident ~env ~acc (id : Ident.t) ty = + match id with + | Pident _ | Pmutable_ident _ -> + if Ident_set.mem env id then acc else Ident.Map.add acc id ty + | Pdot _ | Plocal_method _ -> acc + in + let rec go_func ~env ~acc (func : Core.fn) = + let new_env = + Lst.fold_left func.params env (fun env -> + fun p -> Ident_set.add env p.binder) + in + go ~env:new_env ~acc func.body + and go ~env ~acc (expr : Core.expr) = + match expr with + | Cexpr_const _ -> acc + | Cexpr_unit _ -> acc + | Cexpr_var { id; ty; prim = _ } -> go_ident ~env ~acc id ty + | Cexpr_as { expr; trait = _; obj_type = _ } -> go ~env ~acc expr + | Cexpr_prim { prim = _; args; ty = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_and { lhs; rhs; _ } | Cexpr_or { lhs; rhs; _ } -> + let acc1 = go ~env ~acc lhs in + go ~env ~acc:acc1 rhs + | Cexpr_let { name; rhs; body; ty = _ } -> + let new_env = Ident_set.add env name in + let new_acc = go ~env ~acc rhs in + go ~env:new_env ~acc:new_acc body + | Cexpr_letfn { name; fn; body; ty = _; kind = _ } -> + let new_env = Ident_set.add env name in + let new_acc = go_func ~env:new_env ~acc fn in + go ~env:new_env ~acc:new_acc body + | Cexpr_function { func; ty = _ } -> go_func ~env ~acc func + | Cexpr_apply { func; args; kind; ty = _; prim = _ } -> + let new_acc = + match kind with + | Normal { func_ty } | Async { func_ty } -> + go_ident ~env ~acc func func_ty + | Join -> acc + in + Lst.fold_left args new_acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_letrec { bindings; body; ty = _ } -> + let new_env = + Lst.fold_left bindings env (fun env -> + fun (binder, _) -> Ident_set.add env binder) + in + let new_acc = + Lst.fold_left bindings acc (fun acc -> + fun (_, fn) -> go_func ~env:new_env ~acc fn) + in + go ~env:new_env ~acc:new_acc body + | Cexpr_constr { tag = _; args; ty = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_tuple { exprs; ty = _ } -> + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + | Cexpr_record { fields; ty = _ } -> + Lst.fold_left fields acc (fun acc -> + fun field -> go ~env ~acc field.expr) + | Cexpr_record_update { record; fields; fields_num = _; ty = _ } -> + let new_acc = go ~env ~acc record in + Lst.fold_left fields new_acc (fun acc -> + fun field -> go ~env ~acc field.expr) + | Cexpr_field { record; accessor = _; pos = _; ty = _ } -> + go ~env ~acc record + | Cexpr_mutate { record; label = _; field; pos = _; ty = _ } -> + let new_acc = go ~env ~acc record in + go ~env ~acc:new_acc field + | Cexpr_array { exprs; ty = _ } -> + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + | Cexpr_assign { var; expr; ty = _ } -> + let new_acc = go_ident ~env ~acc var (Core.type_of_expr expr) in + go ~env ~acc:new_acc expr + | Cexpr_sequence { exprs; last_expr; ty = _ } -> + let new_acc = + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + in + go ~env ~acc:new_acc last_expr + | Cexpr_if { cond; ifso; ifnot; ty = _ } -> ( + let acc1 = go ~env ~acc cond in + let acc2 = go ~env ~acc:acc1 ifso in + match ifnot with Some ifnot -> go ~env ~acc:acc2 ifnot | None -> acc2) + | Cexpr_switch_constr { obj; cases; default; ty = _ } -> ( + let acc1 = go ~env ~acc obj in + let acc2 = + Lst.fold_left cases acc1 (fun acc -> + fun (_tag, binder, case) -> + let new_env = + match binder with + | None -> env + | Some binder -> Ident_set.add env binder + in + go ~env:new_env ~acc case) + in + match default with + | Some default -> go ~env ~acc:acc2 default + | None -> acc2) + | Cexpr_switch_constant { obj; cases; default; ty = _ } -> + let acc1 = go ~env ~acc obj in + let acc2 = + Lst.fold_left cases acc1 (fun acc -> + fun (_const, case) -> go ~env ~acc case) + in + go ~env ~acc:acc2 default + | Cexpr_loop { params; body; args; ty = _; label = _ } -> + let new_env = + Lst.fold_left params env (fun env -> + fun p -> Ident_set.add env p.binder) + in + let new_acc = + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + in + go ~env:new_env ~acc:new_acc body + | Cexpr_break { arg; ty = _; label = _ } -> ( + match arg with Some arg -> go ~env ~acc arg | None -> acc) + | Cexpr_continue { args; ty = _; label = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_handle_error { obj; ty = _; handle_kind = _ } -> go ~env ~acc obj + | Cexpr_return { expr; _ } -> go ~env ~acc expr + in + let init_env = + Lst.fold_left fn.params exclude (fun env -> + fun p -> Ident_set.add env p.binder) + in + go ~env:init_env ~acc:Ident.Map.empty fn.body + : Stype.t Ident.Map.t) + +let group_local_fn_bindings (bindings : (Ident.t * Core.fn) list) = + (let n = List.length bindings in + let binding_array = Array.of_list bindings in + let binder_index_map = + Ident_hashmap.of_list + (List.mapi (fun i -> fun (binder, _) -> (binder, i)) bindings) + in + let adjacency_array = + Array.init n (fun src -> + let _, src_fn = binding_array.(src) in + let dst_binders = free_vars ~exclude:Ident_set.empty src_fn in + let dst_vec = VI.empty () in + Ident.Map.iter dst_binders (fun dst_binder -> + fun _ -> + let dst = Ident_hashmap.find_opt binder_index_map dst_binder in + match dst with Some dst -> VI.push dst_vec dst | None -> ()); + dst_vec) + in + let scc = Basic_scc.graph adjacency_array in + Vec.map_into_list scc ~unorder:(fun group -> + if VI.length group = 1 then + let i = VI.get group 0 in + let binder, fn = binding_array.(i) in + if Ident.Map.mem (free_vars ~exclude:Ident_set.empty fn) binder then + Rec [ (binder, fn) ] + else Non_rec (binder, fn) + else Rec (VI.map_into_list group ~unorder:(fun i -> binding_array.(i)))) + : fn_group list) module Transform_return : sig val transform_return_in_fn_body : Core.expr -> Core.expr @@ -297,8 +312,12 @@ end = struct method! visit_Cexpr_letrec ctx bindings body _ty loc_ = Core.letrec ~loc:loc_ bindings (self#visit_expr ctx body) - method! visit_Cexpr_function _ctx fn ty loc_ = - Core.function_ ~loc:loc_ ~ty fn.params fn.body + method! visit_Cexpr_function _ctx fn ty is_raw loc_ = + if is_raw then + Core.raw_function ~loc:loc_ ~ty fn.params fn.body + ~is_async:fn.is_async + else + Core.function_ ~loc:loc_ ~ty fn.params fn.body ~is_async:fn.is_async end let ghost_loc_ = Rloc.no_location @@ -334,6 +353,7 @@ end = struct }; ]; body = Core.var ~ty_args_:[||] ~ty:return_value_ty return_value_id; + is_async = false; } body else body @@ -358,6 +378,7 @@ end = struct }; ]; body = wrapped_var; + is_async = false; } in Core.letfn ~kind:Nontail_join return_join fn body @@ -373,6 +394,7 @@ end = struct params = [ { binder = err_var_id; ty = err_ty; loc_ = ghost_loc_ } ]; body = wrapped_var; + is_async = false; } in Core.letfn ~kind:Nontail_join error_ctx.raise_join fn body @@ -434,7 +456,7 @@ let inline_array_iter ~(arr_id : Ident.t) ~(arr_ty : Stype.t) ] loop_label Stype.unit in - let ifso = Core.let_ elem_id elem_rhs (Core.sequence if_body cont) in + let ifso = Core.let_ elem_id elem_rhs (Core.sequence2 if_body cont) in let if_expr = Core.if_ ~ifso (Core.prim ~ty:Stype.bool Primitive.lt_int [ i_expr; len_expr ]) @@ -451,8 +473,8 @@ let visitor = method! visit_var subst id = Ident.Hash.find_default subst id id end -let substitute ~subst (expr : Core.expr) : Core.expr = - visitor#visit_expr subst expr +let substitute ~subst (expr : Core.expr) = + (visitor#visit_expr subst expr : Core.expr) let single_visitor = object @@ -462,22 +484,24 @@ let single_visitor = end let rec flat_let ?(loc = Rloc.no_location) (id : Ident.t) (rhs : Core.expr) - (body : Core.expr) : Core.expr = - match rhs with - | Cexpr_let { name = id2; rhs = rhs2; body = body2; ty = _; loc_ } -> - let body = flat_let id body2 body in - Core.let_ id2 rhs2 body ~loc:loc_ - | Cexpr_var { id = id2; _ } -> single_visitor#visit_expr (id, id2) body - | _ -> Core.let_ id rhs body ~loc + (body : Core.expr) = + (match rhs with + | Cexpr_let { name = id2; rhs = rhs2; body = body2; ty = _; loc_ } -> + let body = flat_let id body2 body in + Core.let_ id2 rhs2 body ~loc:loc_ + | Cexpr_var { id = id2; _ } -> single_visitor#visit_expr (id, id2) body + | _ -> Core.let_ id rhs body ~loc + : Core.expr) let rec apply_with_beta ?(loc = Rloc.no_location) (func : Core.expr) (args : Core.expr list) ty = match func with | Cexpr_var { id = func; ty = func_ty; ty_args_; prim } -> Core.apply ~loc ~ty_args_ ~kind:(Normal { func_ty }) ~ty ~prim func args - | Cexpr_function { func = { params; body }; _ } -> - Lst.fold_left2 params args body (fun p a body -> - flat_let p.binder a (transform_return_in_fn_body body)) + | Cexpr_function { func = { params; body; is_async = _ }; _ } -> + Lst.fold_left2 params args body (fun p -> + fun a -> + fun body -> flat_let p.binder a (transform_return_in_fn_body body)) | Cexpr_let { name; rhs; body; ty = _ } -> flat_let name rhs (apply_with_beta body args ty) ~loc | func -> @@ -494,13 +518,13 @@ let iter_go_expr = one_expr let iter_end_expr = zero_expr let lt_expr e1 e2 = Core.prim ~ty:Stype.bool Primitive.lt_int [ e1; e2 ] let eq_expr e1 e2 = Core.prim ~ty:Stype.bool Primitive.eq_int [ e1; e2 ] -let and_expr e1 e2 = Core.prim ~ty:Stype.bool Primitive.Psequand [ e1; e2 ] -let or_expr e1 e2 = Core.prim ~ty:Stype.bool Primitive.Psequor [ e1; e2 ] +let and_expr e1 e2 = Core.and_ ~loc:Rloc.no_location e1 e2 +let or_expr e1 e2 = Core.or_ ~loc:Rloc.no_location e1 e2 let mutable_var_label : Parsing_syntax.label = { label_name = "val"; loc_ = Rloc.no_location } -let mutable_var_type (ty : Core.typ) : Core.typ = Builtin.type_ref ty +let mutable_var_type (ty : Core.typ) = (Builtin.type_ref ty : Core.typ) let add_one_expr e = Core.prim @@ -508,23 +532,25 @@ let add_one_expr e = [ e; one_expr ] ~ty:Stype.int let anon_func ?(loc = Rloc.no_location) (param_ty : Stype.t) - (body : Core.expr -> Core.expr) : Core.expr = - let p = Ident.fresh "*p" in - let p_var = Core.var ~ty:param_ty p in - let p_param : Core.param = - { binder = p; ty = param_ty; loc_ = Rloc.no_location } - in - let body = body p_var in - let ty = - Stype.Tarrow - { - params_ty = [ param_ty ]; - ret_ty = Core.type_of_expr body; - err_ty = None; - generic_ = false; - } - in - Core.function_ ~loc [ p_param ] body ~ty + (body : Core.expr -> Core.expr) = + (let p = Ident.fresh "*p" in + let p_var = Core.var ~ty:param_ty p in + let p_param : Core.param = + { binder = p; ty = param_ty; loc_ = Rloc.no_location } + in + let body = body p_var in + let ty = + Stype.Tarrow + { + params_ty = [ param_ty ]; + ret_ty = Core.type_of_expr body; + err_ty = None; + is_async = false; + generic_ = false; + } + in + Core.function_ ~loc [ p_param ] body ~ty ~is_async:false + : Core.expr) let ref_init expr = let ty = Core.type_of_expr expr in @@ -533,301 +559,348 @@ let ref_init expr = let ignore_ ?loc e = Core.prim ?loc ~ty:Stype.unit Pignore [ e ] -let make_iter_iter ~(it : Core.expr) ~(f : Core.expr) ~loc : Core.expr = - let a_ty = - match Stype.type_repr (Core.type_of_expr f) with - | Tarrow { params_ty = a_ty :: []; _ } -> a_ty - | _ -> assert false - in - let arg = - anon_func a_ty (fun a_var -> - Core.sequence (apply_with_beta f [ a_var ] Stype.unit) iter_go_expr) - in - ignore_ ~loc (apply_with_beta it [ arg ] Stype.int ~loc) +let make_iter_iter ~(it : Core.expr) ~(f : Core.expr) ~loc = + (let a_ty = + match Stype.type_repr (Core.type_of_expr f) with + | Tarrow { params_ty = a_ty :: []; _ } -> a_ty + | _ -> assert false + in + let arg = + anon_func a_ty (fun a_var -> + Core.sequence2 (apply_with_beta f [ a_var ] Stype.unit) iter_go_expr) + in + ignore_ ~loc (apply_with_beta it [ arg ] Stype.int ~loc) + : Core.expr) -let make_iter_map ~(it : Core.expr) ~(f : Core.expr) ~loc : Core.expr = - let a_ty, b_ty = - match Stype.type_repr (Core.type_of_expr f) with - | Tarrow { ret_ty = b_ty; params_ty = a_ty :: []; err_ty = None } -> - (a_ty, b_ty) - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ b_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - anon_func k_ty (fun k_var -> - let arg = - anon_func a_ty (fun a_var -> - apply_with_beta k_var [ apply_with_beta f [ a_var ] b_ty ] Stype.int) - in - apply_with_beta it [ arg ] Stype.int ~loc) +let make_iter_map ~(it : Core.expr) ~(f : Core.expr) ~loc = + (let a_ty, b_ty = + match Stype.type_repr (Core.type_of_expr f) with + | Tarrow + { + ret_ty = b_ty; + params_ty = a_ty :: []; + err_ty = None; + is_async = false; + } -> + (a_ty, b_ty) + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ b_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + anon_func k_ty (fun k_var -> + let arg = + anon_func a_ty (fun a_var -> + apply_with_beta k_var + [ apply_with_beta f [ a_var ] b_ty ] + Stype.int) + in + apply_with_beta it [ arg ] Stype.int ~loc) + : Core.expr) -let make_iter_filter ~(it : Core.expr) ~(f : Core.expr) ~loc : Core.expr = - let a_ty = - match Stype.type_repr (Core.type_of_expr f) with - | Tarrow { params_ty = a_ty :: []; _ } -> a_ty - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ a_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - anon_func k_ty (fun k_var -> - let arg = - anon_func a_ty (fun a_var -> - let ifso = apply_with_beta k_var [ a_var ] Stype.int in - let ifnot = iter_go_expr in - Core.if_ (apply_with_beta f [ a_var ] Stype.bool) ~ifso ~ifnot) - in - apply_with_beta it [ arg ] Stype.int ~loc) - -let make_iter_take ~(it : Core.expr) ~(n : Core.expr) ~loc : Core.expr = - let a_ty = - match Stype.type_repr (Core.type_of_expr it) with - | T_constr { type_constructor = _; tys = a_ty :: [] } -> a_ty - | Tarrow { params_ty = Tarrow { params_ty = a_ty :: []; _ } :: []; _ } -> - a_ty - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ a_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - let i_id = Ident.fresh "*i" in - let i_expr = Core.var ~ty:(mutable_var_type Stype.int) i_id in - let i_init = ref_init zero_expr in - let i_field = - Core.field ~pos:0 ~ty:Stype.int i_expr (Label mutable_var_label) - in - let bind_i e = Core.let_ i_id i_init e in - anon_func k_ty ~loc (fun k_var -> - let mutate_i = - Core.mutate ~pos:0 i_expr mutable_var_label (add_one_expr i_field) - in - let arg = - anon_func a_ty (fun a_var -> - let ifso = Core.sequence mutate_i iter_go_expr in - let k_a = apply_with_beta k_var [ a_var ] Stype.int in - let cond = - and_expr (lt_expr i_field n) (eq_expr k_a iter_go_expr) - in - Core.if_ cond ~ifso ~ifnot:iter_end_expr) - in - let cond = - or_expr - (eq_expr (apply_with_beta it [ arg ] Stype.int) iter_go_expr) - (eq_expr i_field n) - in - bind_i (Core.if_ cond ~ifso:iter_go_expr ~ifnot:iter_end_expr)) +let make_iter_filter ~(it : Core.expr) ~(f : Core.expr) ~loc = + (let a_ty = + match Stype.type_repr (Core.type_of_expr f) with + | Tarrow { params_ty = a_ty :: []; _ } -> a_ty + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ a_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + anon_func k_ty (fun k_var -> + let arg = + anon_func a_ty (fun a_var -> + let ifso = apply_with_beta k_var [ a_var ] Stype.int in + let ifnot = iter_go_expr in + Core.if_ (apply_with_beta f [ a_var ] Stype.bool) ~ifso ~ifnot) + in + apply_with_beta it [ arg ] Stype.int ~loc) + : Core.expr) + +let make_iter_take ~(it : Core.expr) ~(n : Core.expr) ~loc = + (let a_ty = + match Stype.type_repr (Core.type_of_expr it) with + | T_constr { type_constructor = _; tys = a_ty :: [] } -> a_ty + | Tarrow { params_ty = Tarrow { params_ty = a_ty :: []; _ } :: []; _ } -> + a_ty + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ a_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + let i_id = Ident.fresh "*i" in + let i_expr = Core.var ~ty:(mutable_var_type Stype.int) i_id in + let i_init = ref_init zero_expr in + let i_field = + Core.field ~pos:0 ~ty:Stype.int i_expr (Label mutable_var_label) + in + let bind_i e = Core.let_ i_id i_init e in + anon_func k_ty ~loc (fun k_var -> + let mutate_i = + Core.mutate ~pos:0 i_expr mutable_var_label (add_one_expr i_field) + in + let arg = + anon_func a_ty (fun a_var -> + let ifso = Core.sequence2 mutate_i iter_go_expr in + let k_a = apply_with_beta k_var [ a_var ] Stype.int in + let cond = + and_expr (lt_expr i_field n) (eq_expr k_a iter_go_expr) + in + Core.if_ cond ~ifso ~ifnot:iter_end_expr) + in + let cond = + or_expr + (eq_expr (apply_with_beta it [ arg ] Stype.int) iter_go_expr) + (eq_expr i_field n) + in + bind_i (Core.if_ cond ~ifso:iter_go_expr ~ifnot:iter_end_expr)) + : Core.expr) let make_iter_reduce ~(it : Core.expr) ~(init : Core.expr) ~(f : Core.expr) ~loc - : Core.expr = - let a_ty, b_ty = - match Stype.type_repr (Core.type_of_expr f) with - | Tarrow { params_ty = [ b_ty; a_ty ]; _ } -> (a_ty, b_ty) - | _ -> assert false - in - let acc_id = Ident.fresh "*acc" in - let acc_expr = Core.var ~ty:(mutable_var_type b_ty) acc_id in - let acc_init = ref_init init in - let bind_acc e = Core.let_ acc_id acc_init e in - let acc_field = - Core.field ~pos:0 ~ty:b_ty acc_expr (Label mutable_var_label) - in - let arg = - anon_func a_ty (fun a_var -> - let mutate = - Core.mutate ~pos:0 acc_expr mutable_var_label - (apply_with_beta f [ acc_field; a_var ] b_ty) - in - Core.sequence mutate iter_go_expr) - in - bind_acc - (Core.sequence - (ignore_ (apply_with_beta it [ arg ] Stype.int)) - acc_field ~loc) - -let make_iter_flat_map ~(it : Core.expr) ~(f : Core.expr) ~loc : Core.expr = - let a_ty, b_ty = - match Stype.type_repr (Core.type_of_expr f) with - | Tarrow - { - params_ty = a_ty :: []; - ret_ty = - ( Tarrow - { params_ty = Tarrow { params_ty = b_ty :: []; _ } :: []; _ } - | T_constr { type_constructor = _; tys = b_ty :: [] } ); - _; - } -> - (a_ty, b_ty) - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ b_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - let iter_b_ty = - Stype.Tarrow - { - params_ty = [ k_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - anon_func k_ty (fun k_var -> - let arg = - anon_func a_ty (fun a_var -> - let f_a = apply_with_beta f [ a_var ] iter_b_ty in - apply_with_beta f_a [ k_var ] Stype.int) - in - apply_with_beta it [ arg ] Stype.int ~loc) - -let make_iter_repeat (a : Core.expr) ~loc : Core.expr = - let a_ty = Core.type_of_expr a in - let k_ty = - Stype.Tarrow - { - params_ty = [ a_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - let loop_label = Label.fresh "*loop" in - anon_func k_ty (fun k_var -> - let ifso = Core.continue [] loop_label Stype.int in - let ifnot = - Core.break (Some iter_end_expr) loop_label Stype.int - ~loc_:Rloc.no_location - in - let cond = eq_expr (apply_with_beta k_var [ a ] Stype.int) iter_go_expr in - let if_expr = Core.if_ cond ~ifso ~ifnot in - Core.loop [] if_expr [] loop_label ~loc) - -let make_iter_concat (it : Core.expr) (other_it : Core.expr) ~loc : Core.expr = - let a_ty = - match Stype.type_repr (Core.type_of_expr it) with - | T_constr { type_constructor = _; tys = a_ty :: [] } -> a_ty - | Tarrow { params_ty = Tarrow { params_ty = a_ty :: []; _ } :: []; _ } -> - a_ty - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ a_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - anon_func ~loc k_ty (fun k_var -> - let it_k = apply_with_beta it [ k_var ] Stype.int in - let other_it_k = apply_with_beta other_it [ k_var ] Stype.int in - let cond = - and_expr (eq_expr it_k iter_go_expr) (eq_expr other_it_k iter_go_expr) - in - Core.if_ cond ~ifso:iter_go_expr ~ifnot:iter_end_expr) + = + (let a_ty, b_ty = + match Stype.type_repr (Core.type_of_expr f) with + | Tarrow { params_ty = [ b_ty; a_ty ]; _ } -> (a_ty, b_ty) + | _ -> assert false + in + let acc_id = Ident.fresh "*acc" in + let acc_expr = Core.var ~ty:(mutable_var_type b_ty) acc_id in + let acc_init = ref_init init in + let bind_acc e = Core.let_ acc_id acc_init e in + let acc_field = + Core.field ~pos:0 ~ty:b_ty acc_expr (Label mutable_var_label) + in + let arg = + anon_func a_ty (fun a_var -> + let mutate = + Core.mutate ~pos:0 acc_expr mutable_var_label + (apply_with_beta f [ acc_field; a_var ] b_ty) + in + Core.sequence2 mutate iter_go_expr) + in + bind_acc + (Core.sequence2 + (ignore_ (apply_with_beta it [ arg ] Stype.int)) + acc_field ~loc) + : Core.expr) -let make_iter_from_array ~(arr : Core.expr) ~loc : Core.expr = - let arr_ty = Core.type_of_expr arr in - let elem_ty = - match Stype.type_repr arr_ty with - | T_constr { type_constructor = T_fixedarray; tys = elem_ty :: [] } -> - elem_ty - | _ -> assert false - in - let k_ty = - Stype.Tarrow - { - params_ty = [ elem_ty ]; - ret_ty = Stype.int; - err_ty = None; - generic_ = false; - } - in - anon_func ~loc k_ty (fun k_var -> - let arr_id = Ident.fresh "*arr" in - let arr_expr = Core.var ~ty:arr_ty arr_id in - let i_id = Ident.fresh "*i" in - let i_expr = Core.var ~ty:Stype.int i_id in - let i_param : Core.param = - { binder = i_id; ty = Stype.int; loc_ = Rloc.no_location } - in - let k_arr_i = - apply_with_beta k_var - [ - Core.prim ~ty:elem_ty - (Pfixedarray_get_item { kind = Unsafe }) - [ arr_expr; i_expr ]; - ] - Stype.int - in - let loop_label = Label.fresh "*loop" in - let if_cond = eq_expr k_arr_i iter_go_expr in - let cont = Core.continue [ add_one_expr i_expr ] loop_label Stype.int in - let brk_false = - Core.break (Some iter_end_expr) loop_label Stype.int - ~loc_:Rloc.no_location - in - let brk_true = - Core.break (Some iter_go_expr) loop_label Stype.int - ~loc_:Rloc.no_location - in - let ifso = Core.if_ if_cond ~ifso:cont ~ifnot:brk_false in - let len_id = Ident.fresh "*len" in - let len_rhs = - Core.prim ~ty:Stype.int Primitive.Pfixedarray_length [ arr_expr ] - in - let len_expr = Core.var ~ty:Stype.int len_id in - let if_expr = Core.if_ ~ifso (lt_expr i_expr len_expr) ~ifnot:brk_true in - let loop = - Core.loop [ i_param ] if_expr [ zero_expr ] loop_label - ~loc:Rloc.no_location - in - Core.let_ arr_id arr (Core.let_ len_id len_rhs loop)) +let make_iter_flat_map ~(it : Core.expr) ~(f : Core.expr) ~loc = + (let a_ty, b_ty = + match Stype.type_repr (Core.type_of_expr f) with + | Tarrow + { + params_ty = a_ty :: []; + ret_ty = + ( Tarrow + { params_ty = Tarrow { params_ty = b_ty :: []; _ } :: []; _ } + | T_constr { type_constructor = _; tys = b_ty :: [] } ); + _; + } -> + (a_ty, b_ty) + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ b_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + let iter_b_ty = + Stype.Tarrow + { + params_ty = [ k_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + anon_func k_ty (fun k_var -> + let arg = + anon_func a_ty (fun a_var -> + let f_a = apply_with_beta f [ a_var ] iter_b_ty in + apply_with_beta f_a [ k_var ] Stype.int) + in + apply_with_beta it [ arg ] Stype.int ~loc) + : Core.expr) + +let make_iter_repeat (a : Core.expr) ~loc = + (let a_ty = Core.type_of_expr a in + let k_ty = + Stype.Tarrow + { + params_ty = [ a_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + let loop_label = Label.fresh "*loop" in + anon_func k_ty (fun k_var -> + let ifso = Core.continue [] loop_label Stype.int in + let ifnot = + Core.break (Some iter_end_expr) loop_label Stype.int + ~loc_:Rloc.no_location + in + let cond = + eq_expr (apply_with_beta k_var [ a ] Stype.int) iter_go_expr + in + let if_expr = Core.if_ cond ~ifso ~ifnot in + Core.loop [] if_expr [] loop_label ~loc) + : Core.expr) + +let make_iter_concat (it : Core.expr) (other_it : Core.expr) ~loc = + (let a_ty = + match Stype.type_repr (Core.type_of_expr it) with + | T_constr { type_constructor = _; tys = a_ty :: [] } -> a_ty + | Tarrow { params_ty = Tarrow { params_ty = a_ty :: []; _ } :: []; _ } -> + a_ty + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ a_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + anon_func ~loc k_ty (fun k_var -> + let it_k = apply_with_beta it [ k_var ] Stype.int in + let other_it_k = apply_with_beta other_it [ k_var ] Stype.int in + let cond = + and_expr (eq_expr it_k iter_go_expr) (eq_expr other_it_k iter_go_expr) + in + Core.if_ cond ~ifso:iter_go_expr ~ifnot:iter_end_expr) + : Core.expr) + +let make_iter_from_array ~(arr : Core.expr) ~loc = + (let arr_ty = Core.type_of_expr arr in + let elem_ty = + match Stype.type_repr arr_ty with + | T_constr { type_constructor = T_fixedarray; tys = elem_ty :: [] } -> + elem_ty + | _ -> assert false + in + let k_ty = + Stype.Tarrow + { + params_ty = [ elem_ty ]; + ret_ty = Stype.int; + err_ty = None; + is_async = false; + generic_ = false; + } + in + anon_func ~loc k_ty (fun k_var -> + let arr_id = Ident.fresh "*arr" in + let arr_expr = Core.var ~ty:arr_ty arr_id in + let i_id = Ident.fresh "*i" in + let i_expr = Core.var ~ty:Stype.int i_id in + let i_param : Core.param = + { binder = i_id; ty = Stype.int; loc_ = Rloc.no_location } + in + let k_arr_i = + apply_with_beta k_var + [ + Core.prim ~ty:elem_ty + (Pfixedarray_get_item { kind = Unsafe }) + [ arr_expr; i_expr ]; + ] + Stype.int + in + let loop_label = Label.fresh "*loop" in + let if_cond = eq_expr k_arr_i iter_go_expr in + let cont = Core.continue [ add_one_expr i_expr ] loop_label Stype.int in + let brk_false = + Core.break (Some iter_end_expr) loop_label Stype.int + ~loc_:Rloc.no_location + in + let brk_true = + Core.break (Some iter_go_expr) loop_label Stype.int + ~loc_:Rloc.no_location + in + let ifso = Core.if_ if_cond ~ifso:cont ~ifnot:brk_false in + let len_id = Ident.fresh "*len" in + let len_rhs = + Core.prim ~ty:Stype.int Primitive.Pfixedarray_length [ arr_expr ] + in + let len_expr = Core.var ~ty:Stype.int len_id in + let if_expr = Core.if_ ~ifso (lt_expr i_expr len_expr) ~ifnot:brk_true in + let loop = + Core.loop [ i_param ] if_expr [ zero_expr ] loop_label + ~loc:Rloc.no_location + in + Core.let_ arr_id arr (Core.let_ len_id len_rhs loop)) + : Core.expr) let make_array_length ?loc arr = Core.field ?loc ~ty:Stype.int ~pos:1 arr (Label { label_name = "len"; loc_ = Rloc.no_location }) -let make_array_buffer ~elem_ty arr = +let make_array_buffer ~elem_ty ~buf_label_name arr = let ty = Builtin.type_fixedarray (Builtin.type_maybe_uninit elem_ty) in Core.field ~ty ~pos:0 arr - (Label { label_name = "buf"; loc_ = Rloc.no_location }) + (Label { label_name = buf_label_name; loc_ = Rloc.no_location }) -let make_array_unsafe_get ~elem_ty arr index = +let make_array_unsafe_get ~elem_ty ~buf_label_name arr index = Core.prim ~ty:elem_ty (Pfixedarray_get_item { kind = Unsafe }) - [ make_array_buffer ~elem_ty arr; index ] + [ make_array_buffer ~elem_ty ~buf_label_name arr; index ] let make_array_unsafe_set arr index value = let elem_ty = Core.type_of_expr value in Core.prim ~ty:Stype.unit (Pfixedarray_set_item { set_kind = Unsafe }) - [ make_array_buffer ~elem_ty arr; index; value ] + [ make_array_buffer ~elem_ty ~buf_label_name:"buf" arr; index; value ] + +let make_arrayview_start arr = + Core.field ~ty:Stype.int ~pos:1 arr + (Label { label_name = "start"; loc_ = Rloc.no_location }) + +let make_arrayview_length ~loc arr = + Core.field ~loc ~ty:Stype.int ~pos:2 arr + (Label { label_name = "len"; loc_ = Rloc.no_location }) + +let make_int_add e1 e2 = + (Core.prim ~ty:Stype.int + (Parith { operand_type = I32; operator = Add }) + [ e1; e2 ] + : Core.expr) + +let make_int_sub e1 e2 = + (Core.prim ~ty:Stype.int + (Parith { operand_type = I32; operator = Sub }) + [ e1; e2 ] + : Core.expr) let try_apply_intrinsic (intrinsic : Moon_intrinsic.t) (args : Core.expr list) ~loc ~ty = @@ -855,92 +928,187 @@ let try_apply_intrinsic (intrinsic : Moon_intrinsic.t) (args : Core.expr list) let anon_func_param = match func.params with p :: [] -> p.binder | _ -> assert false in - Core.bind ~loc arr (fun arr_id -> - inline_array_iter ~arr_id ~arr_ty ~elem_ty ~anon_func_param - ~anon_func_body:func.body) - |> Option.some + Some + (Core.bind ~loc arr (fun arr_id -> + inline_array_iter ~arr_id ~arr_ty ~elem_ty ~anon_func_param + ~anon_func_body:func.body)) | Iter_iter, [ it; f ] -> - bind_impure it (fun it -> - bind_impure f (fun f -> make_iter_iter ~it ~f ~loc)) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure f (fun f -> make_iter_iter ~it ~f ~loc))) | Iter_map, [ it; f ] -> - bind_impure it (fun it -> - bind_impure f (fun f -> make_iter_map ~it ~f ~loc)) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure f (fun f -> make_iter_map ~it ~f ~loc))) | Iter_filter, [ it; f ] -> - bind_impure it (fun it -> - bind_impure f (fun f -> make_iter_filter ~it ~f ~loc)) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure f (fun f -> make_iter_filter ~it ~f ~loc))) | Iter_from_array, arr :: [] -> - bind_impure arr (fun arr -> make_iter_from_array ~arr ~loc) |> Option.some + Some (bind_impure arr (fun arr -> make_iter_from_array ~arr ~loc)) | Iter_take, [ it; n ] -> - bind_impure it (fun it -> - bind_impure n (fun n -> make_iter_take ~it ~n ~loc)) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure n (fun n -> make_iter_take ~it ~n ~loc))) | Iter_reduce, [ it; init; f ] -> - bind_impure it (fun it -> - bind_impure init (fun init -> - bind_impure f (fun f -> make_iter_reduce ~it ~f ~init ~loc))) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure init (fun init -> + bind_impure f (fun f -> make_iter_reduce ~it ~f ~init ~loc)))) | Iter_flat_map, [ it; f ] -> - bind_impure it (fun it -> - bind_impure f (fun f -> make_iter_flat_map ~it ~f ~loc)) - |> Option.some + Some + (bind_impure it (fun it -> + bind_impure f (fun f -> make_iter_flat_map ~it ~f ~loc))) | Iter_repeat, a :: [] -> - bind_impure a (fun a -> make_iter_repeat a ~loc) |> Option.some + Some (bind_impure a (fun a -> make_iter_repeat a ~loc)) | Iter_concat, [ a; b ] -> - bind_impure a (fun a -> - bind_impure b (fun b -> make_iter_concat a b ~loc)) - |> Option.some + Some + (bind_impure a (fun a -> + bind_impure b (fun b -> make_iter_concat a b ~loc))) | Array_length, arr :: [] -> Some (make_array_length ~loc arr) | Array_unsafe_get, [ arr; index ] -> - Some (make_array_unsafe_get ~elem_ty:ty arr index) + Some (make_array_unsafe_get ~elem_ty:ty ~buf_label_name:"buf" arr index) | Array_get, [ arr; index ] -> - Core.bind arr (fun arr_id -> - let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in - Core.bind index (fun index_id -> - let index = Core.var ~ty:(Core.type_of_expr index) index_id in - let len = make_array_length arr in - let range_check = - Core.prim ~ty:Stype.bool Psequand - [ - Core.prim ~ty:Stype.bool - (Pcomparison { operand_type = I32; operator = Le }) - [ Core.const (C_int { v = 0l; repr = None }); index ]; - Core.prim ~ty:Stype.bool - (Pcomparison { operand_type = I32; operator = Lt }) - [ index; len ]; - ] - in - Core.if_ ~loc range_check - ~ifso:(make_array_unsafe_get ~elem_ty:ty arr index) - ~ifnot:(Core.prim ~ty Ppanic []))) - |> Option.some + Some + (Core.bind arr (fun arr_id -> + let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in + Core.bind index (fun index_id -> + let index = Core.var ~ty:(Core.type_of_expr index) index_id in + let len = make_array_length arr in + let range_check = + or_expr + (Core.prim ~ty:Stype.bool + (Pcomparison { operand_type = I32; operator = Lt }) + [ index; Core.const (C_int { v = 0l; repr = None }) ]) + (Core.prim ~ty:Stype.bool + (Pcomparison { operand_type = I32; operator = Ge }) + [ index; len ]) + in + Core.sequence2 + (Core.if_ ~loc range_check + ~ifso:(Core.prim ~ty:Stype.unit Ppanic [])) + (make_array_unsafe_get ~elem_ty:ty ~buf_label_name:"buf" arr + index)))) | Array_unsafe_set, [ arr; index; value ] -> Some (make_array_unsafe_set arr index value) | Array_set, [ arr; index; value ] -> - Core.bind arr (fun arr_id -> - let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in - Core.bind index (fun index_id -> - let index = Core.var ~ty:(Core.type_of_expr index) index_id in - Core.bind value (fun value_id -> - let value = Core.var ~ty:(Core.type_of_expr value) value_id in - let len = make_array_length arr in - let range_check = - Core.prim ~ty:Stype.bool Psequand - [ - Core.prim ~ty:Stype.bool - (Pcomparison { operand_type = I32; operator = Le }) - [ Core.const (C_int { v = 0l; repr = None }); index ]; - Core.prim ~ty:Stype.bool - (Pcomparison { operand_type = I32; operator = Lt }) - [ index; len ]; - ] - in - Core.if_ ~loc range_check - ~ifso:(make_array_unsafe_set arr index value) - ~ifnot:(Core.prim ~ty Ppanic [])))) - |> Option.some + Some + (Core.bind arr (fun arr_id -> + let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in + Core.bind index (fun index_id -> + let index = Core.var ~ty:(Core.type_of_expr index) index_id in + Core.bind value (fun value_id -> + let value = + Core.var ~ty:(Core.type_of_expr value) value_id + in + let len = make_array_length arr in + let range_check = + or_expr + (Core.prim ~ty:Stype.bool + (Pcomparison { operand_type = I32; operator = Lt }) + [ + index; Core.const (C_int { v = 0l; repr = None }); + ]) + (Core.prim ~ty:Stype.bool + (Pcomparison { operand_type = I32; operator = Ge }) + [ index; len ]) + in + Core.sequence2 + (Core.if_ ~loc range_check + ~ifso:(Core.prim ~ty:Stype.unit Ppanic [])) + (make_array_unsafe_set arr index value))))) + | (ArrayView_length | BytesView_length), arr :: [] -> + Some (make_arrayview_length ~loc arr) + | (ArrayView_unsafe_get | BytesView_unsafe_get), [ arr; index ] -> + Some + (Core.bind arr (fun arr_id -> + let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in + let elem_ty = ty in + let buf_label_name = + if intrinsic = ArrayView_unsafe_get then "buf" else "bytes" + in + make_array_unsafe_get ~elem_ty ~buf_label_name arr + (make_int_add (make_arrayview_start arr) index))) + | ArrayView_unsafe_set, [ arr; index; value ] -> + Some + (Core.bind arr (fun arr_id -> + let arr = Core.var ~ty:(Core.type_of_expr arr) arr_id in + make_array_unsafe_set arr + (make_int_add (make_arrayview_start arr) index) + value)) + | (ArrayView_unsafe_as_view | BytesView_unsafe_as_view), [ arr; start; end_ ] + -> + Some + (Core.bind arr (fun arr_id -> + Core.bind start (fun start_id -> + let arr = Core.var ~ty arr_id in + let start = Core.var ~ty:Stype.int start_id in + let make_label name = + ({ label_name = name; loc_ = Rloc.no_location } : Core.label) + in + let some_tag = Builtin.constr_some.cs_tag in + let some_binder = Ident.fresh "*some" in + let some_action = + Core.prim ~ty:Stype.int + (Penum_field { index = 0; tag = some_tag }) + [ + Core.var + ~ty: + (Type.make_constr_type (Core.type_of_expr end_) + ~tag:some_tag) + some_binder; + ] + in + let cases = + [ + (Builtin.constr_some.cs_tag, Some some_binder, some_action); + ] + in + let end_ : Core.expr = + Core.switch_constr + ~default:(Some (make_array_length arr)) + end_ cases + in + let elem_ty = + match ty with + | T_constr { tys = elem_ty :: []; _ } -> elem_ty + | T_constr { type_constructor = p; _ } + when Type_path.is_bytesview p -> + Stype.byte + | _ -> assert false + in + let buf_label_name = + if intrinsic = ArrayView_unsafe_as_view then "buf" + else "bytes" + in + let buf_field : Core.field_def = + { + label = make_label buf_label_name; + pos = 0; + is_mut = false; + expr = make_array_buffer arr ~elem_ty ~buf_label_name; + } + in + let start_field : Core.field_def = + { + label = make_label "start"; + pos = 1; + is_mut = false; + expr = make_int_add start (make_arrayview_start arr); + } + in + let len_field : Core.field_def = + { + label = make_label "len"; + pos = 2; + is_mut = false; + expr = make_int_sub end_ start; + } + in + let fields : Core.field_def list = + [ buf_field; start_field; len_field ] + in + Core.record ~ty fields))) | _ -> None let make_length (env : Global_env.t) (expr : Core.expr) = @@ -948,14 +1116,23 @@ let make_length (env : Global_env.t) (expr : Core.expr) = match ty with | T_constr { type_constructor = T_fixedarray; _ } -> Core.prim ~ty:Stype.int Primitive.Pfixedarray_length [ expr ] + | T_constr { type_constructor = p; _ } + when Basic_type_path.equal p Basic_type_path.Builtin.type_path_arrayview -> + Option.get + (try_apply_intrinsic ArrayView_length [ expr ] ~loc:Rloc.no_location + ~ty:Stype.int) + | T_constr { type_constructor = p; _ } when Type_path.is_bytesview p -> + Option.get + (try_apply_intrinsic BytesView_length [ expr ] ~loc:Rloc.no_location + ~ty:Stype.int) | T_constr { type_constructor = p; _ } -> ( let method_ = - Global_env.find_dot_method env ~type_name:p ~method_name:"length" - |> List.hd + List.hd + (Global_env.find_dot_method env ~type_name:p ~method_name:"length") in let fallback () = let func_id = Ident.of_qual_ident method_.id in - let func_ty, ty_args_ = + let func_ty, _, ty_args_ = Poly_type.instantiate_method_no_constraint method_ in (match func_ty with @@ -978,6 +1155,30 @@ let make_length (env : Global_env.t) (expr : Core.expr) = | None -> fallback ()) | _ -> assert false +let make_array_unsafe_as_view arr ~(ty : Stype.t) ~loc_ = + let make_label name = + ({ label_name = name; loc_ = Rloc.no_location } : Core.label) + in + let elem_ty = + match Stype.type_repr ty with + | T_constr { tys = elem_ty :: []; _ } -> elem_ty + | _ -> assert false + in + let buf = make_array_buffer arr ~elem_ty ~buf_label_name:"buf" in + let len = make_array_length arr in + let start = Core.const (C_int { v = 0l; repr = None }) in + let buf_field : Core.field_def = + { label = make_label "buf"; pos = 0; is_mut = false; expr = buf } + in + let start_field : Core.field_def = + { label = make_label "start"; pos = 1; is_mut = false; expr = start } + in + let len_field : Core.field_def = + { label = make_label "len"; pos = 2; is_mut = false; expr = len } + in + let fields : Core.field_def list = [ buf_field; start_field; len_field ] in + Core.record ~ty fields ~loc:loc_ + let make_op_as_view (env : Global_env.t) (expr : Core.expr) (drop_head_num : int) (drop_tail_num : int) = let wrap_some expr = @@ -988,97 +1189,364 @@ let make_op_as_view (env : Global_env.t) (expr : Core.expr) type_constructor = Basic_type_path.Builtin.type_path_option; tys = [ expr_ty ]; generic_ = false; - only_tag_enum_ = false; is_suberror_ = false; } in - let constr : Parsing_syntax.constructor = - { - constr_name = { name = "Some"; loc_ = Rloc.no_location }; - extra_info = No_extra_info; - loc_ = Rloc.no_location; - } - in - let tag : Basic_constr_info.constr_tag = - Constr_tag_regular - { total = 2; index = 1; name_ = "Some"; is_constant_ = false } - in - Core.constr ~ty constr tag [ expr ] + let tag : Basic_constr_info.constr_tag = Builtin.constr_some.cs_tag in + Core.constr ~ty tag [ expr ] in let ty = Stype.type_repr (Core.type_of_expr expr) in let start_index_expr = Core.const (C_int { v = Int32.of_int drop_head_num; repr = None }) in let end_index_expr = - let len_expr = make_length env expr in - let n = - Core.const (C_int { v = Int32.of_int drop_tail_num; repr = None }) - in - Core.prim ~ty:Stype.int - (Parith { operand_type = I32; operator = Sub }) - [ len_expr; n ] + lazy + (let len_expr = make_length env expr in + let n = + Core.const (C_int { v = Int32.of_int drop_tail_num; repr = None }) + in + Core.prim ~ty:Stype.int + (Parith { operand_type = I32; operator = Sub }) + [ len_expr; n ]) in - match ty with - | T_constr { type_constructor = p; _ } -> ( - let method_ = - Global_env.find_dot_method env ~type_name:p ~method_name:"op_as_view" - in - match method_ with - | method_ :: [] -> - let func_id = Ident.of_qual_ident method_.id in - let func_ty, ty_args_ = - Poly_type.instantiate_method_no_constraint method_ - in - let ret_ty = - match func_ty with - | Tarrow { params_ty = ty_self :: _; ret_ty; err_ty = _ } -> - Ctype.unify_exn ty_self ty; - ret_ty - | _ -> assert false + let args = + lazy [ expr; start_index_expr; wrap_some (Lazy.force end_index_expr) ] + in + let call_method p = + let method_ = + Global_env.find_dot_method env ~type_name:p ~method_name:"op_as_view" + in + match method_ with + | method_ :: [] -> + let func_id = Ident.of_qual_ident method_.id in + let func_ty, _, ty_args_ = + Poly_type.instantiate_method_no_constraint method_ + in + let ret_ty = + match func_ty with + | Tarrow + { params_ty = ty_self :: _; ret_ty; err_ty = _; is_async = _ } -> + Ctype.unify_exn ty_self ty; + ret_ty + | _ -> assert false + in + if + Type_path.equal p Type_path.Builtin.type_path_stringview + || Type_path.equal p Type_path.Builtin.type_path_string + then + let end_index = + if drop_tail_num = 0 then + let ty : Stype.t = + T_constr + { + type_constructor = Type_path.Builtin.type_path_option; + tys = [ Stype.int ]; + generic_ = false; + is_suberror_ = false; + } + in + Core.constr ~ty Builtin.constr_none.cs_tag [] + else + wrap_some + (Core.const + (C_int { v = Int32.of_int (-drop_tail_num); repr = None })) in Core.apply ~prim:None ~ty_args_ ~kind:(Normal { func_ty }) ~ty:ret_ty func_id - [ expr; start_index_expr; wrap_some end_index_expr ] - | _ -> assert false) + [ expr; start_index_expr; end_index ] + else + Core.apply ~prim:None ~ty_args_ + ~kind:(Normal { func_ty }) + ~ty:ret_ty func_id (Lazy.force args) + | _ -> assert false + [@@inline] + in + match ty with + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_arrayview -> + Option.get + (try_apply_intrinsic ArrayView_unsafe_as_view (Lazy.force args) + ~loc:Rloc.no_location ~ty) + | T_constr { type_constructor = p; _ } when Type_path.is_bytesview p -> + Option.get + (try_apply_intrinsic BytesView_unsafe_as_view (Lazy.force args) + ~loc:Rloc.no_location ~ty) + | T_constr { type_constructor = p; _ } -> call_method p + | T_builtin T_string -> call_method Type_path.Builtin.type_path_string | _ -> assert false +let make_string_codeunit_get (expr : Core.expr) (index : int) ~(rev : bool) = + let index_expr = Core.const (C_int { v = Int32.of_int index; repr = None }) in + let index_expr_after_rev = + if rev then + let len_expr = Core.prim ~ty:Stype.int Primitive.Pstringlength [ expr ] in + let one = Core.const (C_int { v = 1l; repr = None }) in + let psub a b = + Core.prim ~ty:Stype.int + (Parith { operand_type = I32; operator = Sub }) + [ a; b ] + in + psub (psub len_expr one) index_expr + else index_expr + in + let prim : Primitive.prim = Pgetstringitem { safe = false } in + Core.prim ~ty:Stype.char prim [ expr; index_expr_after_rev ] + let make_op_get (env : Global_env.t) (expr : Core.expr) (index : int) ~(rev : bool) = let ty = Stype.type_repr (Core.type_of_expr expr) in let index_expr = Core.const (C_int { v = Int32.of_int index; repr = None }) in + let index_expr_after_rev = + lazy + (if rev then + let len_expr = make_length env expr in + let one = Core.const (C_int { v = 1l; repr = None }) in + let psub a b = + Core.prim ~ty:Stype.int + (Parith { operand_type = I32; operator = Sub }) + [ a; b ] + in + psub (psub len_expr one) index_expr + else index_expr) + in + let args = lazy [ expr; Lazy.force index_expr_after_rev ] in + let call_method type_name method_name elem_ty args = + match[@warning "-fragile-match"] + Global_env.find_dot_method env ~type_name ~method_name + with + | method_ :: [] -> + let func_id = Ident.of_qual_ident method_.id in + let func_ty, _, ty_args_ = + Poly_type.instantiate_method_no_constraint method_ + in + (match func_ty with + | Tarrow { ret_ty; _ } -> Ctype.unify_exn ret_ty elem_ty + | _ -> assert false); + Core.apply ~prim:None ~ty_args_ + ~kind:(Normal { func_ty }) + ~ty:elem_ty func_id args + | _ -> assert false + [@@inline] + in match ty with | T_constr { type_constructor = T_fixedarray; tys = elem_ty :: [] } -> let prim : Primitive.prim = Pfixedarray_get_item { kind = (if rev then Rev_unsafe else Unsafe) } in Core.prim ~ty:elem_ty prim [ expr; index_expr ] - | T_constr { type_constructor = p; tys = elem_ty :: [] } -> ( - match[@warning "-fragile-match"] - Global_env.find_dot_method env ~type_name:p ~method_name:"op_get" - with - | method_ :: [] -> - let func_id = Ident.of_qual_ident method_.id in - let func_ty, ty_args_ = - Poly_type.instantiate_method_no_constraint method_ - in - (match func_ty with - | Tarrow { ret_ty; _ } -> Ctype.unify_exn ret_ty elem_ty - | _ -> assert false); - let index_expr = - if rev then - let len_expr = make_length env expr in - let one = Core.const (C_int { v = 1l; repr = None }) in - let psub a b = - Core.prim ~ty:Stype.int - (Parith { operand_type = I32; operator = Sub }) - [ a; b ] - in - psub (psub len_expr one) index_expr - else index_expr - in - Core.apply ~prim:None ~ty_args_ - ~kind:(Normal { func_ty }) - ~ty:elem_ty func_id [ expr; index_expr ] - | _ -> assert false) + | T_constr { type_constructor = p; tys = elem_ty :: [] } + when Basic_type_path.equal p Basic_type_path.Builtin.type_path_arrayview -> + Option.get + (try_apply_intrinsic ArrayView_unsafe_get (Lazy.force args) + ~loc:Rloc.no_location ~ty:elem_ty) + | T_constr { type_constructor = p; tys = elem_ty :: [] } + when Basic_type_path.equal p Basic_type_path.Builtin.type_path_array -> + Option.get + (try_apply_intrinsic Array_unsafe_get (Lazy.force args) + ~loc:Rloc.no_location ~ty:elem_ty) + | T_constr { type_constructor = p; _ } when Type_path.is_bytesview p -> + Option.get + (try_apply_intrinsic BytesView_unsafe_get (Lazy.force args) + ~loc:Rloc.no_location ~ty:Stype.byte) + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_stringview -> + if rev then call_method p "rev_get" Stype.char [ expr; index_expr ] + else call_method p "op_get" Stype.char (Lazy.force args) + | T_builtin T_string -> + let p = Type_path.Builtin.type_path_string in + if rev then call_method p "rev_get" Stype.char [ expr; index_expr ] + else call_method p "codepoint_at" Stype.char (Lazy.force args) + | T_constr { type_constructor = p; tys = elem_ty :: [] } -> + call_method p "op_get" elem_ty (Lazy.force args) | _ -> assert false + +let make_array_make (exprs : Core.expr list) ~loc_ ~ty = + (let make_label name = + ({ label_name = name; loc_ = Rloc.no_location } : Core.label) + in + let elem_ty = + match Stype.type_repr ty with + | T_constr { type_constructor = _; tys = elem_ty :: [] } -> elem_ty + | _ -> assert false + in + let buf_ty : Stype.t = + T_constr + { + type_constructor = Type_path.Builtin.type_path_fixedarray; + tys = + [ + T_constr + { + type_constructor = Type_path.Builtin.type_path_maybe_uninit; + tys = [ elem_ty ]; + generic_ = false; + is_suberror_ = false; + }; + ]; + generic_ = false; + is_suberror_ = false; + } + in + let fields : Core.field_def list = + [ + { + label = make_label "buf"; + pos = 0; + is_mut = true; + expr = + Core.prim ~ty:buf_ty + (Pfixedarray_make { kind = EverySingleElem }) + exprs; + }; + { + label = make_label "len"; + pos = 1; + is_mut = true; + expr = + Core.const + (C_int { v = Int32.of_int (List.length exprs); repr = None }); + }; + ] + in + Core.record ~ty ~loc:loc_ fields + : Core.expr) + +let all_fields_immutable (global_env : Global_env.t) (tp : Type_path.t) + ~(allow_enum : bool) = + match tp with + | Tuple _ -> true + | _ when Type_path.equal tp Type_path.Builtin.type_path_arrayview -> true + | _ -> ( + match Global_env.find_all_type_by_path global_env tp with + | Some t -> ( + match t.ty_desc with + | Record_type { fields; _ } -> + Lst.for_all fields (fun { mut; _ } -> not mut) + | Variant_type cs when allow_enum -> + Basic_lst.for_all cs (fun c -> + Fn_arity.is_immutable_constr_arity c.cs_arity_) + | _ -> false) + | None -> false) + +let arrayview_ty_params : Tvar_env.t = Tvar_env.tvar_env_1 + +let arrayview_ty : Stype.t = + Stype.T_constr + { + type_constructor = Type_path.Builtin.type_path_arrayview; + tys = Tvar_env.get_types arrayview_ty_params; + generic_ = true; + is_suberror_ = false; + } + +let arrayview_all_labels = [ "buf"; "start"; "len" ] + +let field_buf : Typedecl_info.field = + { + field_name = "buf"; + pos = 0; + ty_field = + Stype.T_constr + { + type_constructor = Type_path.Builtin.type_path_fixedarray; + tys = [ Stype.param0 ]; + generic_ = true; + is_suberror_ = false; + }; + ty_record = arrayview_ty; + mut = false; + vis = Read_write; + all_labels = arrayview_all_labels; + ty_params_ = arrayview_ty_params; + label_loc_ = Loc.no_location; + loc_ = Loc.no_location; + } + +let field_start : Typedecl_info.field = + { + field_name = "start"; + pos = 1; + ty_field = Stype.int; + ty_record = arrayview_ty; + mut = false; + vis = Read_write; + all_labels = arrayview_all_labels; + ty_params_ = arrayview_ty_params; + label_loc_ = Loc.no_location; + loc_ = Loc.no_location; + } + +let field_len : Typedecl_info.field = + { + field_name = "len"; + pos = 2; + ty_field = Stype.int; + ty_record = arrayview_ty; + mut = false; + vis = Read_write; + all_labels = arrayview_all_labels; + ty_params_ = arrayview_ty_params; + label_loc_ = Loc.no_location; + loc_ = Loc.no_location; + } + +let arrayview_fields = [ field_buf; field_start; field_len ] + +let get_fields_exn (global_env : Global_env.t) (tp : Type_path.t) = + match tp with + | Tuple _ -> [] + | _ when Type_path.equal tp Type_path.Builtin.type_path_arrayview -> + arrayview_fields + | _ -> ( + match Global_env.find_all_type_by_path global_env tp with + | Some t -> ( + match t.ty_desc with + | Record_type { fields; _ } -> fields + | _ -> assert false) + | None -> assert false) + +let make_length_test (global_env : Global_env.t) (expr : Core.expr) (num : int) + ~(kind : [ `Geq | `Eq ]) ~ifso ~ifnot = + let expr_ty = Stype.type_repr (Core.type_of_expr expr) in + let call_method p = + let num_pats_expr = + Core.const (C_int { v = Int32.of_int num; repr = None }) + in + let test_expr = + let method_ = + List.hd + (match kind with + | `Geq -> + Global_env.find_dot_method global_env ~type_name:p + ~method_name:"length_ge" + | `Eq -> + Global_env.find_dot_method global_env ~type_name:p + ~method_name:"length_eq") + in + Core.apply + ~kind:(Normal { func_ty = method_.typ }) + ~ty:Stype.bool + (Ident.of_qual_ident method_.id) + [ expr; num_pats_expr ] + in + Core.if_ test_expr ~ifso ~ifnot + [@@inline] + in + match expr_ty with + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_stringview -> + call_method p + | T_builtin T_string -> call_method Type_path.Builtin.type_path_string + | _ -> + let arr_len_expr = make_length global_env expr in + let num_pats_expr = + Core.const (C_int { v = Int32.of_int num; repr = None }) + in + let test_expr = + let prim = + if kind = `Geq then Primitive.ge_int else Primitive.equal_int + in + Core.prim prim [ arr_len_expr; num_pats_expr ] ~ty:Stype.bool + in + Core.if_ test_expr ~ifso ~ifnot diff --git a/src/ctype.ml b/src/ctype.ml index fbc2828..796b29d 100644 --- a/src/ctype.ml +++ b/src/ctype.ml @@ -22,49 +22,52 @@ exception Unify let type_repr = Stype.type_repr let check_occur = Type.check_occur -let rec unify (ty1 : typ) (ty2 : typ) : unit = - let ty1' = type_repr ty1 and ty2' = type_repr ty2 in - if Basic_prelude.phys_not_equal ty1' ty2' then ( - (match (ty1', ty2') with - | Tvar link1, _ -> ( - match ty2' with - | Tvar link2 -> ( - match !link1 with - | Tnolink Tvar_error -> link2 := Tlink ty1' - | _ -> link1 := Tlink ty2') - | _ -> - if check_occur ty1' ty2' then raise_notrace Unify - else link1 := Tlink ty2') - | _, Tvar link -> - if check_occur ty2' ty1' then raise_notrace Unify - else link := Tlink ty1' - | T_blackhole, _ | _, T_blackhole -> () - | ( Tarrow { params_ty = t1x; ret_ty = t1y; err_ty = t1z }, - Tarrow { params_ty = t2x; ret_ty = t2y; err_ty = t2z } ) -> ( - unify_list t1x t2x; - unify t1y t2y; - match (t1z, t2z) with - | None, None -> () - | Some t1z, Some t2z -> unify t1z t2z - | _ -> raise_notrace Unify) - | ( T_constr { type_constructor = c1; tys = tys1 }, - T_constr { type_constructor = c2; tys = tys2 } ) -> - if Type_path.equal c1 c2 then unify_list tys1 tys2 - else raise_notrace Unify - | Tparam { index = i1 }, Tparam { index = i2 } -> - if i1 <> i2 then raise_notrace Unify - | T_trait t1, T_trait t2 -> - if not (Type_path.equal t1 t2) then raise_notrace Unify - | T_builtin a, T_builtin b -> - if not (Stype.equal_builtin a b) then raise_notrace Unify - | Tarrow _, (T_constr _ | Tparam _ | T_trait _ | T_builtin _) - | T_constr _, (Tarrow _ | Tparam _ | T_trait _ | T_builtin _) - | Tparam _, (T_constr _ | Tarrow _ | T_trait _ | T_builtin _) - | T_trait _, (T_constr _ | Tarrow _ | Tparam _ | T_builtin _) - | T_builtin _, (T_constr _ | Tarrow _ | Tparam _ | T_trait _) -> - raise_notrace Unify); - type_repr ty1 |> ignore; - type_repr ty2 |> ignore) +let rec unify (ty1 : typ) (ty2 : typ) = + (let ty1' = type_repr ty1 and ty2' = type_repr ty2 in + if Basic_prelude.phys_not_equal ty1' ty2' then ( + (match (ty1', ty2') with + | Tvar link1, _ -> ( + match ty2' with + | Tvar link2 -> ( + match !link1 with + | Tnolink Tvar_error -> link2 := Tlink ty1' + | _ -> link1 := Tlink ty2') + | _ -> + if check_occur ty1' ty2' then raise_notrace Unify + else link1 := Tlink ty2') + | _, Tvar link -> + if check_occur ty2' ty1' then raise_notrace Unify + else link := Tlink ty1' + | T_blackhole, _ | _, T_blackhole -> () + | ( Tarrow { params_ty = t1x; ret_ty = t1y; err_ty = t1z; is_async = a1 }, + Tarrow { params_ty = t2x; ret_ty = t2y; err_ty = t2z; is_async = a2 } ) + -> ( + if a1 <> a2 then raise_notrace Unify; + unify_list t1x t2x; + unify t1y t2y; + match (t1z, t2z) with + | None, None -> () + | Some t1z, Some t2z -> unify t1z t2z + | _ -> raise_notrace Unify) + | ( T_constr { type_constructor = c1; tys = tys1 }, + T_constr { type_constructor = c2; tys = tys2 } ) -> + if Type_path.equal c1 c2 then unify_list tys1 tys2 + else raise_notrace Unify + | Tparam { index = i1 }, Tparam { index = i2 } -> + if i1 <> i2 then raise_notrace Unify + | T_trait t1, T_trait t2 -> + if not (Type_path.equal t1 t2) then raise_notrace Unify + | T_builtin a, T_builtin b -> + if not (Stype.equal_builtin a b) then raise_notrace Unify + | Tarrow _, (T_constr _ | Tparam _ | T_trait _ | T_builtin _) + | T_constr _, (Tarrow _ | Tparam _ | T_trait _ | T_builtin _) + | Tparam _, (T_constr _ | Tarrow _ | T_trait _ | T_builtin _) + | T_trait _, (T_constr _ | Tarrow _ | Tparam _ | T_builtin _) + | T_builtin _, (T_constr _ | Tarrow _ | Tparam _ | T_trait _) -> + raise_notrace Unify); + ignore (type_repr ty1); + ignore (type_repr ty2)) + : unit) and unify_list t1s t2s = match (t1s, t2s) with @@ -74,39 +77,48 @@ and unify_list t1s t2s = unify_list t1s t2s | [], _ :: _ | _ :: _, [] -> raise_notrace Unify -let unify_expr ~expect_ty ~actual_ty loc : Local_diagnostics.error_option = - try - unify expect_ty actual_ty; - None - with Unify -> - let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in - Some (Errors.expr_unify ~expected ~actual ~loc) +let unify_expr ~expect_ty ~actual_ty loc = + (try + unify expect_ty actual_ty; + None + with Unify -> + let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in + Some (Errors.expr_unify ~expected ~actual ~loc) + : Local_diagnostics.error option) -let unify_pat ~expect_ty ~actual_ty loc : Local_diagnostics.error_option = - try - unify expect_ty actual_ty; - None +let unify_expr_and_store_error ~expect_ty ~actual_ty ~diagnostics loc = + try unify expect_ty actual_ty with Unify -> let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in - Some (Errors.pat_unify ~expected ~actual ~loc) + Local_diagnostics.add_error diagnostics + (Errors.expr_unify ~expected ~actual ~loc) -let unify_param name ~expect_ty ~actual_ty loc : Local_diagnostics.error_option - = - try - unify expect_ty actual_ty; - None - with Unify -> - let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in - Some (Errors.param_unify ~name ~expected ~actual ~loc) +let unify_pat ~expect_ty ~actual_ty loc = + (try + unify expect_ty actual_ty; + None + with Unify -> + let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in + Some (Errors.pat_unify ~expected ~actual ~loc) + : Local_diagnostics.error option) -let unify_constr name ~expect_ty ~actual_ty loc : Local_diagnostics.error_option - = - try - unify expect_ty actual_ty; - None - with Unify -> - let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in - Some (Errors.constr_unify ~name ~expected ~actual ~loc) +let unify_param name ~expect_ty ~actual_ty loc = + (try + unify expect_ty actual_ty; + None + with Unify -> + let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in + Some (Errors.param_unify ~name ~expected ~actual ~loc) + : Local_diagnostics.error option) + +let unify_constr name ~expect_ty ~actual_ty loc = + (try + unify expect_ty actual_ty; + None + with Unify -> + let expected, actual = Printer.type_pair_to_string expect_ty actual_ty in + Some (Errors.constr_unify ~name ~expected ~actual ~loc) + : Local_diagnostics.error option) let unify_exn = unify diff --git a/src/dead_code.ml b/src/dead_code.ml index ccb1abc..1cc5fb2 100644 --- a/src/dead_code.ml +++ b/src/dead_code.ml @@ -53,32 +53,34 @@ include struct let _ = sexp_of_constr_arg_kind let equal_constr_arg_kind = - (fun a__005_ b__006_ -> - if Stdlib.( == ) a__005_ b__006_ then true - else - match (a__005_, b__006_) with - | Positional _a__007_, Positional _b__008_ -> - Stdlib.( = ) (_a__007_ : int) _b__008_ - | Positional _, _ -> false - | _, Positional _ -> false - | Labelled _a__009_, Labelled _b__010_ -> - Stdlib.( = ) (_a__009_ : string) _b__010_ + (fun a__005_ -> + fun b__006_ -> + if Stdlib.( == ) a__005_ b__006_ then true + else + match (a__005_, b__006_) with + | Positional _a__007_, Positional _b__008_ -> + Stdlib.( = ) (_a__007_ : int) _b__008_ + | Positional _, _ -> false + | _, Positional _ -> false + | Labelled _a__009_, Labelled _b__010_ -> + Stdlib.( = ) (_a__009_ : string) _b__010_ : constr_arg_kind -> constr_arg_kind -> bool) let _ = equal_constr_arg_kind let (hash_fold_constr_arg_kind : Ppx_base.state -> constr_arg_kind -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Positional _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = hsv in - Ppx_base.hash_fold_int hsv _a0 - | Labelled _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = hsv in - Ppx_base.hash_fold_string hsv _a0 + (fun hsv -> + fun arg -> + match arg with + | Positional _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + Ppx_base.hash_fold_int hsv _a0 + | Labelled _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + Ppx_base.hash_fold_string hsv _a0 : Ppx_base.state -> constr_arg_kind -> Ppx_base.state) let _ = hash_fold_constr_arg_kind @@ -201,113 +203,115 @@ include struct let _ = sexp_of_entity let equal_entity = - (fun a__048_ b__049_ -> - if Stdlib.( == ) a__048_ b__049_ then true - else - match (a__048_, b__049_) with - | Struct_field _a__050_, Struct_field _b__051_ -> - Stdlib.( && ) - (Type_path.equal _a__050_.ty _b__051_.ty) - (Stdlib.( = ) (_a__050_.name : string) _b__051_.name) - | Struct_field _, _ -> false - | _, Struct_field _ -> false - | Construct_struct _a__052_, Construct_struct _b__053_ -> - Type_path.equal _a__052_.ty _b__053_.ty - | Construct_struct _, _ -> false - | _, Construct_struct _ -> false - | Enum_constr _a__054_, Enum_constr _b__055_ -> - Stdlib.( && ) - (Type_path.equal _a__054_.ty _b__055_.ty) - (Stdlib.( = ) (_a__054_.name : string) _b__055_.name) - | Enum_constr _, _ -> false - | _, Enum_constr _ -> false - | Var _a__056_, Var _b__057_ -> Ident.equal _a__056_.id _b__057_.id - | Var _, _ -> false - | _, Var _ -> false - | Direct_pkg_use _a__058_, Direct_pkg_use _b__059_ -> - Stdlib.( = ) (_a__058_ : string) _b__059_ - | Direct_pkg_use _, _ -> false - | _, Direct_pkg_use _ -> false - | Trait_method _a__060_, Trait_method _b__061_ -> - Stdlib.( && ) - (Type_path.equal _a__060_.trait _b__061_.trait) - (Stdlib.( = ) - (_a__060_.method_name : string) - _b__061_.method_name) - | Trait_method _, _ -> false - | _, Trait_method _ -> false - | Constr_argument _a__062_, Constr_argument _b__063_ -> - Stdlib.( && ) - (Type_path.equal _a__062_.ty _b__063_.ty) - (Stdlib.( && ) - (Constr_info.equal_constr_tag _a__062_.tag _b__063_.tag) - (equal_constr_arg_kind _a__062_.kind _b__063_.kind)) - | Constr_argument _, _ -> false - | _, Constr_argument _ -> false - | Fn_optional_arg _a__064_, Fn_optional_arg _b__065_ -> - Stdlib.( && ) - (Ident.equal _a__064_.fn _b__065_.fn) - (Stdlib.( = ) (_a__064_.label : string) _b__065_.label) + (fun a__048_ -> + fun b__049_ -> + if Stdlib.( == ) a__048_ b__049_ then true + else + match (a__048_, b__049_) with + | Struct_field _a__050_, Struct_field _b__051_ -> + Stdlib.( && ) + (Type_path.equal _a__050_.ty _b__051_.ty) + (Stdlib.( = ) (_a__050_.name : string) _b__051_.name) + | Struct_field _, _ -> false + | _, Struct_field _ -> false + | Construct_struct _a__052_, Construct_struct _b__053_ -> + Type_path.equal _a__052_.ty _b__053_.ty + | Construct_struct _, _ -> false + | _, Construct_struct _ -> false + | Enum_constr _a__054_, Enum_constr _b__055_ -> + Stdlib.( && ) + (Type_path.equal _a__054_.ty _b__055_.ty) + (Stdlib.( = ) (_a__054_.name : string) _b__055_.name) + | Enum_constr _, _ -> false + | _, Enum_constr _ -> false + | Var _a__056_, Var _b__057_ -> Ident.equal _a__056_.id _b__057_.id + | Var _, _ -> false + | _, Var _ -> false + | Direct_pkg_use _a__058_, Direct_pkg_use _b__059_ -> + Stdlib.( = ) (_a__058_ : string) _b__059_ + | Direct_pkg_use _, _ -> false + | _, Direct_pkg_use _ -> false + | Trait_method _a__060_, Trait_method _b__061_ -> + Stdlib.( && ) + (Type_path.equal _a__060_.trait _b__061_.trait) + (Stdlib.( = ) + (_a__060_.method_name : string) + _b__061_.method_name) + | Trait_method _, _ -> false + | _, Trait_method _ -> false + | Constr_argument _a__062_, Constr_argument _b__063_ -> + Stdlib.( && ) + (Type_path.equal _a__062_.ty _b__063_.ty) + (Stdlib.( && ) + (Constr_info.equal_constr_tag _a__062_.tag _b__063_.tag) + (equal_constr_arg_kind _a__062_.kind _b__063_.kind)) + | Constr_argument _, _ -> false + | _, Constr_argument _ -> false + | Fn_optional_arg _a__064_, Fn_optional_arg _b__065_ -> + Stdlib.( && ) + (Ident.equal _a__064_.fn _b__065_.fn) + (Stdlib.( = ) (_a__064_.label : string) _b__065_.label) : entity -> entity -> bool) let _ = equal_entity let (hash_fold_entity : Ppx_base.state -> entity -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Struct_field _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv _ir.ty - in - Ppx_base.hash_fold_string hsv _ir.name - | Construct_struct _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = hsv in - Type_path.hash_fold_t hsv _ir.ty - | Enum_constr _ir -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv _ir.ty - in - Ppx_base.hash_fold_string hsv _ir.name - | Var _ir -> - let hsv = Ppx_base.hash_fold_int hsv 3 in - let hsv = - let hsv = hsv in - Ident.hash_fold_t hsv _ir.id - in - hsv - | Direct_pkg_use _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 4 in - let hsv = hsv in - Ppx_base.hash_fold_string hsv _a0 - | Trait_method _ir -> - let hsv = Ppx_base.hash_fold_int hsv 5 in - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv _ir.trait - in - Ppx_base.hash_fold_string hsv _ir.method_name - | Constr_argument _ir -> - let hsv = Ppx_base.hash_fold_int hsv 6 in - let hsv = - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv _ir.ty - in - Constr_info.hash_fold_constr_tag hsv _ir.tag - in - hash_fold_constr_arg_kind hsv _ir.kind - | Fn_optional_arg _ir -> - let hsv = Ppx_base.hash_fold_int hsv 7 in - let hsv = - let hsv = hsv in - Ident.hash_fold_t hsv _ir.fn - in - Ppx_base.hash_fold_string hsv _ir.label + (fun hsv -> + fun arg -> + match arg with + | Struct_field _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv _ir.ty + in + Ppx_base.hash_fold_string hsv _ir.name + | Construct_struct _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + Type_path.hash_fold_t hsv _ir.ty + | Enum_constr _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv _ir.ty + in + Ppx_base.hash_fold_string hsv _ir.name + | Var _ir -> + let hsv = Ppx_base.hash_fold_int hsv 3 in + let hsv = + let hsv = hsv in + Ident.hash_fold_t hsv _ir.id + in + hsv + | Direct_pkg_use _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 4 in + let hsv = hsv in + Ppx_base.hash_fold_string hsv _a0 + | Trait_method _ir -> + let hsv = Ppx_base.hash_fold_int hsv 5 in + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv _ir.trait + in + Ppx_base.hash_fold_string hsv _ir.method_name + | Constr_argument _ir -> + let hsv = Ppx_base.hash_fold_int hsv 6 in + let hsv = + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv _ir.ty + in + Constr_info.hash_fold_constr_tag hsv _ir.tag + in + hash_fold_constr_arg_kind hsv _ir.kind + | Fn_optional_arg _ir -> + let hsv = Ppx_base.hash_fold_int hsv 7 in + let hsv = + let hsv = hsv in + Ident.hash_fold_t hsv _ir.fn + in + Ppx_base.hash_fold_string hsv _ir.label : Ppx_base.state -> entity -> Ppx_base.state) let _ = hash_fold_entity @@ -367,7 +371,10 @@ let join_type_usage u1 u2 = type entity_info = { is_mut : bool; mutable usage : entity_usage; loc : Loc.t } type type_info = { - decl : [ `Type of Typedtree.type_decl | `Trait of Typedtree.trait_decl ]; + decl : + [ `Type of Typedtree.type_decl + | `Trait of Typedtree.trait_decl + | `Trait_alias of Typedtree.trait_alias_decl ]; mutable usage : type_usage; loc : Loc.t; } @@ -381,17 +388,18 @@ type ctx = { let register_entity ctx entity ~is_mut ~loc = H.add ctx.entities entity { is_mut; loc; usage = Unused } +let name_should_be_ignored name = + String.length name = 0 || match name.[0] with '_' | '*' -> true | _ -> false + let register_binder ctx (binder : Typedtree.binder) ~base_loc ~is_mut ~kind = - match (Ident.base_name binder.binder_id).[0] with - | '_' | '*' -> () - | _ -> - let loc = Rloc.to_loc ~base:base_loc binder.loc_ in - H.add ctx.entities - (Var { id = binder.binder_id; kind }) - { is_mut; loc; usage = Unused } + if not (name_should_be_ignored (Ident.base_name binder.binder_id)) then + let loc = Rloc.to_loc ~base:base_loc binder.loc_ in + H.add ctx.entities + (Var { id = binder.binder_id; kind }) + { is_mut; loc; usage = Unused } let register_pat_binders ctx (pat_binders : Typedtree.pat_binders) ~base_loc = - Lst.iter pat_binders (fun pb -> + Lst.iter pat_binders ~f:(fun pb -> register_binder ctx pb.binder ~base_loc ~is_mut:false ~kind:Local) let update_usage ctx entity usage = @@ -441,14 +449,14 @@ let rec process_typ ~in_pub_sig ctx (typ : Typedtree.typ) = match typ with | Tany _ -> () | Tarrow { params; return; err_ty; ty = _ } -> ( - Lst.iter params go; + Lst.iter params ~f:go; go return; match err_ty with | Error_typ { ty } -> go ty | Default_error_typ _ | No_error_typ -> ()) - | T_tuple { params; ty = _ } -> Lst.iter params go + | T_tuple { params; ty = _ } -> Lst.iter params ~f:go | Tname { constr; params; ty; is_alias_ } -> ( - Lst.iter params go; + Lst.iter params ~f:go; if is_alias_ then process_alias ctx constr.lid else match Stype.type_repr ty with @@ -456,6 +464,14 @@ let rec process_typ ~in_pub_sig ctx (typ : Typedtree.typ) = let usage = if in_pub_sig then Used_in_pub else Used_in_priv in update_type_usage ctx ty usage | T_builtin _ | Tarrow _ | Tparam _ | Tvar _ | T_blackhole -> ()) + | Tobject { constr; ty; is_alias_ } -> ( + if is_alias_ then process_alias ctx constr.lid + else + match Stype.type_repr ty with + | T_trait ty -> + let usage = if in_pub_sig then Used_in_pub else Used_in_priv in + update_type_usage ctx ty usage + | _ -> ()) let process_typ_opt ctx ~in_pub_sig konstraint = match konstraint with @@ -477,25 +493,27 @@ let rec process_pat ctx (pat : Typedtree.pat) = | Tpat_var _ | Tpat_any _ -> () | Tpat_array { pats; ty = _ } -> ( match pats with - | Closed pats -> Lst.iter pats go + | Closed pats -> Lst.iter pats ~f:go | Open (pats_l, pats_r, _) -> - Lst.iter pats_l go; - Lst.iter pats_r go) + Lst.iter pats_l ~f:go; + Lst.iter pats_r ~f:go) | Tpat_constant { name_ = None; _ } -> () | Tpat_constant { name_ = Some { var_id }; _ } -> update_var_usage ctx var_id Only_read | Tpat_range { lhs; rhs; inclusive = _; ty = _ } -> go lhs; go rhs - | Tpat_constr { constr; args; ty; tag; used_error_subtyping = _ } -> ( + | Tpat_constr { type_name; constr; args; ty; tag; used_error_subtyping = _ } + -> ( + (match type_name with + | Some type_name -> process_type_name ~in_pub_sig:false ctx type_name + | _ -> ()); match Stype.type_repr ty with | T_constr { type_constructor = ty; _ } -> update_type_usage ctx ty Used_in_priv; - update_usage ctx - (Enum_constr { ty; name = constr.constr_name.name }) - Only_read; + update_usage ctx (Enum_constr { ty; name = constr.name }) Only_read; let last_positional_index = ref (-1) in - Lst.iter args (fun (Constr_pat_arg { pat; kind; pos = _ }) -> + Lst.iter args ~f:(fun (Constr_pat_arg { pat; kind; pos = _ }) -> go pat; let kind : constr_arg_kind = match kind with @@ -513,15 +531,15 @@ let rec process_pat ctx (pat : Typedtree.pat) = | _ -> update_usage ctx (Constr_argument { ty; tag; kind }) Only_read) | _ -> - Lst.iter args (fun (Constr_pat_arg { pat; kind = _; pos = _ }) -> + Lst.iter args ~f:(fun (Constr_pat_arg { pat; kind = _; pos = _ }) -> go pat)) | Tpat_or { pat1; pat2; ty = _ } -> go pat1; go pat2 - | Tpat_tuple { pats; ty = _ } -> Lst.iter pats go + | Tpat_tuple { pats; ty = _ } -> Lst.iter pats ~f:go | Tpat_record { fields; is_closed = _; ty } -> let ty = Stype.type_repr ty in - Lst.iter fields (fun (Field_pat { label; pat; is_pun = _; pos = _ }) -> + Lst.iter fields ~f:(fun (Field_pat { label; pat; is_pun = _; pos = _ }) -> go pat; match ty with | T_constr { type_constructor = ty; _ } -> @@ -535,14 +553,14 @@ let rec process_pat ctx (pat : Typedtree.pat) = go pat | Tpat_map { elems; op_get_info_ = op_get_id, _, _; ty = _ } -> update_var_usage ctx op_get_id Only_read; - Lst.iter elems (fun (_, pat) -> go pat) + Lst.iter elems ~f:(fun (_, pat) -> go pat) let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = let go expr = process_expr ~base_loc ctx expr [@@inline] in match expr with | Texpr_apply { func; args; ty = _ } -> ( go func; - Lst.iter args (fun arg -> go arg.arg_value); + Lst.iter args ~f:(fun arg -> go arg.arg_value); match func with | Texpr_method { meth = { var_id = fn }; arity_ = Some arity; _ } | Texpr_ident { id = { var_id = fn }; arity_ = Some arity; _ } @@ -579,11 +597,14 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = process_type_name ctx ~in_pub_sig:false type_name; update_var_usage ctx meth.var_id Only_read | Texpr_unresolved_method { trait_name; method_name; self_type = _; ty = _ } - -> - update_type_usage ctx trait_name.name Used_in_priv; - update_usage ctx - (Trait_method { trait = trait_name.name; method_name }) - Only_read + -> ( + process_type_name ~in_pub_sig:false ctx trait_name; + match trait_name with + | Tname_path { name; _ } | Tname_alias { name; _ } -> + update_usage ctx + (Trait_method { trait = name; method_name }) + Only_read + | Tname_tvar _ -> ()) | Texpr_ident { id; kind = _; ty = _ } -> ( update_var_usage ctx id.var_id Only_read; match id.var_id with @@ -593,11 +614,14 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = | Texpr_as { expr; trait; ty = _; is_implicit = _ } -> process_type_name ctx ~in_pub_sig:false trait; go expr - | Texpr_array { exprs; ty = _; is_fixed_array = _ } -> Lst.iter exprs go + | Texpr_array { exprs; ty = _; is_fixed_array = _ } -> Lst.iter exprs ~f:go | Texpr_constant { name_ = None; _ } -> () | Texpr_constant { name_ = Some var; _ } -> update_var_usage ctx var.var_id Only_read - | Texpr_constr { constr; tag = _; ty } -> ( + | Texpr_constr { type_name; constr; tag = _; ty } -> ( + (match type_name with + | Some type_name -> process_type_name ~in_pub_sig:false ctx type_name + | _ -> ()); let constr_opt = match Stype.type_repr ty with | T_constr { type_constructor; _ } -> Some type_constructor @@ -611,25 +635,23 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = | None -> () | Some ty -> update_type_usage ctx ty Used_in_priv; - update_usage ctx - (Enum_constr { ty; name = constr.constr_name.name }) - Only_write) - | Texpr_while { loop_cond; loop_body; while_else; ty = _ } -> + update_usage ctx (Enum_constr { ty; name = constr.name }) Only_write) + | Texpr_while { loop_cond; loop_body; while_else; ty = _; label = _ } -> ( go loop_cond; go loop_body; - Option.iter go while_else + match while_else with Some while_else -> go while_else | _ -> ()) | Texpr_function { func; ty = _ } -> process_fn ctx ~base_loc ~in_pub_sig:false func - | Texpr_if { cond; ifso; ifnot; ty = _ } -> + | Texpr_if { cond; ifso; ifnot; ty = _ } -> ( go cond; go ifso; - Option.iter go ifnot + match ifnot with Some ifnot -> go ifnot | _ -> ()) | Texpr_letfn { binder; fn; body; ty = _; is_rec = _ } -> process_fn ctx ~base_loc ~in_pub_sig:false fn; register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local_func; go body | Texpr_letrec { bindings; body; ty = _ } -> - Lst.iter bindings (fun (binder, _) -> + Lst.iter bindings ~f:(fun (binder, _) -> register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local_func); go body; let filter_used fns = @@ -648,15 +670,15 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = match used with | [] -> let excluding = - Lst.fold_left unused ctx.excluding - (fun excluding ((binder : Typedtree.binder), _) -> - Ident.Set.add excluding binder.binder_id) + Lst.fold_left unused ctx.excluding (fun excluding -> + fun ((binder : Typedtree.binder), _) -> + Ident.Set.add excluding binder.binder_id) in let ctx = { ctx with excluding } in - Lst.iter unused (fun (_, fn) -> + Lst.iter unused ~f:(fun (_, fn) -> process_fn ctx ~base_loc ~in_pub_sig:false fn) | used -> - Lst.iter used (fun (_, fn) -> + Lst.iter used ~f:(fun (_, fn) -> process_fn ctx ~base_loc ~in_pub_sig:false fn); let used, unused = filter_used unused in process_used ~used ~unused @@ -668,10 +690,10 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = go rhs; register_pat_binders ctx pat_binders ~base_loc; go body - | Texpr_sequence { expr1; expr2; ty = _ } -> - go expr1; - go expr2 - | Texpr_tuple { exprs; ty = _ } -> Lst.iter exprs go + | Texpr_sequence { exprs; last_expr; ty = _ } -> + Lst.iter exprs ~f:go; + go last_expr + | Texpr_tuple { exprs; ty = _ } -> Lst.iter exprs ~f:go | Texpr_record { type_name; fields; ty } -> (match type_name with | None -> () @@ -681,19 +703,22 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = update_type_usage ctx ty Used_in_priv; update_usage ctx (Construct_struct { ty }) Only_write | _ -> ()); - Lst.iter fields (fun (Field_def { expr; _ }) -> go expr) + Lst.iter fields ~f:(fun (Field_def { expr; _ }) -> go expr) | Texpr_record_update { type_name; record; fields; all_fields = _; ty = _ } -> (match type_name with | None -> () | Some type_name -> process_type_name ctx ~in_pub_sig:false type_name); go record; - Lst.iter fields (fun (Field_def { expr; _ }) -> go expr) + Lst.iter fields ~f:(fun (Field_def { expr; _ }) -> go expr) | Texpr_field { record; accessor = Index _; pos = _; ty = _ } -> go record | Texpr_field { record; accessor = Newtype; pos = _; ty = _ } -> ( go record; match Stype.type_repr (Typedtree_util.type_of_typed_expr record) with | T_constr { type_constructor = Toplevel { pkg = _; id } as ty; _ } -> update_usage ctx (Enum_constr { ty; name = id }) Only_read + | T_constr + { type_constructor = T_local { toplevel_id = _; name } as ty; _ } -> + update_usage ctx (Enum_constr { ty; name }) Only_read | _ -> ()) | Texpr_field { record; accessor = Label label; pos = _; ty = _ } -> ( go record; @@ -710,7 +735,7 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = | Texpr_mutate { record; label; field; augmented_by; pos = _; ty = _ } -> ( go record; go field; - Option.iter go augmented_by; + (match augmented_by with Some augmented_by -> go augmented_by | _ -> ()); match Stype.type_repr (Typedtree_util.type_of_typed_expr record) with | T_constr { type_constructor = ty; _ } -> let entity = @@ -724,6 +749,10 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = | Texpr_match { expr; cases; ty = _ } -> go expr; process_match_cases ctx ~base_loc cases + | Texpr_is { expr; pat; pat_binders } -> + go expr; + process_pat ctx pat; + register_pat_binders ctx pat_binders ~base_loc | Texpr_letmut { binder; konstraint; expr; body; ty = _ } -> go expr; process_typ_opt ctx ~in_pub_sig:false konstraint; @@ -731,33 +760,37 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = go body | Texpr_assign { var; expr; augmented_by; ty = _ } -> update_var_usage ctx var.var_id Only_write; - Option.iter go augmented_by; + (match augmented_by with Some augmented_by -> go augmented_by | _ -> ()); go expr | Texpr_hole _ | Texpr_unit _ -> () - | Texpr_break { arg; ty = _ } -> Option.iter go arg - | Texpr_continue { args; ty = _ } -> Lst.iter args go - | Texpr_loop { params; body; args; ty = _ } -> - Lst.iter args go; + | Texpr_break { arg; ty = _; label = _ } -> ( + match arg with Some arg -> go arg | _ -> ()) + | Texpr_continue { args; ty = _; label = _ } -> Lst.iter args ~f:go + | Texpr_loop { params; body; args; ty = _; label = _ } -> + Lst.iter args ~f:go; process_params ctx ~base_loc ~in_pub_sig:false params; go body - | Texpr_for { binders; condition; steps; body; for_else; ty = _ } -> - Lst.iter binders (fun (binder, init) -> + | Texpr_for { binders; condition; steps; body; for_else; ty = _; label = _ } + -> ( + Lst.iter binders ~f:(fun (binder, init) -> register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local; go init); - Option.iter go condition; - Lst.iter steps (fun (_, update) -> go update); + (match condition with Some condition -> go condition | _ -> ()); + Lst.iter steps ~f:(fun (_, update) -> go update); go body; - Option.iter go for_else - | Texpr_foreach { binders; expr; body; else_block; elem_tys = _; ty = _ } -> + match for_else with Some for_else -> go for_else | _ -> ()) + | Texpr_foreach + { binders; expr; body; else_block; elem_tys = _; ty = _; label = _ } -> ( go expr; - Lst.iter binders (fun binder_opt -> + Lst.iter binders ~f:(fun binder_opt -> match binder_opt with | None -> () | Some binder -> register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local); go body; - Option.iter go else_block - | Texpr_return { return_value; ty = _ } -> Option.iter go return_value + match else_block with Some else_block -> go else_block | _ -> ()) + | Texpr_return { return_value; ty = _ } -> ( + match return_value with Some return_value -> go return_value | _ -> ()) | Texpr_raise { error_value; ty = _ } -> go error_value | Texpr_try { body; catch; try_else; catch_all = _; ty = _; err_ty = _ } -> ( go body; @@ -774,10 +807,10 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = match rhs with | Pipe_partial_apply { func; args } -> go func; - Lst.iter args (fun arg -> go arg.arg_value) + Lst.iter args ~f:(fun arg -> go arg.arg_value) | Pipe_invalid { expr; ty = _ } -> go expr) | Texpr_interp { elems; ty = _ } -> - Lst.iter elems (fun elem -> + Lst.iter elems ~f:(fun elem -> match elem with | Interp_lit _ -> () | Interp_expr { expr; to_string } -> @@ -785,7 +818,7 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = go to_string) | Texpr_guard { cond; otherwise; body; ty = _ } -> go cond; - Option.iter go otherwise; + (match otherwise with Some otherwise -> go otherwise | _ -> ()); go body | Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; ty = _ } -> process_pat ctx pat; @@ -795,6 +828,10 @@ let rec process_expr ~base_loc ctx (expr : Typedtree.expr) = | Some otherwise -> process_match_cases ctx ~base_loc otherwise); register_pat_binders ctx pat_binders ~base_loc; go body + | Texpr_array_as_view { array; _ } -> go array + | Texpr_and { lhs; rhs; _ } | Texpr_or { lhs; rhs; _ } -> + go lhs; + go rhs and process_fn ~base_loc ~in_pub_sig ctx (func : Typedtree.fn) = process_params ctx ~base_loc ~in_pub_sig func.params; @@ -808,17 +845,24 @@ and process_fn ~base_loc ~in_pub_sig ctx (func : Typedtree.fn) = process_expr ctx ~base_loc func.body and process_params ctx ~base_loc ~in_pub_sig (params : Typedtree.params) = - Lst.iter params (fun (Param { binder; konstraint; kind; ty = _ }) -> - register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local; - process_typ_opt ctx ~in_pub_sig konstraint; - match kind with - | Positional | Labelled | Autofill | Question_optional -> () - | Optional default -> process_expr ctx ~base_loc default) + Lst.iter params ~f:(fun p -> + match p with + | Discard_positional_param { konstraint; _ } -> + process_typ_opt ctx ~in_pub_sig konstraint + | Param { binder; konstraint; kind; ty = _ } -> ( + register_binder ctx binder ~base_loc ~is_mut:false ~kind:Local; + process_typ_opt ctx ~in_pub_sig konstraint; + match kind with + | Positional | Labelled | Autofill | Question_optional -> () + | Optional default -> process_expr ctx ~base_loc default)) and process_match_cases ctx ~base_loc (cases : Typedtree.match_case list) = - Lst.iter cases (fun { pat; action; pat_binders } -> + Lst.iter cases ~f:(fun { pat; action; pat_binders; guard } -> process_pat ctx pat; register_pat_binders ctx pat_binders ~base_loc; + (match guard with + | None -> () + | Some guard -> process_expr ctx ~base_loc guard); process_expr ctx ~base_loc action) let register_trait_decl ctx (trait : Typedtree.trait_decl) = @@ -827,15 +871,22 @@ let register_trait_decl ctx (trait : Typedtree.trait_decl) = let base = trait.trait_loc_ in let loc = Rloc.to_loc ~base trait.trait_name.loc_ in register_type ctx trait.trait_name.name (`Trait trait) ~loc; - Lst.iter trait.trait_methods (fun meth -> + Lst.iter trait.trait_methods ~f:(fun meth -> let loc = Rloc.to_loc ~base meth.method_name.loc_ in let trait = trait.trait_name.name in let method_name = meth.method_name.binder_name in - register_entity ctx - (Trait_method { trait; method_name }) - ~is_mut:false ~loc) + if not (name_should_be_ignored method_name) then + register_entity ctx + (Trait_method { trait; method_name }) + ~is_mut:false ~loc) | Vis_readonly | Vis_fully_pub -> () +let register_trait_alias ctx (decl : Typedtree.trait_alias_decl) = + if not decl.trait_alias_is_pub then + let base = decl.trait_alias_loc_ in + let loc = Rloc.to_loc ~base decl.trait_alias_name.loc_ in + register_type ctx decl.trait_alias_name.name (`Trait_alias decl) ~loc + let register_type_decl ctx (decl : Typedtree.type_decl) = let base = decl.td_loc_ in let is_pub = @@ -853,15 +904,18 @@ let register_type_decl ctx (decl : Typedtree.type_decl) = | Td_newtype _ | Td_error (Single_payload _) -> ( match decl.td_vis with | Vis_fully_pub -> () - | Vis_readonly | Vis_priv | Vis_default -> ( + | Vis_readonly | Vis_priv | Vis_default -> let ty = decl.td_binder.name in - match[@warning "-fragile-match"] ty with - | Toplevel { pkg = _; id } -> - let entity = Enum_constr { ty; name = id } in - register_entity ctx entity ~is_mut:true - ~loc:(Rloc.to_loc ~base decl.td_binder.loc_); - if is_pub || is_error then update_usage ctx entity Only_read - | _ -> assert false)) + let id = + match ty with + | Toplevel { pkg = _; id } -> id + | T_local { toplevel_id = _; name } -> name + | _ -> assert false + in + let entity = Enum_constr { ty; name = id } in + register_entity ctx entity ~is_mut:true + ~loc:(Rloc.to_loc ~base decl.td_binder.loc_); + if is_pub || is_error then update_usage ctx entity Only_read) | Td_variant constrs | Td_error (Enum_payload constrs) -> let ty = decl.td_binder.name in let can_construct_outside, can_read_outside = @@ -871,7 +925,7 @@ let register_type_decl ctx (decl : Typedtree.type_decl) = | Vis_priv | Vis_default -> (false, false) in if not can_construct_outside then - Lst.iter constrs (fun constr -> + Lst.iter constrs ~f:(fun constr -> let entity = Enum_constr { ty; name = constr.constr_name.label_name } in @@ -879,46 +933,52 @@ let register_type_decl ctx (decl : Typedtree.type_decl) = ~loc:(Rloc.to_loc ~base constr.constr_name.loc_); if can_read_outside || is_error then update_usage ctx entity Only_read; - Fn_arity.iter2 constr.constr_arity_ constr.constr_args - (fun kind arg -> - let kind = - match kind with - | Positional index -> Positional index - | Labelled { label; is_mut = _ } -> Labelled label - | Optional _ | Autofill _ | Question_optional _ -> - assert false - in - let entity = - Constr_argument { ty; tag = constr.constr_tag; kind } - in - register_entity ctx entity ~is_mut:arg.carg_mut - ~loc:(Rloc.to_loc ~base (Typedtree.loc_of_typ arg.carg_typ)); - if can_read_outside || is_error then - update_usage ctx entity Only_read)) - | Td_record fields -> ( + Fn_arity.iter2 constr.constr_arity_ constr.constr_args (fun kind -> + fun arg -> + let register_arg kind = + let entity = + Constr_argument { ty; tag = constr.constr_tag; kind } + in + register_entity ctx entity ~is_mut:arg.carg_mut + ~loc: + (Rloc.to_loc ~base (Typedtree.loc_of_typ arg.carg_typ)); + if can_read_outside || is_error then + update_usage ctx entity Only_read + [@@local] + in + match kind with + | Positional index -> register_arg (Positional index) + | Labelled { label; is_mut = _ } -> + if not (name_should_be_ignored label) then + register_arg (Labelled label) + | Optional _ | Autofill _ | Question_optional _ -> assert false)) + | Td_record fields -> let ty = decl.td_binder.name in - match decl.td_vis with - | Vis_fully_pub -> - Lst.iter fields (fun field -> - if field.field_vis = Vis_priv then - let entity = - Struct_field { ty; name = field.field_label.label_name } - in - register_entity ctx entity ~is_mut:field.field_mut - ~loc:(Rloc.to_loc ~base field.field_label.loc_)) - | Vis_readonly | Vis_priv | Vis_default -> + (match decl.td_vis with + | Vis_fully_pub + when Lst.for_all fields (fun field -> field.field_vis <> Invisible) -> + () + | _ -> register_entity ctx (Construct_struct { ty }) ~is_mut:false - ~loc:(Rloc.to_loc ~base decl.td_binder.loc_); - Lst.iter fields (fun field -> - let entity = - Struct_field { ty; name = field.field_label.label_name } - in - register_entity ctx entity ~is_mut:field.field_mut - ~loc:(Rloc.to_loc ~base field.field_label.loc_); - if is_pub && field.field_vis <> Vis_priv then - update_usage ctx entity Only_read)) + ~loc:(Rloc.to_loc ~base decl.td_binder.loc_)); + Lst.iter fields ~f:(fun field -> + let register_entity () = + let entity = + Struct_field { ty; name = field.field_label.label_name } + in + register_entity ctx entity ~is_mut:field.field_mut + ~loc:(Rloc.to_loc ~base field.field_label.loc_); + entity + in + match field.field_vis with + | Read_write -> () + | _ when name_should_be_ignored field.field_label.label_name -> () + | Readable -> + let entity = register_entity () in + update_usage ctx entity Only_read + | Invisible -> ignore (register_entity ())) let register_impl ctx (impl : Typedtree.impl) = match impl with @@ -946,27 +1006,30 @@ let register_impl ctx (impl : Typedtree.impl) = | Positional _ | Labelled _ -> () | Optional { label; loc_; _ } | Question_optional { label; loc_ } -> - let entity = - Fn_optional_arg { fn = binder.binder_id; label } - in - register_entity ctx entity ~is_mut:true ~loc:loc_ + if not (name_should_be_ignored label) then + let entity = + Fn_optional_arg { fn = binder.binder_id; label } + in + register_entity ctx entity ~is_mut:true ~loc:loc_ | Autofill { label; loc_ } -> - let entity = - Fn_optional_arg { fn = binder.binder_id; label } - in - register_entity ctx entity ~is_mut:false ~loc:loc_) + if not (name_should_be_ignored label) then + let entity = + Fn_optional_arg { fn = binder.binder_id; label } + in + register_entity ctx entity ~is_mut:false ~loc:loc_) | _ -> ()) let register_direct_use ctx (import_items : Pkg_config_util.import_items) = - Map_string.iter import_items (fun _pkg item -> - Lst.iter item.direct_uses (fun (name, loc) -> - let entity = Direct_pkg_use name in - register_entity ctx entity ~is_mut:false ~loc)) + Map_string.iter import_items (fun _pkg -> + fun item -> + Lst.iter item.direct_uses ~f:(fun (name, loc) -> + let entity = Direct_pkg_use name in + register_entity ctx entity ~is_mut:false ~loc)) let process_tvar_env ctx ~in_pub_sig (tvar_env : Tvar_env.t) = let usage = if in_pub_sig then Used_in_pub else Used_in_priv in Tvar_env.iter tvar_env (fun tparam -> - Lst.iter tparam.constraints (fun tvc -> + Lst.iter tparam.constraints ~f:(fun tvc -> update_type_usage ctx tvc.trait usage)) let process_trait_decl ctx (trait : Typedtree.trait_decl) = @@ -976,10 +1039,18 @@ let process_trait_decl ctx (trait : Typedtree.trait_decl) = | Vis_priv | Vis_default -> false in let go_typ ty = process_typ ctx ~in_pub_sig ty in - Lst.iter trait.trait_methods (fun meth -> - Lst.iter meth.method_params (fun (_, typ) -> go_typ typ); - Option.iter go_typ meth.method_ret; - Option.iter go_typ meth.method_err) + Lst.iter trait.trait_methods ~f:(fun meth -> + Lst.iter meth.method_params ~f:(fun (_, typ) -> go_typ typ); + (match meth.method_ret with + | Some method_ret -> go_typ method_ret + | _ -> ()); + match meth.method_err with + | Some method_err -> go_typ method_err + | _ -> ()) + +let process_trait_alias ctx (decl : Typedtree.trait_alias_decl) = + process_type_name ctx ~in_pub_sig:decl.trait_alias_is_pub + decl.trait_alias_target let process_type_decl ctx (decl : Typedtree.type_decl) = let is_pub = @@ -993,16 +1064,59 @@ let process_type_decl ctx (decl : Typedtree.type_decl) = | Td_abstract | Td_error No_payload -> () | Td_newtype typ | Td_error (Single_payload typ) | Td_alias typ -> go_typ typ | Td_variant constrs | Td_error (Enum_payload constrs) -> - Lst.iter constrs (fun constr -> - Lst.iter constr.constr_args (fun carg -> go_typ carg.carg_typ)) - | Td_record fields -> Lst.iter fields (fun field -> go_typ field.field_typ) + Lst.iter constrs ~f:(fun constr -> + Lst.iter constr.constr_args ~f:(fun carg -> go_typ carg.carg_typ)) + | Td_record fields -> Lst.iter fields ~f:(fun field -> go_typ field.field_typ) + +let rec collect_named_types ctx ~acc ty = + let go ty = collect_named_types ctx ~acc ty [@@inline] in + match Stype.type_repr ty with + | T_builtin _ | Tvar _ | T_blackhole | T_trait _ | Tparam _ -> () + | Tarrow { params_ty; ret_ty; err_ty; is_async = _ } -> ( + Lst.iter params_ty ~f:go; + go ret_ty; + match err_ty with Some err_ty -> go err_ty | _ -> ()) + | T_constr { type_constructor = p; tys } -> ( + Lst.iter tys ~f:go; + match Type_path.Hash.find_opt ctx.types p with + | Some { decl = `Type decl; _ } -> ( + match Type_path.Hash.find_opt acc p with + | None -> ( + Type_path.Hash.add acc p decl; + let go typ = go (Typedtree_util.stype_of_typ typ) [@@inline] in + match decl.td_desc with + | Td_abstract | Td_error No_payload -> () + | Td_error (Single_payload typ) | Td_newtype typ | Td_alias typ -> + go typ + | Td_error (Enum_payload constrs) | Td_variant constrs -> + Lst.iter constrs ~f:(fun constr -> + Lst.iter constr.constr_args ~f:(fun carg -> + go carg.carg_typ)) + | Td_record fields -> + Lst.iter fields ~f:(fun field -> go field.field_typ)) + | Some _ -> ()) + | None | Some { decl = `Trait _ | `Trait_alias _; _ } -> ()) let process_impl ctx (impl : Typedtree.impl) = match impl with | Timpl_expr { expr; loc_; expr_id = _; is_main = _ } -> process_expr ctx ~base_loc:loc_ expr | Timpl_fun_decl - { fun_decl = { kind; fn; is_pub; ty_params_; fn_binder = _ }; loc_ } -> + { + fun_decl = + { + kind; + fn; + is_pub; + ty_params_; + fn_binder = _; + constraint_names; + attrs = _; + }; + loc_; + } -> + Lst.iter constraint_names ~f:(fun c -> + process_type_name ctx ~in_pub_sig:is_pub c); (match kind with | Fun_kind_regular | Fun_kind_method None -> () | Fun_kind_method (Some type_name) | Fun_kind_default_impl type_name -> @@ -1012,115 +1126,78 @@ let process_impl ctx (impl : Typedtree.impl) = process_typ ctx ~in_pub_sig:is_pub self_ty); process_tvar_env ctx ~in_pub_sig:is_pub ty_params_; process_fn ctx ~in_pub_sig:is_pub ~base_loc:loc_ fn - | Timpl_letdef { konstraint; expr; is_pub; loc_; binder = _ } -> + | Timpl_letdef { konstraint; expr; is_pub; loc_; binder = _; attrs = _ } -> process_typ_opt ctx ~in_pub_sig:is_pub konstraint; process_expr ctx ~base_loc:loc_ expr - | Timpl_stub_decl { params; ret; is_pub; binder = _; func_stubs = _ } -> ( - Lst.iter params (fun (Param { konstraint; binder = _; ty; kind = _ }) -> + | Timpl_stub_decl { params; ret; is_pub; binder = _; func_stubs = _ } -> + let all_accessible_types = Type_path.Hash.create 17 in + Lst.iter params + ~f:(fun + ( Param { konstraint; binder = _; ty; kind = _ } + | Discard_positional_param { konstraint; ty; _ } ) + -> process_typ_opt ctx ~in_pub_sig:is_pub konstraint; - match Stype.extract_tpath (Stype.type_repr ty) with - | None -> () - | Some ty -> ( - match Type_path.Hash.find_opt ctx.types ty with - | None - | Some { decl = `Trait _; _ } - | Some - { decl = `Type { td_desc = Td_abstract | Td_alias _; _ }; _ } - -> - () - | Some { decl = `Type { td_desc = Td_record fields; _ }; _ } -> - Lst.iter fields (fun field -> - update_usage ctx - (Struct_field - { ty; name = field.field_label.label_name }) - Read_write) - | Some - { - decl = - `Type - { - td_desc = - ( Td_newtype _ - | Td_error (No_payload | Single_payload _) ); - _; - }; - _; - } -> ( - match[@warning "-fragile-match"] ty with - | Toplevel { pkg = _; id } -> - update_usage ctx (Enum_constr { ty; name = id }) Only_read - | _ -> assert false) - | Some - { - decl = - `Type - { - td_desc = - Td_variant constrs | Td_error (Enum_payload constrs); - _; - }; - _; - } -> - Lst.iter constrs (fun constr -> - update_usage ctx - (Enum_constr - { ty; name = constr.constr_name.label_name }) - Only_read))); - process_typ_opt ctx ~in_pub_sig:is_pub ret; - match ret with - | Some typ -> ( - match - Stype.extract_tpath - (Stype.type_repr (Typedtree_util.stype_of_typ typ)) - with - | None -> () - | Some ty -> ( - match Type_path.Hash.find_opt ctx.types ty with - | Some { decl = `Type { td_desc = Td_record _; _ }; _ } -> - update_usage ctx (Construct_struct { ty }) Only_write - | Some - { - decl = - `Type - { - td_desc = - ( Td_newtype _ - | Td_error (No_payload | Single_payload _) ); - _; - }; - _; - } -> ( - match[@warning "-fragile-match"] ty with - | Toplevel { pkg = _; id } -> - update_usage ctx - (Enum_constr { ty; name = id }) - Only_write - | _ -> assert false) - | Some - { - decl = - `Type - { - td_desc = - Td_variant constrs | Td_error (Enum_payload constrs); - _; - }; - _; - } -> - Lst.iter constrs (fun constr -> - update_usage ctx - (Enum_constr - { ty; name = constr.constr_name.label_name }) - Only_write) - | None - | Some - { - decl = - `Type { td_desc = Td_abstract | Td_alias _; _ } | `Trait _; - _; - } -> - ())) - | None -> ()) + collect_named_types ctx ty ~acc:all_accessible_types); + (match ret with + | Some ret -> + process_typ ctx ~in_pub_sig:is_pub ret; + collect_named_types ctx + (Typedtree_util.stype_of_typ ret) + ~acc:all_accessible_types + | None -> ()); + Type_path.Hash.iter2 all_accessible_types (fun ty -> + fun decl -> + match decl with + | { td_vis = Vis_fully_pub; _ } -> () + | { td_desc = Td_abstract | Td_alias _; _ } -> () + | { td_desc = Td_record fields; _ } -> + Lst.iter fields ~f:(fun field -> + update_usage ctx + (Struct_field { ty; name = field.field_label.label_name }) + Read_write); + update_usage ctx (Construct_struct { ty }) Only_write + | { + td_desc = Td_newtype _ | Td_error (No_payload | Single_payload _); + _; + } -> ( + match[@warning "-fragile-match"] ty with + | Toplevel { pkg = _; id } -> + update_usage ctx (Enum_constr { ty; name = id }) Read_write + | _ -> assert false) + | { + td_desc = Td_variant constrs | Td_error (Enum_payload constrs); + _; + } -> + Lst.iter constrs ~f:(fun constr -> + let tag = constr.constr_tag in + update_usage ctx + (Enum_constr { ty; name = constr.constr_name.label_name }) + Read_write; + ignore + (Lst.fold_left constr.constr_args 0 + (fun positional_index -> + fun carg -> + match carg.carg_label with + | None -> + update_usage ctx + (Constr_argument + { + ty; + tag; + kind = Positional positional_index; + }) + Only_read; + positional_index + 1 + | Some label -> + update_usage ctx + (Constr_argument + { + ty; + tag; + kind = Labelled label.label_name; + }) + Read_write; + positional_index)))) let analyze_usage ~(import_items : Pkg_config_util.import_items) (prog : Typedtree.output) = @@ -1131,112 +1208,138 @@ let analyze_usage ~(import_items : Pkg_config_util.import_items) excluding = Ident.Set.empty; } in - let (Output { value_defs; type_defs; trait_defs }) = prog in - Lst.iter trait_defs (register_trait_decl ctx); - Lst.iter type_defs (register_type_decl ctx); - Lst.iter value_defs (register_impl ctx); + let (Output { value_defs; type_defs; trait_defs; trait_alias }) = prog in + Lst.iter trait_defs ~f:(register_trait_decl ctx); + Lst.iter trait_alias ~f:(register_trait_alias ctx); + Lst.iter type_defs ~f:(register_type_decl ctx); + Lst.iter value_defs ~f:(register_impl ctx); register_direct_use ctx import_items; - Lst.iter trait_defs (process_trait_decl ctx); - Lst.iter type_defs (process_type_decl ctx); - Lst.iter value_defs (process_impl ctx); + Lst.iter trait_defs ~f:(process_trait_decl ctx); + Lst.iter trait_alias ~f:(process_trait_alias ctx); + Lst.iter type_defs ~f:(process_type_decl ctx); + Lst.iter value_defs ~f:(process_impl ctx); ctx -let report_unused ~diagnostics ~ctx = +let report_unused ~diagnostics ~ctx ~report_unused_abstract_type = let unused_types : Type_path.Hashset.t = Type_path.Hashset.create 17 in - Type_path.Hash.iter2 ctx.types (fun ty info -> - let report w = - Diagnostics.add_warning diagnostics { loc = info.loc; kind = w } - in - let vis = - match info.decl with `Type td -> td.td_vis | `Trait tr -> tr.trait_vis - in - match (vis, info.usage) with - | (Vis_fully_pub | Vis_readonly), _ -> assert false - | _, Unused -> - Type_path.Hashset.add unused_types ty; - report (Unused_type_declaration (Type_path_util.name ty)) - | Vis_priv, (Used_in_priv | Used_in_pub) | Vis_default, Used_in_pub -> () - | Vis_default, Used_in_priv -> - let _ = Warnings.Unused_abstract_type (Type_path_util.name ty) in - ()); + Type_path.Hash.iter2 ctx.types (fun ty -> + fun info -> + let report w = + Diagnostics.add_warning diagnostics { loc = info.loc; kind = w } + in + let vis = + match info.decl with + | `Type td -> td.td_vis + | `Trait tr -> tr.trait_vis + | `Trait_alias decl -> + if decl.trait_alias_is_pub then Vis_fully_pub else Vis_priv + in + match (vis, info.usage) with + | (Vis_fully_pub | Vis_readonly), _ -> assert false + | _, Unused -> + Type_path.Hashset.add unused_types ty; + report (Unused_type_declaration (Type_path_util.name ty)) + | Vis_priv, (Used_in_priv | Used_in_pub) | Vis_default, Used_in_pub -> () + | Vis_default, Used_in_priv -> + if report_unused_abstract_type then + let name = Type_path_util.name ty in + let kind = + match info.decl with + | `Type _ -> "type" + | `Trait _ | `Trait_alias _ -> "trait" + in + report (Unused_abstract_type { name; kind })); let constr_is_read ty tag = let entity = Enum_constr { ty; name = Constr_info.get_name tag } in match (H.find_exn ctx.entities entity).usage with | Read_write | Only_read -> true | Only_write | Unused -> false in - H.iter2 ctx.entities (fun entity info -> - let report w = - Diagnostics.add_warning diagnostics { loc = info.loc; kind = w } - in - match (entity, info.usage) with - | _, Read_write -> () - | _, Only_read when not info.is_mut -> () - | Struct_field { ty; name = _ }, _ - | Construct_struct { ty }, _ - | Enum_constr { ty; name = _ }, _ - when Type_path.Hashset.mem unused_types ty -> - () - | Struct_field { ty = _; name }, (Unused | Only_write) -> - report (Unused_field name) - | Struct_field { ty = _; name }, Only_read -> - report (Unused_mutability ("field '" ^ name ^ "'" : Stdlib.String.t)) - | Construct_struct { ty }, Unused -> - report (Struct_never_constructed (Type_path_util.name ty)) - | Construct_struct _, (Only_read | Only_write) -> () - | Enum_constr { ty = _; name }, Unused -> - report (Unused_constructor { constr = name; kind = Unused }) - | Enum_constr { ty = _; name }, Only_write -> - report (Unused_constructor { constr = name; kind = No_read }) - | Enum_constr { ty = _; name }, Only_read -> - report (Unused_constructor { constr = name; kind = No_construct }) - | Trait_method { trait = _; method_name }, Unused -> - report (Unused_func method_name) - | Trait_method _, (Only_read | Only_write) -> () - | Var { id; kind }, (Unused | Only_write) -> ( - let var_name = Ident.base_name id in - match kind with - | Local -> report (Unused_var { var_name; is_toplevel = false }) - | Top_let -> report (Unused_var { var_name; is_toplevel = true }) - | Local_func | Top_func -> report (Unused_func var_name)) - | Var { id; kind = _ }, Only_read -> - report - (Unused_mutability - ("'" ^ Ident.base_name id ^ "'" : Stdlib.String.t)) - | Constr_argument { ty; tag; kind = _ }, _ - when not (constr_is_read ty tag) -> - () - | ( Constr_argument { ty = _; tag; kind = Positional index }, - (Unused | Only_write) ) -> - let constr = Constr_info.get_name tag in - report (Unused_constr_arg { constr; index }) - | Constr_argument { ty = _; tag; kind = Labelled label }, Unused -> - let constr = Constr_info.get_name tag in - report (Unused_constr_field { constr; label; is_mutated = false }) - | Constr_argument { ty = _; tag; kind = Labelled label }, Only_write -> - let constr = Constr_info.get_name tag in - report (Unused_constr_field { constr; label; is_mutated = true }) - | Constr_argument { ty = _; tag; kind }, Only_read -> ( - match[@warning "-fragile-match"] kind with - | Labelled label -> - report - (Unused_mutability - (Stdlib.String.concat "" - [ - "field '"; - label; - "' of constructor "; - Constr_info.get_name tag; - ])) - | _ -> assert false) - | Fn_optional_arg { fn = _; label }, usage -> - if usage = optional_arg_supplied then - report (Optional_arg_always_supplied label) - else if usage = optional_arg_use_default then - report (Optional_arg_never_supplied label) - | Direct_pkg_use name, Unused -> report (Unused_import_value name) - | Direct_pkg_use _, _ -> ()) - -let analyze_unused ~diagnostics ~import_items (prog : Typedtree.output) = + H.iter2 ctx.entities (fun entity -> + fun info -> + let report w = + Diagnostics.add_warning diagnostics { loc = info.loc; kind = w } + in + match (entity, info.usage) with + | _, Read_write -> () + | _, Only_read when not info.is_mut -> () + | Struct_field { ty; name = _ }, _ + | Construct_struct { ty }, _ + | Enum_constr { ty; name = _ }, _ + when Type_path.Hashset.mem unused_types ty -> + () + | Struct_field { ty = _; name }, (Unused | Only_write) -> + report (Unused_field name) + | Struct_field { ty = _; name }, Only_read -> + report + (Unused_mutability + (("field '" ^ name ^ "'" : Stdlib.String.t) [@merlin.hide])) + | Construct_struct { ty }, Unused -> + report (Struct_never_constructed (Type_path_util.name ty)) + | Construct_struct _, (Only_read | Only_write) -> () + | Enum_constr { ty = _; name }, Unused -> + report (Unused_constructor { constr = name; kind = Unused }) + | Enum_constr { ty = _; name }, Only_write -> + report (Unused_constructor { constr = name; kind = No_read }) + | Enum_constr { ty = _; name }, Only_read -> + report (Unused_constructor { constr = name; kind = No_construct }) + | Trait_method { trait = _; method_name }, Unused -> + report (Unused_func method_name) + | Trait_method _, (Only_read | Only_write) -> () + | Var { id; kind }, (Unused | Only_write) -> ( + let var_name = Ident.base_name id in + match kind with + | Local -> report (Unused_var { var_name; is_toplevel = false }) + | Top_let -> report (Unused_var { var_name; is_toplevel = true }) + | Local_func | Top_func -> report (Unused_func var_name)) + | Var { id; kind = _ }, Only_read -> + report + (Unused_mutability + (("'" ^ Ident.base_name id ^ "'" + : Stdlib.String.t) + [@merlin.hide])) + | Constr_argument { ty; tag; kind = _ }, _ + when not (constr_is_read ty tag) -> + () + | ( Constr_argument { ty = _; tag; kind = Positional index }, + (Unused | Only_write) ) -> + let constr = Constr_info.get_name tag in + report (Unused_constr_arg { constr; index }) + | Constr_argument { ty = _; tag; kind = Labelled label }, Unused -> + let constr = Constr_info.get_name tag in + report (Unused_constr_field { constr; label; is_mutated = false }) + | Constr_argument { ty = _; tag; kind = Labelled label }, Only_write -> + let constr = Constr_info.get_name tag in + report (Unused_constr_field { constr; label; is_mutated = true }) + | Constr_argument { ty = _; tag; kind }, Only_read -> ( + match[@warning "-fragile-match"] kind with + | Labelled label -> + report + (Unused_mutability + (Stdlib.String.concat "" + [ + "field '"; + label; + "' of constructor "; + Constr_info.get_name tag; + ] [@merlin.hide])) + | _ -> assert false) + | Fn_optional_arg { fn = _; label }, usage -> + if usage = optional_arg_supplied then + report (Optional_arg_always_supplied label) + else if usage = optional_arg_use_default then + report (Optional_arg_never_supplied label) + | Direct_pkg_use name, Unused -> report (Unused_import_value name) + | Direct_pkg_use _, _ -> ()) + +let analyze_unused ~diagnostics ~import_items + ~(build_context : Typeutil.build_context) + ~(import_kind : Pkg_config_util.import_kind) (prog : Typedtree.output) = let ctx = analyze_usage ~import_items prog in - report_unused ~diagnostics ~ctx + let report_unused_abstract_type = + match build_context with + | Exec _ | SingleFile -> false + | Lib -> ( + match import_kind with Wbtest | Bbtest -> false | Normal -> true) + in + report_unused ~diagnostics ~ctx ~report_unused_abstract_type diff --git a/src/derive.ml b/src/derive.ml index e8b7e04..27ad5cf 100644 --- a/src/derive.ml +++ b/src/derive.ml @@ -15,124 +15,112 @@ module Qual_ident = Basic_qual_ident module Type_path = Basic_type_path -module Longident = Basic_longident module Lst = Basic_lst module Syntax = Parsing_syntax let add_error = Local_diagnostics.add_error -let resolve_derive_alias (trait : Longident.t) : Longident.t = - match trait with - | Lident "FromJson" -> Ldot { pkg = "moonbitlang/core/json"; id = "FromJson" } - | Lident "Arbitrary" -> - Ldot { pkg = "moonbitlang/core/quickcheck"; id = "Arbitrary" } - | trait -> trait - let generate_signatures ~(types : Global_env.All_types.t) ~(ext_method_env : Ext_method_env.t) ~(trait_impls : Trait_impl.t) (decl : Typedecl_info.t) (trait : Syntax.type_name) - ~(diagnostics : Local_diagnostics.t) ~loc = - match Global_env.All_types.find_trait ~loc:trait.loc_ types trait.name with - | Error err -> add_error diagnostics err - | Ok trait_decl -> - let impl_params = - Tvar_env.map decl.ty_params_ (fun tvar -> - assert (tvar.constraints = []); - let constraints = - Trait_closure.compute_closure ~types - [ - { - trait = trait_decl.name; - loc_ = trait.loc_; - required_by_ = []; - }; - ] - in - Tvar_env.tparam_info ~name:tvar.name ~typ:tvar.typ ~constraints - ~loc:Rloc.no_location) - in - let is_suberror_ = - match decl.ty_desc with - | Error_type _ | ErrorEnum_type _ -> true - | _ -> false - in - let self_typ : Stype.t = - T_constr - { - type_constructor = decl.ty_constr; - tys = Tvar_env.get_types impl_params; - generic_ = not (Tvar_env.is_empty impl_params); - only_tag_enum_ = decl.ty_is_only_tag_enum_; - is_suberror_; - } - in - let pub = - match decl.ty_vis with - | Vis_fully_pub | Vis_readonly | Vis_default -> true - | Vis_priv -> false - in - let has_error = ref false in - let check_duplicate_impl self_type method_name = - match - Ext_method_env.find_method ext_method_env ~trait:trait_decl.name - ~self_type ~method_name - with - | None -> true - | Some method_info -> - has_error := true; - add_error diagnostics - (Errors.derive_method_exists ~trait:trait_decl.name - ~type_name:self_type ~method_name ~prev_loc:method_info.loc - ~loc:trait.loc_); - false - [@@inline] - in - let add_method (method_info : Method_env.method_info) = - match[@warning "-fragile-match"] method_info.id with - | Qext_method { trait; self_typ; name } -> - if check_duplicate_impl self_typ name then - Ext_method_env.add_method ext_method_env ~trait - ~self_type:self_typ ~method_name:name method_info - | _ -> assert false - [@@inline] - in - Lst.iter trait_decl.methods (fun meth -> - let impl_ty = Poly_type.instantiate_method_decl meth ~self:self_typ in - let method_name = meth.method_name in - if - (not - (Type_path.equal trait_decl.name Type_path.Builtin.trait_hash - && method_name = "hash")) - && not - (Type_path.equal trait_decl.name Type_path.Builtin.trait_show - && method_name = "to_string") - then - add_method - { - id = - Qual_ident.ext_meth ~trait:trait_decl.name - ~self_typ:decl.ty_constr ~name:method_name; - prim = None; - typ = impl_ty; - pub; - loc; - doc_ = - Docstring.make ~pragmas:[] ~loc:Loc.no_location - [ "automatically derived" ]; - ty_params_ = impl_params; - arity_ = meth.method_arity; - param_names_ = []; - }); - if not !has_error then - let trait = trait_decl.name in - let type_name = decl.ty_constr in - let impl : Trait_impl.impl = - { - trait; - self_ty = self_typ; - ty_params = impl_params; - is_pub = pub; - loc_ = loc; - } + (trait_decl : Trait_decl.t) ~(diagnostics : Local_diagnostics.t) ~loc = + let impl_params = + Tvar_env.map decl.ty_params_ (fun tvar -> + assert (tvar.constraints = []); + let constraints = + Trait_closure.compute_closure ~types + [ { trait = trait_decl.name; loc_ = trait.loc_; src_ = Direct } ] in - Trait_impl.add_impl trait_impls ~trait ~type_name impl + Tvar_env.tparam_info ~name:tvar.name ~typ:tvar.typ ~constraints + ~loc:Rloc.no_location) + in + let is_suberror_ = + match decl.ty_desc with + | Error_type _ | ErrorEnum_type _ -> true + | _ -> false + in + let self_typ : Stype.t = + T_constr + { + type_constructor = decl.ty_constr; + tys = Tvar_env.get_types impl_params; + generic_ = not (Tvar_env.is_empty impl_params); + is_suberror_; + } + in + let pub = + match decl.ty_vis with + | Vis_fully_pub | Vis_readonly | Vis_default -> true + | Vis_priv -> false + in + let has_error = ref false in + let check_duplicate_impl self_type method_name = + match + Ext_method_env.find_method ext_method_env ~trait:trait_decl.name + ~self_type ~method_name + with + | None -> true + | Some method_info -> + has_error := true; + add_error diagnostics + (Errors.derive_method_exists ~trait:trait_decl.name + ~type_name:self_type ~method_name ~prev_loc:method_info.loc + ~loc:trait.loc_); + false + [@@inline] + in + let add_method (method_info : Method_env.method_info) = + match[@warning "-fragile-match"] method_info.id with + | Qext_method { trait; self_typ; name } -> + if check_duplicate_impl self_typ name then + Ext_method_env.add_method ext_method_env ~trait ~self_type:self_typ + ~method_name:name method_info + | _ -> assert false + [@@inline] + in + Lst.iter trait_decl.methods ~f:(fun meth -> + let impl_ty = Poly_type.instantiate_method_decl meth ~self:self_typ in + let method_name = meth.method_name in + if + (not + (Type_path.equal trait_decl.name Type_path.Builtin.trait_hash + && method_name = "hash")) + && not + (Type_path.equal trait_decl.name Type_path.Builtin.trait_show + && method_name = "to_string") + then + add_method + { + id = + Qual_ident.ext_meth ~trait:trait_decl.name + ~self_typ:decl.ty_constr ~name:method_name; + prim = None; + typ = impl_ty; + pub; + loc; + doc_ = + Docstring.make ~pragmas:[] ~loc:Loc.no_location + [ "automatically derived" ]; + attrs = []; + ty_params_ = impl_params; + kind_ = Method_explicit_self { self_ty = self_typ }; + arity_ = meth.method_arity; + param_names_ = []; + }); + if not !has_error then + let trait = trait_decl.name in + let type_name = decl.ty_constr in + let impl : Trait_impl.impl = + { + trait; + self_ty = self_typ; + ty_params = impl_params; + is_pub = pub; + is_implicit_ = false; + doc_ = + Docstring.make ~pragmas:[] ~loc:Loc.no_location + [ "automatically derived" ]; + loc_ = loc; + } + in + Trait_impl.add_impl trait_impls ~trait ~type_name impl diff --git a/src/derive_args.ml b/src/derive_args.ml index 6c27a52..af1df4d 100644 --- a/src/derive_args.ml +++ b/src/derive_args.ml @@ -15,42 +15,7 @@ module StringMap = Basic_map_string module Syntax = Parsing_syntax - -type meta_labelled_arg_spec = { - name : string; - alias : string list; - allow_no_value : bool; - allow_value : bool; - on_repeat : [ `Error | `Append | `Replace ]; - action : (Syntax.argument list -> unit) option; -} - -type meta_arg_parser = { - reverse_args : meta_labelled_arg_spec StringMap.t; - allow_positional : bool; - allow_unknown_labelled : bool; -} - -let decl_meta_arg name ?(alias : string list = []) ?(allow_no_value = false) - ?(allow_value = false) ?(action = None) ?(on_repeat = `Error) () = - { name; alias; allow_no_value; allow_value; action; on_repeat } - -let mk_parser (args : meta_labelled_arg_spec list) ?(allow_positional = false) - ?(allow_unknown_labelled = false) () = - let reverse_args = - List.fold_left - (fun acc (arg : meta_labelled_arg_spec) -> - List.fold_left - (fun acc alias -> StringMap.add acc alias arg) - acc (arg.name :: arg.alias)) - StringMap.empty args - in - { reverse_args; allow_positional; allow_unknown_labelled } - -type parsed_meta_args = { - positional : Syntax.argument list; - labelled : Syntax.argument list StringMap.t; -} +module Lst = Basic_lst let mk_diag_emitter ~(host_type : string) ~(trait_name : Basic_longident.t) (diag : Local_diagnostics.t) (msg : string) (loc : Rloc.t) = @@ -59,98 +24,219 @@ let mk_diag_emitter ~(host_type : string) ~(trait_name : Basic_longident.t) in Local_diagnostics.add_error diag report -let parse (parser : meta_arg_parser) ~(host_type : string) - (directive : Syntax.deriving_directive) (diag : Local_diagnostics.t) = - let met_error = ref false in - let emit_diag msg loc = - met_error := true; - mk_diag_emitter ~host_type ~trait_name:directive.type_name_.name diag msg - loc - in - let args = directive.args in - let positional = ref [] in - let labelled = ref StringMap.empty in - let do_add_labelled is_replace id args = - let old = StringMap.find_opt !labelled id in - let new_args = - match old with - | None -> args - | Some old_args -> if is_replace then args else old_args @ args - in - labelled := StringMap.add !labelled id new_args - in - let try_add_labelled id (args : Syntax.argument list) loc = - let meta_arg_desc = StringMap.find_opt parser.reverse_args id in - match meta_arg_desc with - | None when not parser.allow_unknown_labelled -> - emit_diag ("Unknown labelled argument: " ^ id : Stdlib.String.t) loc - | None -> do_add_labelled false id args - | Some meta_arg_desc -> ( - let { allow_no_value; allow_value; on_repeat; action; _ } = - meta_arg_desc - in - match args with - | [] when not allow_no_value -> - emit_diag ("Expected value for " ^ id : Stdlib.String.t) loc - | _ :: _ when not allow_value -> - emit_diag ("Unexpected value for " ^ id : Stdlib.String.t) loc - | _ -> ( - let id = meta_arg_desc.name in - (match on_repeat with - | `Error when StringMap.mem !labelled id -> - emit_diag ("Duplicate argument: " ^ id : Stdlib.String.t) loc - | `Error -> do_add_labelled false id args - | `Append -> do_add_labelled false id args - | `Replace -> do_add_labelled true id args); - match action with None -> () | Some action -> action args)) - in - let mk_positional arg : Syntax.argument = - { arg_kind = Syntax.Positional; arg_value = arg } - in - let parse_single (arg : Syntax.argument) = - match arg.arg_kind with - | Syntax.Positional -> ( - match arg.arg_value with - | Syntax.Pexpr_ident - { id = { var_name = Basic_longident.Lident id; _ }; loc_ } -> - try_add_labelled id [] loc_ - | Syntax.Pexpr_ident { loc_; _ } -> - emit_diag "Non-local identifier not supported" loc_ - | Syntax.Pexpr_apply - { - func = - Syntax.Pexpr_ident - { id = { var_name = Basic_longident.Lident id; _ }; _ }; - args; - loc_; - _; - } -> - try_add_labelled id args loc_ - | Syntax.Pexpr_apply { loc_; _ } -> - emit_diag "Non-local identifier not supported" loc_ - | expr -> - if parser.allow_positional then positional := arg :: !positional - else - emit_diag "Positional arguments are not allowed" - (Syntax.loc_of_expression expr)) - | Syntax.Labelled lbl | Syntax.Labelled_option { label = lbl; _ } -> - let name = lbl.label_name in - let arg = mk_positional arg.arg_value in - let loc = lbl.loc_ in - try_add_labelled name [ arg ] loc - | Syntax.Labelled_pun _ | Syntax.Labelled_option_pun _ -> - emit_diag "Labelled pun arguments are not allowed" - (Syntax.loc_of_expression arg.arg_value) - in - List.iter parse_single args; - if !met_error then Error () - else Ok { positional = !positional; labelled = !labelled } - let deny_all_args ~host_type ~trait_name diag (directive : Syntax.deriving_directive) = if directive.args <> [] then ( mk_diag_emitter ~host_type ~trait_name diag - ("{trait_name} does not accept any arguments." : Stdlib.String.t) + (Basic_longident.to_string trait_name ^ " does not accept any arguments." + : Stdlib.String.t) directive.loc_; true) else false + +let extract_string (expr : Syntax.expr) = + match expr with + | Syntax.Pexpr_constant { c = Syntax.Const_string s; _ } -> Ok s.string_val + | Syntax.Pexpr_multiline_string { elems; _ } -> + if + List.for_all + (fun elem -> + match elem with Syntax.Multiline_string _ -> true | _ -> false) + elems + then + Ok + (String.concat "\n" + (Lst.map elems (fun elem -> + match elem with Syntax.Multiline_string s -> s | _ -> ""))) + else Error "Interpolation is not allowed in this position" + | Syntax.Pexpr_interp _ -> + Error "Interpolation is not allowed in this position" + | _ -> Error "Expected a string" + +let extract_constant (expr : Syntax.expr) = + match expr with + | Syntax.Pexpr_constant { c; _ } -> Ok c + | _ -> ( + match extract_string expr with + | Ok s -> Ok (Syntax.Const_string { string_val = s; string_repr = s }) + | Error _ -> Error "Not a constant value") + +let extract_string_interp (expr : Syntax.expr) = + match expr with + | Syntax.Pexpr_constant { c = Syntax.Const_string s; loc_ } -> + Ok + [ Syntax.Interp_lit { str = s.string_val; repr = s.string_repr; loc_ } ] + | Syntax.Pexpr_interp { elems; _ } -> Ok elems + | Syntax.Pexpr_multiline_string { elems; _ } -> + Ok + (Lst.concat + (Lst.map elems (fun elem -> + match elem with + | Syntax.Multiline_string s -> + [ + Syntax.Interp_lit + { str = s; repr = s; loc_ = Rloc.no_location }; + ] + | Syntax.Multiline_interp interp -> interp))) + | _ -> Error "Expected a string or an interpolated string" + +type meta_item_value = + | Nothing + | Value of Syntax.expr + | Arguments of Syntax.argument list + +type meta_item = { + label : string option; + value : meta_item_value; + loc_ : Rloc.t; +} + +exception MetaParseError of string * Rloc.t +exception MetaParseErrorNoEmit + +let item_label (item : meta_item) = item.label + +let item_label_is (label : string) (item : meta_item) = + match item.label with Some lbl -> lbl = label | None -> false + +let item_is_positional (item : meta_item) = item.label = None + +let item_no_value_exn (item : meta_item) = + match item.value with + | Nothing -> () + | _ -> raise (MetaParseError ("Expected no value", item.loc_)) + +let item_value_expr_exn (item : meta_item) = + match item.value with + | Value expr -> expr + | _ -> raise (MetaParseError ("Expected an expression", item.loc_)) + +let item_value_args_exn (item : meta_item) = + match item.value with + | Arguments args -> args + | _ -> raise (MetaParseError ("Expected arguments", item.loc_)) + +let item_string_exn (item : meta_item) = + match extract_string (item_value_expr_exn item) with + | Ok s -> s + | Error msg -> raise (MetaParseError (msg, item.loc_)) + +let item_string_interp_exn (item : meta_item) = + match extract_string_interp (item_value_expr_exn item) with + | Ok interp -> interp + | Error msg -> raise (MetaParseError (msg, item.loc_)) + +let item_constant_exn (item : meta_item) = + match extract_constant (item_value_expr_exn item) with + | Ok c -> c + | Error msg -> raise (MetaParseError (msg, item.loc_)) + +let fail_item (item : meta_item) msg = raise (MetaParseError (msg, item.loc_)) + +let parse_single (arg : Syntax.argument) = + match arg.arg_kind with + | Syntax.Positional -> ( + match arg.arg_value with + | Syntax.Pexpr_ident + { id = { var_name = Basic_longident.Lident id; _ }; loc_ } + | Syntax.Pexpr_constr + { constr = { constr_name = { name = id; _ }; _ }; loc_ } -> + { label = Some id; value = Nothing; loc_ } + | Syntax.Pexpr_ident { id = { var_name = id; _ }; loc_ } -> + raise + (MetaParseError + ( (("Non-local identifier " + ^ Basic_longident.to_string id + ^ " not supported" + : Stdlib.String.t) + [@merlin.hide]), + loc_ )) + | Syntax.Pexpr_apply + { + func = + Syntax.Pexpr_ident + { id = { var_name = Basic_longident.Lident id; _ }; _ }; + args; + loc_; + _; + } + | Syntax.Pexpr_apply + { + func = + Syntax.Pexpr_constr + { constr = { constr_name = { name = id; _ }; _ }; _ }; + args; + loc_; + _; + } -> + { label = Some id; value = Arguments args; loc_ } + | Syntax.Pexpr_apply { loc_; _ } -> + raise + (MetaParseError + ( "Unexpected left-hand side of labelled meta arguments, should \ + be an identifier", + loc_ )) + | expr -> + { + label = None; + value = Value expr; + loc_ = Syntax.loc_of_expression expr; + }) + | Syntax.Labelled lbl | Syntax.Labelled_option { label = lbl; _ } -> + { + label = Some lbl.label_name; + value = Value arg.arg_value; + loc_ = Syntax.loc_of_expression arg.arg_value; + } + | Syntax.Labelled_pun _ | Syntax.Labelled_option_pun _ -> + raise + (MetaParseError + ( "Labelled pun arguments are not allowed", + Syntax.loc_of_expression arg.arg_value )) + +let parse (args : Syntax.argument list) (emit_diag : string -> Rloc.t -> unit) + (on_item : meta_item -> unit) = + (let has_err = + List.fold_left + (fun has_err -> + fun it -> + try + let item = parse_single it in + on_item item; + has_err + with + | MetaParseErrorNoEmit -> true + | MetaParseError (msg, loc) -> + emit_diag msg loc; + true) + false args + in + if has_err then raise MetaParseErrorNoEmit + : unit) + +let parse_fold (args : Syntax.argument list) + (emit_diag : string -> Rloc.t -> unit) (init : 'a) + (f : 'a -> meta_item -> 'a) = + (let rec loop acc = function + | [] -> acc + | arg :: rest -> ( + try + let item = parse_single arg in + loop (f acc item) rest + with + | MetaParseErrorNoEmit -> loop acc rest + | MetaParseError (msg, loc) -> + emit_diag msg loc; + loop acc rest) + in + loop init args + : 'a) + +let wrap_parse (f : unit -> 'a) = + (try Some (f ()) with + | MetaParseErrorNoEmit -> None + | MetaParseError _ -> + failwith + "Unexpected error: MetaParseError should not appear outside of \ + parsing functions" + : 'a option) diff --git a/src/diagnostics.ml b/src/diagnostics.ml index f3969ee..f53cefd 100644 --- a/src/diagnostics.ml +++ b/src/diagnostics.ml @@ -26,7 +26,8 @@ include struct loc = loc__002_; message = message__004_; error_code = error_code__006_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__007_ = Error_code.sexp_of_t error_code__006_ in @@ -48,47 +49,50 @@ include struct let _ = sexp_of_report let compare_report = - (fun a__008_ b__009_ -> - if Stdlib.( == ) a__008_ b__009_ then 0 - else - match Loc.compare a__008_.loc b__009_.loc with - | 0 -> ( - match - Stdlib.compare (a__008_.message : string) b__009_.message - with - | 0 -> Error_code.compare a__008_.error_code b__009_.error_code - | n -> n) - | n -> n + (fun a__008_ -> + fun b__009_ -> + if Stdlib.( == ) a__008_ b__009_ then 0 + else + match Loc.compare a__008_.loc b__009_.loc with + | 0 -> ( + match + Stdlib.compare (a__008_.message : string) b__009_.message + with + | 0 -> Error_code.compare a__008_.error_code b__009_.error_code + | n -> n) + | n -> n : report -> report -> int) let _ = compare_report let equal_report = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then true - else - Stdlib.( && ) - (Loc.equal a__010_.loc b__011_.loc) - (Stdlib.( && ) - (Stdlib.( = ) (a__010_.message : string) b__011_.message) - (Error_code.equal a__010_.error_code b__011_.error_code)) + (fun a__010_ -> + fun b__011_ -> + if Stdlib.( == ) a__010_ b__011_ then true + else + Stdlib.( && ) + (Loc.equal a__010_.loc b__011_.loc) + (Stdlib.( && ) + (Stdlib.( = ) (a__010_.message : string) b__011_.message) + (Error_code.equal a__010_.error_code b__011_.error_code)) : report -> report -> bool) let _ = equal_report end -let report_to_json ~is_error report : Json.t = - let level = if is_error then "error" else "warning" in - `Assoc - [ - ("$message_type", `String "diagnostic"); - ("level", `String level); - ("loc", Loc.t_to_json report.loc); - ("message", `String report.message); - ("error_code", Error_code.t_to_json report.error_code); - ] - -module Report_set = Basic_setf.Make (struct +let report_to_json ~is_error report = + (let level = if is_error then "error" else "warning" in + `Assoc + [ + ("$message_type", `String "diagnostic"); + ("level", `String level); + ("loc", Loc.t_to_json report.loc); + ("message", `String report.message); + ("error_code", Error_code_utils.to_json report.error_code); + ] + : Json.t) + +module Error_set = Basic_setf.Make (struct type t = report include struct @@ -133,16 +137,16 @@ end) exception Fatal_error type t = { - mutable errors : Report_set.t; + mutable errors : Error_set.t; mutable alerts : Alert_set.t; mutable warnings : Warning_set.t; } -let has_fatal_errors (x : t) = not (Report_set.is_empty x.errors) +let has_fatal_errors (x : t) = not (Error_set.is_empty x.errors) let make () = { - errors = Report_set.empty; + errors = Error_set.empty; alerts = Alert_set.empty; warnings = Warning_set.empty; } @@ -150,7 +154,7 @@ let make () = let add_warning (x : t) (w : warning) = x.warnings <- Warning_set.add x.warnings w -let add_error (x : t) (w : report) = x.errors <- Report_set.add x.errors w +let add_error (x : t) (w : report) = x.errors <- Error_set.add x.errors w let add_alert (x : t) (a : alert) = Alerts.register_alert a.category; @@ -173,15 +177,15 @@ let iter_reports (x : t) (f : is_error:bool -> report -> unit) = { loc = w.loc; message = Warnings.message ~as_error:is_error w.kind; - error_code = Error_code.warning (Warnings.number w.kind); + error_code = Error_code_utils.warning (Warnings.number w.kind); }); - Report_set.iter x.errors (fun report -> f ~is_error:true report) + Error_set.iter x.errors (fun report -> f ~is_error:true report) let render_report ~is_error ({ loc; message; error_code } as report) = match !Basic_config.error_format with | Basic_config.Human -> Printf.sprintf "%s [%s] %s\n" (Loc.loc_range_string loc) - (Error_code.to_string error_code) + (Error_code_utils.to_string error_code) message | Basic_config.Json -> Printf.sprintf "%s\n" (Json.to_string (report_to_json ~is_error report)) @@ -190,24 +194,23 @@ let emit_report ~is_error report = output_string stderr (render_report ~is_error report) let emit_errors (x : t) = - iter_reports x (fun ~is_error report -> - if is_error then emit_report ~is_error:true report) + iter_reports x (fun ~is_error -> + fun report -> if is_error then emit_report ~is_error:true report) let check_diagnostics (x : t) = let has_error = ref false in - iter_reports x (fun ~is_error report -> - if is_error then has_error := true; - emit_report ~is_error report); + iter_reports x (fun ~is_error -> + fun report -> + if is_error then has_error := true; + emit_report ~is_error report); if !has_error then raise Fatal_error let reset (x : t) = - x.errors <- Report_set.empty; + x.errors <- Error_set.empty; x.warnings <- Warning_set.empty -type error_option = report option - let merge_into (dst : t) (src : t) = - dst.errors <- Report_set.union dst.errors src.errors; + dst.errors <- Error_set.union dst.errors src.errors; dst.warnings <- Warning_set.union dst.warnings src.warnings let remove_diagnostics_inside_loc (x : t) (loc : Loc.t) = @@ -216,6 +219,6 @@ let remove_diagnostics_inside_loc (x : t) (loc : Loc.t) = (Loc.relation_of_loc loc l = Loc.Includes || Loc.relation_of_loc loc l = Loc.Equal) in - x.errors <- Report_set.filter x.errors (fun e -> not_in_loc e.loc); + x.errors <- Error_set.filter x.errors (fun e -> not_in_loc e.loc); x.warnings <- Warning_set.filter x.warnings (fun w -> not_in_loc w.loc); x.alerts <- Alert_set.filter x.alerts (fun a -> not_in_loc a.loc) diff --git a/src/docstring.ml b/src/docstring.ml index a8b9886..b43d1b4 100644 --- a/src/docstring.ml +++ b/src/docstring.ml @@ -15,6 +15,7 @@ module Comment = Lex_comment module Strutil = Basic_strutil +module Lst = Basic_lst type pragma_prop = Prop_string of string | Prop_atom of string @@ -78,7 +79,8 @@ include struct let _ = fun (_ : t) -> () let sexp_of_t = - (fun { comment = comment__015_; pragmas = pragmas__017_; loc = loc__019_ } -> + (fun { comment = comment__015_; pragmas = pragmas__017_; loc = loc__019_ } + -> let bnds__014_ = ([] : _ Stdlib.List.t) in let bnds__014_ = let arg__020_ = Loc.sexp_of_t loc__019_ in @@ -109,8 +111,9 @@ exception Parse_error of Loc.t * string type state = { doc : string; loc : Loc.t; mutable pos : int } -let peek state : char = - if state.pos < String.length state.doc then state.doc.[state.pos] else '\000' +let peek state = + (if state.pos < String.length state.doc then state.doc.[state.pos] else '\000' + : char) let consume state = if state.pos < String.length state.doc then ( @@ -157,19 +160,20 @@ let parse_pragma_props s = let parse_pragma ~loc str = let s = { doc = str; loc; pos = 0 } in - let rec parse () : (string * pragma_prop list) option = - match peek s with - | ' ' | '\t' -> - skip s; - parse () - | '@' -> ( - skip s; - let pragma_name = parse_ident s in - let peek_s = peek s in - match peek_s with - | ' ' | '\t' | '\000' -> Some (pragma_name, parse_pragma_props s) - | _ -> None) - | _ -> None + let rec parse () = + (match peek s with + | ' ' | '\t' -> + skip s; + parse () + | '@' -> ( + skip s; + let pragma_name = parse_ident s in + let peek_s = peek s in + match peek_s with + | ' ' | '\t' | '\000' -> Some (pragma_name, parse_pragma_props s) + | _ -> None) + | _ -> None + : (string * pragma_prop list) option) in match parse () with | Some (id, props) -> ( @@ -195,11 +199,9 @@ let loc (t : t) = t.loc let of_comments ~diagnostics (comments : Comment.with_loc) = let comments = - List.map - (fun (loc, { Comment.content; _ }) -> + Lst.map comments (fun (loc, { Comment.content; _ }) -> let content = Basic_strutil.drop_while (fun c -> c = '/') content in (loc, content)) - comments in let comments = match comments with @@ -219,25 +221,25 @@ let of_comments ~diagnostics (comments : Comment.with_loc) = | (loc, _) :: _ -> Loc.get_end loc in let pragmas = - let rec aux (acc : 'a list) (comments : (Loc.t * string) list) : pragma list - = - match comments with - | [] -> acc - | (_, line) :: comments when Strutil.trim line = "" -> aux acc comments - | (loc, line) :: comments -> ( - try - match parse_pragma ~loc line with - | None -> acc - | Some x -> aux (x :: acc) comments - with Parse_error (loc, message) -> - Diagnostics.add_warning diagnostics - { kind = Warnings.Unexpected_pragmas message; loc }; - aux acc comments) + let rec aux (acc : 'a list) (comments : (Loc.t * string) list) = + (match comments with + | [] -> acc + | (_, line) :: comments when Strutil.trim line = "" -> aux acc comments + | (loc, line) :: comments -> ( + try + match parse_pragma ~loc line with + | None -> acc + | Some x -> aux (x :: acc) comments + with Parse_error (loc, message) -> + Diagnostics.add_warning diagnostics + { kind = Warnings.Unexpected_pragmas message; loc }; + aux acc comments) + : pragma list) in aux [] comments_rev in { - comment = List.map snd comments; + comment = Lst.map comments snd; pragmas; loc = Loc.of_menhir (startp, endp); } @@ -245,10 +247,8 @@ let of_comments ~diagnostics (comments : Comment.with_loc) = let make ~pragmas ~loc docs = { comment = docs; pragmas; loc } let check_alerts ~diagnostics pragmas loc = - List.iter - (fun pragma -> + Basic_lst.iter pragmas ~f:(fun pragma -> match pragma with | Pragma_alert { category; message } -> Local_diagnostics.add_alert diagnostics { category; message; loc } | _ -> ()) - pragmas diff --git a/src/driver_compenv.ml b/src/driver_compenv.ml index 8bd68b4..4ccc6c6 100644 --- a/src/driver_compenv.ml +++ b/src/driver_compenv.ml @@ -13,6 +13,8 @@ *) +module Lst = Basic_lst + exception SyntaxError of string let cut_at s (c : char) = @@ -28,25 +30,30 @@ let cut_at s (c : char) = raise (SyntaxError (Stdlib.String.concat "" - [ "MOONC_INTERNAL_PARAMS: missing '"; Char.escaped c; "' in "; s ])) + [ "MOONC_INTERNAL_PARAMS: missing '"; Char.escaped c; "' in "; s ] + [@merlin.hide])) let parse_args params = if String.equal params "" then ([], []) else let before, after = cut_at params '|' in let before = - String.split_on_char ',' before - |> List.filter (fun s -> not (String.equal s "")) - |> List.map (fun kv -> - let k, v = cut_at kv '=' in - (String.trim k, String.trim v)) + (fun args -> + Lst.map args (fun kv -> + let k, v = cut_at kv '=' in + (String.trim k, String.trim v))) + (List.filter + (fun s -> not (String.equal s "")) + (String.split_on_char ',' before)) in let after = - String.split_on_char ',' after - |> List.filter (fun s -> not (String.equal s "")) - |> List.map (fun kv -> - let k, v = cut_at kv '=' in - (String.trim k, String.trim v)) + (fun args -> + Lst.map args (fun kv -> + let k, v = cut_at kv '=' in + (String.trim k, String.trim v))) + (List.filter + (fun s -> not (String.equal s "")) + (String.split_on_char ',' after)) in (before, after) @@ -58,9 +65,17 @@ let exec_args (params : (string * string) list) = Driver_config.Common_Opt.wat_plain_mode := true; if String.equal tag "0" then Driver_config.Common_Opt.wat_plain_mode := false - | _ -> () + | "dedup_wasm", tag -> + if String.equal tag "1" then Driver_config.Common_Opt.dedup_wasm := true; + if String.equal tag "0" then + Driver_config.Common_Opt.dedup_wasm := false + | option, _ -> + failwith + (("MOONC_INTERNAL_PARAMS: unknown option '" ^ option ^ "'" + : Stdlib.String.t) + [@merlin.hide]) in - List.iter exec params + Basic_lst.iter params ~f:exec let moonc_internal_params () = match Sys.getenv_opt "MOONC_INTERNAL_PARAMS" with None -> "" | Some s -> s diff --git a/src/driver_config.ml b/src/driver_config.ml index 990808d..b1fc6e7 100644 --- a/src/driver_config.ml +++ b/src/driver_config.ml @@ -22,18 +22,25 @@ module Common_Opt = struct let source_map = ref false let source_map_url = ref "" let debug_tokens = ref false + let debug_segments = ref false let debug_source = ref false let contification = ref true let wasi = ref false let wat_plain_mode = ref false + let dedup_wasm = ref false let quiet = ref false let no_intermediate_file = ref false let enable_coverage = ref false + let enable_value_tracing = ref false let coverage_package_override = ref None let is_main = ref false - let cc = ref "" - let cc_flags = ref "" - let cc_link_flags = ref "" + + type llvm_opt = O0 | O1 | O2 | O3 | Os | Oz + + let llvm_opt = ref O2 + let llvm_target : string option ref = ref None + let emit_text_format = ref false + let emit_llvm_ir = ref false let set_coverage_package_override pkg = if pkg = "@self" then coverage_package_override := Some None @@ -44,6 +51,23 @@ module Common_Opt = struct Arg.Unit Warnings.help_warnings, " show description of warning numbers" ) + let set_llvm_opt s = + llvm_opt := + match s with + | "0" -> O0 + | "1" -> O1 + | "2" -> O2 + | "3" -> O3 + | "s" -> Os + | "z" -> Oz + | _ -> + failwith + "unknown llvm optimization level, should be 0, 1, 2, 3, s or z" + + let set_o0 () = + Config.no_opt := true; + llvm_opt := O0 + let warn_list = ( "-w", Arg.String (fun s -> Warnings.parse_options false s), @@ -65,6 +89,25 @@ module Common_Opt = struct \t@ enable alert and treat it as error\n\ \tIf is 'all', is stands for all alerts\n\ \tdefault setting is " ^ Alerts.default_alerts ) + + let llvm_list = + [ + ( "-llvm-opt", + Arg.String set_llvm_opt, + "set llvm optimization level. available levels: 0, 1, 2, 3, s, z. \ + (LLVM backend only)" ); + ( "-llvm-target", + Arg.String (fun target -> llvm_target := Some target), + "set llvm target triple. unset means current target. (LLVM backend \ + only)" ); + ( "-S", + Arg.Set emit_text_format, + "emit text format of the result instead of binary (LLVM backend only)" + ); + ( "-emit-llvm-ir", + Arg.Set emit_llvm_ir, + "emit LLVM IR or bitcode instead of machine code (LLVM backend only)" ); + ] end module Linkcore_Opt = struct @@ -73,10 +116,12 @@ module Linkcore_Opt = struct let pkg_config_path = ref "" let exported_functions = Basic_hash_string.create 17 let emit_dts = ref true + let stop_on_main = ref false let spec = [ ("-g", Arg.Set Config.debug, "save debugging information"); + ("-O0", Arg.Unit Common_Opt.set_o0, " turn off optimization"); ("-source-map", Arg.Set Common_Opt.source_map, "emit sourcemap"); ( "-source-map-url", Arg.Set_string Common_Opt.source_map_url, @@ -96,12 +141,13 @@ module Linkcore_Opt = struct " output plain style wat" ); ( "-target", Arg.Symbol - ( [ "wasm-gc"; "wasm"; "js"; "riscv" ], + ( [ "wasm-gc"; "wasm"; "js"; "riscv"; "native"; "llvm" ], fun target -> Config.target := Basic_config.parse_target_exn target ), - "set compilation target. available targets: wasm, wasm-gc, js, riscv" + "set compilation target. available targets: wasm-gc, wasm, js, riscv, native, llvm" ); ("-no-dts", Arg.Clear emit_dts, "Do not emit typescript declaration file"); + ("-stop-on-main", Arg.Set stop_on_main, "stop on main function"); ( "-js-format", Arg.Symbol ( [ "esm"; "cjs"; "iife" ], @@ -135,6 +181,15 @@ module Linkcore_Opt = struct ( "-import-memory-name", Arg.String (fun name -> Config.import_memory_name := Some name), "specify the name of the memory to import" ); + ( "-memory-limits-min", + Arg.Int (fun min -> Config.memory_limits_min := Some min), + "specify the minimum size of the memory" ); + ( "-memory-limits-max", + Arg.Int (fun max -> Config.memory_limits_max := Some max), + "specify the maximum size of the memory" ); + ( "-shared-memory", + Arg.Set Config.shared_memory, + "specify the memory to be shared" ); ( "-heap-start-address", Arg.Set_int Config.heap_memory_start, "reserve the memory below the start address" ); @@ -149,13 +204,6 @@ module Linkcore_Opt = struct ( "-leak-check", Arg.Set Config.leak_check, "enable memory leak check for wasm_linear backend" ); - ("-cc", Arg.Set_string Common_Opt.cc, "C compiler for native backend"); - ( "-cc-flags", - Arg.Set_string Common_Opt.cc_flags, - " extra C compiler flags for native backend" ); - ( "-cc-link-flags", - Arg.Set_string Common_Opt.cc_link_flags, - " linker flags for native backend" ); ( "-use-js-builtin-string", Arg.Set Config.use_js_builtin_string, "use js builtin string" ); @@ -163,12 +211,14 @@ module Linkcore_Opt = struct Arg.String (fun path -> pkg_config_path := path), "path to moon.pkg.json" ); ] + @ Common_Opt.llvm_list end module Buildpkg_Opt = struct let mi_files = ref [] let output_file = ref "" let no_mi = ref false + let patch_file = ref "" let blackbox_test = ref false let whitebox_test = ref false @@ -178,6 +228,7 @@ module Buildpkg_Opt = struct Arg.String (fun mi -> mi_files := mi :: !mi_files), "dependent .mi files" ); ("-g", Arg.Set Config.debug, "save debugging information"); + ("-O0", Arg.Set Config.no_opt, " turn off optimization"); ("-source-map", Arg.Set Common_Opt.source_map, "emit sourcemap"); ( "-source-map-url", Arg.Set_string Common_Opt.source_map_url, @@ -188,7 +239,7 @@ module Buildpkg_Opt = struct "output file (suffix with .core by convention)" ); ( "-target", Arg.Symbol - ( [ "wasm-gc"; "wasm"; "js"; "native" ], + ( [ "wasm-gc"; "wasm"; "js"; "native"; "llvm" ], fun target -> Config.target := Basic_config.parse_target_exn target ), "set compilation target. available targets: wasm, wasm-gc, js, native" @@ -207,6 +258,7 @@ module Buildpkg_Opt = struct ( "-enable-coverage", Arg.Set Common_Opt.enable_coverage, " Enable code coverage tracking" ); + ("-enable-value-tracing", Arg.Set Common_Opt.enable_value_tracing, ""); ( "-coverage-package-override", Arg.String Common_Opt.set_coverage_package_override, "Override package name for coverage tracking. use \"@self\" for \ @@ -221,17 +273,18 @@ module Buildpkg_Opt = struct Config.error_format := Basic_config.parse_error_format_exn error_format ), " set format of diagnostics. available formats: human, json" ); + ("-patch-file", Arg.Set_string patch_file, "patch file"); ("-no-mi", Arg.Set no_mi, "don't generate .mi file"); - Common_Opt.warn_help; - Common_Opt.warn_list; - Common_Opt.alert_list; ] + @ Common_Opt.llvm_list + @ [ Common_Opt.warn_help; Common_Opt.warn_list; Common_Opt.alert_list ] end module Check_Opt = struct let mi_files = ref [] let output_file = ref "" let no_mi = ref false + let patch_file = ref "" let blackbox_test = ref false let whitebox_test = ref false @@ -245,7 +298,7 @@ module Check_Opt = struct "output file (suffix with .mi by convention)" ); ( "-target", Arg.Symbol - ( [ "wasm-gc"; "wasm"; "js"; "native" ], + ( [ "wasm-gc"; "wasm"; "js"; "native"; "llvm" ], fun target -> Config.target := Basic_config.parse_target_exn target ), "set compilation target. available targets: wasm, wasm-gc, js, native" @@ -271,6 +324,7 @@ module Check_Opt = struct Config.error_format := Basic_config.parse_error_format_exn error_format ), " set format of diagnostics. available formats: human, json" ); + ("-patch-file", Arg.Set_string patch_file, "patch file"); ("-no-mi", Arg.Set no_mi, "don't generate .mi file"); Common_Opt.warn_help; Common_Opt.warn_list; @@ -286,18 +340,21 @@ module Compile_Opt = struct let emit_dts = ref true let stop_after_parsing = ref false let stop_after_typing = ref false + let stop_on_main = ref false let spec = [ ("-q", Arg.Set Common_Opt.quiet, "quite mode"); ("-verbose", Arg.Set Config.verbose, " verbose mode for debugging"); ("-g", Arg.Set Config.debug, "save debugging information"); + ("-O0", Arg.Set Config.no_opt, " turn off optimization"); ("-dsource", Arg.Set Common_Opt.debug_source, "debug source"); ("-source-map", Arg.Set Common_Opt.source_map, "emit sourcemap"); ( "-source-map-url", Arg.Set_string Common_Opt.source_map_url, "set url of source map" ); ("-no-dts", Arg.Clear emit_dts, "Do not emit typescript declaration file"); + ("-stop-on-main", Arg.Set stop_on_main, "stop on main function"); ( "-o", Arg.Set_string output_file, "output file, suffix with .wat or .wasm" ); @@ -319,7 +376,7 @@ module Compile_Opt = struct ("-no-rc", Arg.Clear Common_Opt.rc, " disable reference counting GC"); ( "-target", Arg.Symbol - ( [ "wasm-gc"; "wasm"; "js"; "native" ], + ( [ "wasm-gc"; "wasm"; "js"; "native"; "llvm" ], fun target -> Config.target := Basic_config.parse_target_exn target ), " set compilation target. available targets: wasm, wasm-gc, js, native" @@ -337,6 +394,11 @@ module Compile_Opt = struct "set js format" ); ("-wasi", Arg.Set Common_Opt.wasi, " compile to WASI"); ("-debug-tokens", Arg.Set Common_Opt.debug_tokens, " debug token stream"); + ("-debug-segments", Arg.Set Common_Opt.debug_segments, " debug segments"); + ( "-parser", + Arg.Symbol (Basic_config.symbols, Basic_config.parse_symbol_exn), + " option to set the parser, default: " + ^ Basic_config.current_parser_display () ); ("-stop-after-parsing", Arg.Set stop_after_parsing, " stop after parsing"); ("-stop-after-typing", Arg.Set stop_after_typing, " stop after typing"); ("-show-loc", Arg.Set Basic_config.show_loc, " show loc in ir"); @@ -346,6 +408,7 @@ module Compile_Opt = struct ( "-enable-coverage", Arg.Set Common_Opt.enable_coverage, " Enable code coverage tracking" ); + ("-enable-value-tracing", Arg.Set Common_Opt.enable_value_tracing, ""); ( "-coverage-package-override", Arg.String Common_Opt.set_coverage_package_override, "Override package name for coverage tracking. use \"@self\" for \ @@ -387,23 +450,21 @@ module Compile_Opt = struct ( "-memory-safety-check", Arg.Set Config.memory_safety_check, "enable memory safety check" ); - ("-cc", Arg.Set_string Common_Opt.cc, "C compiler for native backend"); - ( "-cc-flags", - Arg.Set_string Common_Opt.cc_flags, - " extra C compiler flags for native backend" ); - ( "-cc-link-flags", - Arg.Set_string Common_Opt.cc_link_flags, - " linker flags for native backend" ); ( "-use-js-builtin-string", Arg.Set Config.use_js_builtin_string, "use js builtin string" ); - Common_Opt.warn_help; - Common_Opt.warn_list; - Common_Opt.alert_list; ] + @ Common_Opt.llvm_list + @ [ Common_Opt.warn_help; Common_Opt.warn_list; Common_Opt.alert_list ] end module Gentestinfo_Opt = struct + let patch_file = ref "" let json = ref false - let spec = [ ("-json", Arg.Set json, "output in json format") ] + + let spec = + [ + ("-json", Arg.Set json, "output in json format"); + ("-patch-file", Arg.Set_string patch_file, "patch file"); + ] end diff --git a/src/driver_util.ml b/src/driver_util.ml index f04f233..d7efde4 100644 --- a/src/driver_util.ml +++ b/src/driver_util.ml @@ -13,6 +13,8 @@ *) +module Lst = Basic_lst + let ( |-> ) obj callback = callback obj; obj @@ -25,26 +27,27 @@ type core_passes = | `Core_Lambda_Lift | `Core_Remove_Let_Alias | `Core_Stackalloc - | `Core_Start ] - -type clam1_passes = - [ `Clam1_End - | `Clam1_RC_Drop_Spec - | `Clam1_RC_End - | `Clam1_RC_Insert_Ref - | `Clam1_Start - | `Clam1_Unused_Let ] + | `Core_Unbox_Loop_Params + | `Core_Propagate_Constr + | `Core_Propagate_Constr + | `Core_Start + | `Core_no_async ] type clam_passes = [ `Clam_End | `Clam_Start | `Clam_Unused_Let ] type mbt_input = File_Path of string | Name_Content of string * string -type mi_input = Import_Path of string | Import_Path_Content of string * string -type std_input = Std_Path of string | Std_Content of (string * string) list -type wasm_rep = Wat of W.t list + +type mi_input = Typecheck_driver_util.mi_input = + | Import_Path of string + | Import_Path_Content of string * string + +type std_input = Typecheck_driver_util.std_input = + | Std_Path of string + | Std_Content of (string * string) list type target = | Wasm_gc of { clam_callback : clam_passes -> Clam.prog -> unit; - sexp_callback : W.t list -> unit; + dwarfsm_callback : Dwarfsm_ast.module_ -> unit; } | Riscv of { sexp_callback : Riscv.t list -> unit; @@ -62,185 +65,212 @@ let parse ~diagnostics ~(debug_tokens : bool) (input : mbt_input) : Parsing_parse.impl_of_string ~name ~debug_tokens ~diagnostics ~transform:false content -let postprocess_ast ~diagnostics (output : Parsing_parse.output) : - Parsing_parse.output = - { output with ast = Parsing_ast_lint.post_process ~diagnostics output.ast } +let postprocess_ast ~diagnostics (output : Parsing_parse.output) = + ({ output with ast = Parsing_ast_lint.post_process ~diagnostics output.ast } + : Parsing_parse.output) -let tast_of_ast ~diagnostics ~(build_context : Typeutil.build_context) - ~(imports : mi_input list) ~(quiet : bool) ?(std_import : std_input option) - ~(genv_callback : Global_env.t -> unit) - ~(tast_callback : Typedtree.output -> unit) - ~(pkg_config : Json_types.t option) - ~(import_kind : Pkg_config_util.import_kind) - (asts : Parsing_parse.output list) : Typedtree.output * Global_env.t = - let asts = Basic_lst.map asts (fun a -> a.ast) in - let pkgs = Pkg.create_tbl () in - let import_items = - Pkg_config_util.parse_import_item ~import_kind pkg_config - in - Basic_lst.iter imports (function - | Import_Path_Content (imp_str, mi_content) -> - let imp = Parsing_import_path.parse imp_str in - Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics - | Import_Path imp_str -> - let imp = Parsing_import_path.parse imp_str in - let mi_content = - Stdlib.In_channel.with_open_bin imp.path Stdlib.In_channel.input_all - in - Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics); - (match std_import with - | Some (Std_Content imports) -> - Basic_lst.iter imports (fun (imp_str, mi_content) -> - let imp = Parsing_import_path.parse imp_str in - Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics) - | Some (Std_Path std_path) -> - if std_path <> "" then Pkg.load_std pkgs ~std_path ~diagnostics - | None -> ()); - let top_output = - Toplevel_typer.check_toplevel ~pkgs ~build_context asts ~diagnostics - in - let genv = top_output.global_env |-> genv_callback in - let tast = Typer.type_check top_output ~diagnostics in - if (not quiet) && not (Diagnostics.has_fatal_errors diagnostics) then - Check_match.analyze ~diagnostics (genv, tast); - let tast = Topo_sort.topo_sort tast ~diagnostics |-> tast_callback in - Global_env.report_unused_pkg ~diagnostics genv; - Dead_code.analyze_unused ~diagnostics ~import_items tast; - (tast, genv) +let tast_of_ast = Typecheck_driver_util.tast_of_ast -let core_of_tast ~(debug : bool) ~(contification : bool) ~(genv : Global_env.t) - ~(tast : Typedtree.output) ~core_callback : Core.program = - let pass ~cond ~stage f prog = - if cond then prog |> f |-> core_callback ~global_env:genv stage else prog - in - let prog = Core_of_tast.transl ~global_env:genv tast in - prog - |> pass ~cond:(not debug) ~stage:`Core_Inline_Single_Use_Join - Pass_inline_single_use_join.inline_single_use_join - |-> core_callback ~global_env:genv `Core_Start - |> pass ~cond:contification ~stage:`Core_Contify Pass_contification.contify - |> pass ~cond:(not debug) ~stage:`Core_Remove_Let_Alias - Pass_let_alias.remove_let_alias - |> pass ~cond:(not debug) ~stage:`Core_Stackalloc - Pass_stackalloc.unbox_mut_records - |> pass ~cond:(not debug) ~stage:`Core_Lambda_Lift Lambda_lift.lift_program - |> pass ~cond:(not debug) ~stage:`Core_DCE Core_dce.eliminate_dead_code - |-> core_callback ~global_env:genv `Core_End +let core_of_tast ~(no_opt : bool) ~(contification : bool) ~(genv : Global_env.t) + ~(tast : Typedtree.output) ~core_callback = + (let pass ~cond ~stage f prog = + if cond then f prog |-> core_callback ~global_env:genv stage else prog + in + let prog = Core_of_tast.transl ~global_env:genv tast in + pass ~cond:(not no_opt) ~stage:`Core_DCE Core_dce.eliminate_dead_code + (pass ~cond:(not no_opt) ~stage:`Core_Lambda_Lift Lambda_lift.lift_program + (pass ~cond:(not no_opt) ~stage:`Core_Propagate_Constr + (Pass_propagate_constr.propagate_constr genv) + (pass ~cond:(not no_opt) ~stage:`Core_Unbox_Loop_Params + (Pass_unbox_loop_params.unbox_loop_params genv) + (pass ~cond:(not no_opt) ~stage:`Core_Stackalloc + Pass_stackalloc.unbox_mut_records + (pass ~cond:(not no_opt) ~stage:`Core_Remove_Let_Alias + Pass_let_alias.remove_let_alias + (pass ~cond:contification ~stage:`Core_Contify + Pass_contification.contify + (Eliminate_async.eliminate_async ~global_env:genv + (pass ~cond:(not no_opt) + ~stage:`Core_Inline_Single_Use_Join + Pass_inline_single_use_join.inline_single_use_join + prog + |-> core_callback ~global_env:genv `Core_Start) + |-> core_callback ~global_env:genv `Core_no_async))))))) + |-> core_callback ~global_env:genv `Core_End + : Core.program) + +let apply_patch_add (patches : Patch.t list) (mbt_files : mbt_input list) = + (mbt_files + @ Basic_lst.fold_left patches [] (fun acc -> + fun patch -> + match patch with + | PAdd { name; content } -> Name_Content (name, content) :: acc + | PDrop _ -> acc) + : mbt_input list) + +let apply_patch_drop ~(diagnostics : Diagnostics.t) (patches : Patch.t list) + (ast : Parsing_parse.output) = + (match ast.name with + | "" -> ast + | name -> ( + let patch = + Basic_lst.find_opt patches (fun patch -> + match patch with + | PDrop { file; index = _ } when Filename.basename file = name -> + Some patch + | _ -> None) + in + match patch with + | Some (PDrop { file = _; index }) -> + let loc = Parsing_syntax.loc_of_impl (List.nth ast.ast index) in + Diagnostics.remove_diagnostics_inside_loc diagnostics loc; + { + ast with + ast = List.filteri (fun i -> fun _ -> i <> index) ast.ast; + } + | _ -> ast) + : Parsing_parse.output) + +type process_result = { + mbt_files : mbt_input list; + build_context : Typeutil.build_context; + pkgs : Pkg.pkg_tbl; + import_items : Pkg_config_util.import_items; +} + +let process_config_and_input ~(pkg_config_file : string option) + ~(mbt_files : mbt_input list) ~(is_main : bool) + ~(import_kind : Pkg_config_util.import_kind) ~(imports : mi_input list) + ~(std_import : std_input option) ~(diagnostics : Diagnostics.t) = + (let pkg_config = + match pkg_config_file with + | Some path -> + Some + (Json_parse.parse_json_from_file ~diagnostics + ~fname:(Filename.basename path) path) + | None -> None + in + Pkg_config_util.parse_warn_alert pkg_config; + let build_context : Typeutil.build_context = + match Pkg_config_util.parse_is_main pkg_config with + | Is_main loc -> Exec { is_main_loc = loc } + | Not_main -> + if is_main then Exec { is_main_loc = Loc.no_location } else Lib + in + let pkgs = Pkg.create_tbl () in + let import_items = + Pkg_config_util.parse_import_item ~import_kind pkg_config + in + Basic_lst.iter imports ~f:(function + | Import_Path_Content (imp_str, mi_content) -> + let imp = Parsing_import_path.parse imp_str in + Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics + | Import_Path imp_str -> + let imp = Parsing_import_path.parse imp_str in + let mi_content = + Stdlib.In_channel.with_open_bin imp.path Stdlib.In_channel.input_all + in + Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics); + (match std_import with + | Some (Std_Content imports) -> + Basic_lst.iter imports ~f:(fun (imp_str, mi_content) -> + let imp = Parsing_import_path.parse imp_str in + Pkg.load_mi ~import_items pkgs imp mi_content ~diagnostics) + | Some (Std_Path std_path) -> + if std_path <> "" then Pkg.load_std pkgs ~std_path ~diagnostics + | None -> ()); + { mbt_files; build_context; pkgs; import_items } + : process_result) let check ~diagnostics ?(std_import : std_input option) ~(imports : mi_input list) ~(debug_tokens : bool) ~(is_main : bool) ~(quiet : bool) ~(genv_callback : Global_env.t -> unit) - ~(tast_callback : Typedtree.output -> unit) + ~(tast_callback : Typedtree.output -> unit) ?(patches : Patch.t list = []) ~(pkg_config_file : string option) - ~(import_kind : Pkg_config_util.import_kind) (mbt_files : mbt_input list) : - Typedtree.output * Global_env.t = - let outputs = - mbt_files - |> List.map (fun input -> - let ast = parse ~diagnostics ~debug_tokens input in - postprocess_ast ~diagnostics ast) - in - let pkg_config = - match pkg_config_file with - | Some path -> - Some - (Json_parse.parse_json_from_file ~diagnostics - ~fname:(Filename.basename path) path) - | None -> None - in - Pkg_config_util.parse_warn_alert pkg_config; - let build_context : Typeutil.build_context = - match Pkg_config_util.parse_is_main pkg_config with - | Is_main loc -> Exec { is_main_loc = loc } - | Not_main -> - if is_main then Exec { is_main_loc = Loc.no_location } else Lib - in - tast_of_ast ~diagnostics ~build_context ~imports ~quiet ?std_import - ~genv_callback ~tast_callback ~pkg_config ~import_kind outputs + ~(import_kind : Pkg_config_util.import_kind) (mbt_files : mbt_input list) = + (let { mbt_files; build_context; pkgs; import_items } = + process_config_and_input ~pkg_config_file ~mbt_files ~is_main ~diagnostics + ~import_kind ~imports ~std_import + in + let patched_mbt_files = apply_patch_add patches mbt_files in + let outputs = + Lst.map patched_mbt_files (fun input -> + let ast = parse ~diagnostics ~debug_tokens input in + let ast = apply_patch_drop ~diagnostics patches ast in + postprocess_ast ~diagnostics ast) + in + tast_of_ast ~diagnostics ~build_context ~import_kind ~quiet ~genv_callback + ~tast_callback ~import_items ~pkgs outputs + : Typedtree.output * Global_env.t) let build_package ~diagnostics ?(std_import : std_input option) - ~(imports : mi_input list) ~(debug_tokens : bool) ~(debug : bool) + ~(imports : mi_input list) ~(debug_tokens : bool) ~(no_opt : bool) ~(contification : bool) ~(is_main : bool) ~(quiet : bool) + ~(tracing_callback : Parsing_parse.output list -> Parsing_parse.output list) ~(profile_callback : Parsing_parse.output list -> Parsing_parse.output list) ~(debug_source_callback : string -> Parsing_parse.output -> unit) ~(genv_callback : Global_env.t -> unit) ~(tast_callback : Typedtree.output -> unit) ~core_callback ~(pkg_config_file : string option) - ~(import_kind : Pkg_config_util.import_kind) (mbt_files : mbt_input list) : - Core.program = - let asts = - mbt_files - |> List.map (parse ~diagnostics ~debug_tokens) - |> profile_callback - |> List.map (postprocess_ast ~diagnostics) - in - let pkg_config = - match pkg_config_file with - | Some path -> - Some - (Json_parse.parse_json_from_file ~diagnostics - ~fname:(Filename.basename path) path) - | None -> None - in - Pkg_config_util.parse_warn_alert pkg_config; - let build_context : Typeutil.build_context = - match Pkg_config_util.parse_is_main pkg_config with - | Is_main loc -> Exec { is_main_loc = loc } - | Not_main -> - if is_main then Exec { is_main_loc = Loc.no_location } else Lib - in - Basic_lst.iter2 mbt_files asts (fun mbt_file ast -> - match mbt_file with - | Name_Content _ -> () - | File_Path path -> debug_source_callback path ast); - ( asts - |> tast_of_ast ~diagnostics ~build_context ~imports ~quiet ?std_import - ~genv_callback ~tast_callback ~pkg_config ~import_kind - |-> fun _ -> Diagnostics.check_diagnostics diagnostics ) - |> fun (tast, genv) -> - core_of_tast ~debug ~contification ~genv ~tast ~core_callback + ~(import_kind : Pkg_config_util.import_kind) ?(patches : Patch.t list = []) + (mbt_files : mbt_input list) = + (let { mbt_files; build_context; pkgs; import_items } = + process_config_and_input ~pkg_config_file ~mbt_files ~is_main ~diagnostics + ~import_kind ~imports ~std_import + in + let mbt_files = apply_patch_add patches mbt_files in + let asts = + (fun xs -> + (fun xs -> + (fun xs -> Lst.map xs (postprocess_ast ~diagnostics)) + (profile_callback + (tracing_callback + (Lst.map xs (apply_patch_drop ~diagnostics patches))))) + (Lst.map xs (parse ~diagnostics ~debug_tokens))) + mbt_files + in + Basic_lst.iter2 mbt_files asts (fun mbt_file -> + fun ast -> + match mbt_file with + | Name_Content _ -> () + | File_Path path -> debug_source_callback path ast); + (fun (tast, genv) -> + core_of_tast ~no_opt ~contification ~genv ~tast ~core_callback) + ( tast_of_ast ~diagnostics ~build_context ~import_kind ~import_items ~pkgs + ~quiet ~genv_callback ~tast_callback asts + |-> fun _ -> Diagnostics.check_diagnostics diagnostics ) + : Core.program) type core_input = Core_Path of string | Core_Content of string -let monofy_core_link ~(link_output : Core_link.output) ~exported_functions : - Mcore.t = - let monofy_env = - Monofy_env.make ~regular_methods:link_output.methods - ~extension_methods:link_output.ext_methods - in - let mono_core = - Monofy.monofy ~monofy_env ~stype_defs:link_output.types ~exported_functions - link_output.linked_program - in - let mono_core = Pass_layout.optimize_layout mono_core in - mono_core +let monofy_core_link ~(link_output : Core_link.output) ~exported_functions = + (let monofy_env = + Monofy_env.make ~regular_methods:link_output.methods + ~extension_methods:link_output.ext_methods + in + let mono_core = + Monofy.monofy ~monofy_env ~stype_defs:link_output.types ~exported_functions + link_output.linked_program + in + let mono_core = Pass_layout.optimize_layout mono_core in + mono_core + : Mcore.t) -let clam1_of_mcore ~(elim_unused_let : bool) (core : Mcore.t) ~clam1_callback : - Clam1.prog = - let pass ~cond ~stage f prog = - if cond then prog |> f |-> clam1_callback stage else prog - in - core |> Clam1_of_core.transl_prog - |-> clam1_callback `Clam1_Start - |> pass ~cond:elim_unused_let ~stage:`Clam1_Unused_Let - Pass_unused_let1.unused_let_opt - |-> clam1_callback `Clam1_End +let clam_of_mcore ~(elim_unused_let : bool) (core : Mcore.t) ~clam_callback = + (let pass ~cond ~stage f prog = + if cond then f prog |-> clam_callback stage else prog + in + pass ~cond:elim_unused_let ~stage:`Clam_Unused_Let + Pass_unused_let.unused_let_opt + (Clam_of_core.transl_prog core |-> clam_callback `Clam_Start) + |-> clam_callback `Clam_End + : Clam.prog) -let clam_of_mcore ~(elim_unused_let : bool) (core : Mcore.t) ~clam_callback : - Clam.prog = - let pass ~cond ~stage f prog = - if cond then prog |> f |-> clam_callback stage else prog - in - core |> Clam_of_core.transl_prog |-> clam_callback `Clam_Start - |> pass ~cond:elim_unused_let ~stage:`Clam_Unused_Let - Pass_unused_let.unused_let_opt - |-> clam_callback `Clam_End - -let wasm_gen ~(elim_unused_let : bool) (core : Mcore.t) ~clam_callback = - core - |> clam_of_mcore ~elim_unused_let ~clam_callback - |> Wasm_of_clam_gc.compile - |> fun sexp -> Wat sexp +let wasm_gen ~(elim_unused_let : bool) (core : Mcore.t) ~(target : target) = + match target with + | Wasm_gc { clam_callback; _ } -> + Wasm_of_clam_gc.compile + (clam_of_mcore ~elim_unused_let ~clam_callback core) let riscv_gen (core : Mcore.t) = core @@ -252,8 +282,7 @@ let riscv_gen (core : Mcore.t) = let link_core ~(shrink_wasm : bool) ~(elim_unused_let : bool) ~(core_inputs : core_input Basic_vec.t) - ~(exported_functions : string Basic_hash_string.t) ~(target : target) : unit - = + ~(exported_functions : string Basic_hash_string.t) ~(target : target) = let targets : Core_link.linking_target Basic_vec.t = Basic_vec.empty () in Basic_vec.iter (function | Core_Path path -> Basic_vec.push targets (Core_link.File_path path) @@ -267,25 +296,26 @@ let link_core ~(shrink_wasm : bool) ~(elim_unused_let : bool) (Exported_functions.Export_selected exported_functions) in match target with - | Wasm_gc { sexp_callback; clam_callback } -> ( - let mod_and_callback = mono_core |> wasm_gen ~elim_unused_let ~clam_callback in - match mod_and_callback with - | Wat sexp -> - (if shrink_wasm then Pass_shrink_wasm.shrink sexp else sexp) - |> sexp_callback) + | Wasm_gc { clam_callback; dwarfsm_callback } -> + (* Hybrid approach: use both callback systems *) + let mod_ = wasm_gen ~elim_unused_let ~target mono_core in + dwarfsm_callback (if shrink_wasm then Shrink_wasmir.shrink mod_ else mod_) | Riscv { sexp_callback; _ } -> riscv_gen mono_core |> sexp_callback let gen_test_info ~(diagnostics : Diagnostics.t) ~(json : bool) - (mbt_files : mbt_input list) : string = - let parse_and_patch mbt_file = - let ast = parse ~diagnostics ~debug_tokens:false mbt_file in - ast - in - let inputs = - Basic_lst.map mbt_files (fun mbt_file -> - match mbt_file with - | File_Path path -> (path, (parse_and_patch mbt_file).ast) - | Name_Content (name, _) -> (name, (parse_and_patch mbt_file).ast)) - in - if json then Gen_test_info.gen_test_info_json inputs - else Gen_test_info.gen_test_info inputs + ?(patches : Patch.t list = []) (mbt_files : mbt_input list) = + (let parse_and_patch mbt_file = + let ast = parse ~diagnostics ~debug_tokens:false mbt_file in + let ast = apply_patch_drop ~diagnostics patches ast in + ast + in + let mbt_files = apply_patch_add patches mbt_files in + let inputs = + Basic_lst.map mbt_files (fun mbt_file -> + match mbt_file with + | File_Path path -> (path, (parse_and_patch mbt_file).ast) + | Name_Content (name, _) -> (name, (parse_and_patch mbt_file).ast)) + in + if json then Gen_test_info.gen_test_info_json inputs + else Gen_test_info.gen_test_info inputs + : string) diff --git a/src/dune b/src/dune index 9027933..cb8cc89 100644 --- a/src/dune +++ b/src/dune @@ -1,12 +1,12 @@ ; -; Copyright (C) 2024 International Digital Economy -; Academy This program is licensed under the MoonBit Public Source +; Copyright (C) 2024 International Digital Economy Academy. +; This program is licensed under the MoonBit Public Source ; License as published by the International Digital Economy Academy, ; either version 1 of the License, or (at your option) any later -; version. This program is distributed in the hope that it will be +; version. This program is distributed in the hope that it will be ; useful, but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit -; Public Source License for more details. You should have received a +; Public Source License for more details. You should have received a ; copy of the MoonBit Public Source License along with this program. If ; not, see ; . @@ -20,6 +20,7 @@ (executables (names moon0_main) (public_names moonc) + (libraries unix str) (foreign_stubs (language c) (names hash))) diff --git a/src/dwarf_basic.ml b/src/dwarf_basic.ml deleted file mode 100644 index fa478f9..0000000 --- a/src/dwarf_basic.ml +++ /dev/null @@ -1,63 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Byteseq = Basic_byteseq - -let ( ^^ ) = Byteseq.O.( ^^ ) - -let int_uleb128 = Basic_encoders.int_uleb128 -and byte = Basic_encoders.byte -and int_32_le = Basic_encoders.int_32_le -and with_length_preceded = Basic_encoders.with_length_preceded - -let dw_form_string = Dwarf_consts.dw_form_string -and dw_form_udata = Dwarf_consts.dw_form_udata -and dw_form_sec_offset = Dwarf_consts.dw_form_sec_offset -and dw_form_exprloc = Dwarf_consts.dw_form_exprloc -and dw_form_ref4 = Dwarf_consts.dw_form_ref4 - -type relocatable_pc = int ref * int -type relative_offset = Byteseq.marker * Byteseq.marker - -type attr_value = - | String of string - | Unsigned of int - | SecOffset of int - | Exprloc of Byteseq.t - | Reference of relative_offset - -let attr_form_of_value value = - match value with - | String _ -> dw_form_string - | Unsigned _ -> dw_form_udata - | SecOffset _ -> dw_form_sec_offset - | Exprloc _ -> dw_form_exprloc - | Reference _ -> dw_form_ref4 - -let attr_value = function - | Unsigned x -> int_uleb128 x - | SecOffset x -> int_32_le x - | String x -> Byteseq.of_string x ^^ byte 0x00 - | Exprloc e -> with_length_preceded ~f:int_uleb128 e - | Reference (base, target) -> - Byteseq.deferred 4 (fun _ -> - int_32_le - (Byteseq.get_transitive_offset target - - Byteseq.get_transitive_offset base) - |> Byteseq.to_string) - -let absolute_pc_of ((base, offset) : relocatable_pc) = base.contents + offset -let list l f = Basic_lst.fold_left l Byteseq.empty (fun t x -> t ^^ f x) -let count_list l f = int_uleb128 (List.length l) ^^ list l f diff --git a/src/dwarf_consts.ml b/src/dwarf_consts.ml deleted file mode 100644 index f934e3d..0000000 --- a/src/dwarf_consts.ml +++ /dev/null @@ -1,55 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -let dw_lns_copy = 0x01 -let dw_lns_advance_pc = 0x02 -let dw_lns_advance_line = 0x03 -let dw_lns_set_file = 0x04 -let dw_lns_set_column = 0x05 -let dw_lns_negate_stmt = 0x06 -let dw_lns_set_prologue_end = 0x0a -let dw_lne_end_sequence = 0x01 -let dw_lnct_path = 0x1 -let dw_form_string = 0x08 -let dw_form_udata = 0x0f -let dw_form_ref4 = 0x13 -let dw_form_sec_offset = 0x17 -let dw_form_exprloc = 0x18 -let dw_children_yes = 0x01 -let dw_children_no = 0x00 -let dw_tag_enumeration_type = 0x04 -let dw_tag_formal_parameter = 0x05 -let dw_tag_compile_unit = 0x11 -let dw_tag_base_type = 0x24 -let dw_tag_enumerator = 0x28 -let dw_tag_subprogram = 0x2e -let dw_tag_variable = 0x34 -let dw_at_location = 0x02 -let dw_at_name = 0x03 -let dw_at_byte_size = 0x0b -let dw_at_stmt_list = 0x10 -let dw_at_low_pc = 0x11 -let dw_at_high_pc = 0x12 -let dw_at_comp_dir = 0x1b -let dw_at_const_value = 0x1c -let dw_at_encoding = 0x3e -let dw_at_type = 0x49 -let dw_ut_compile = 0x01 -let dw_op_stack_value = 0x9f -let dw_op_wasm_location = 0xed -let dw_ate_float = 0x04 -let dw_ate_signed = 0x05 -let dw_ate_unsigned = 0x07 -let dw_ate_utf = 0x10 diff --git a/src/dwarfsm_ast.ml b/src/dwarfsm_ast.ml index 4dbfa1b..80bd179 100644 --- a/src/dwarfsm_ast.ml +++ b/src/dwarfsm_ast.ml @@ -15,24 +15,265 @@ module Itype = Dwarfsm_itype -type var = { var_name : string option; mutable index : int } -type index = var type binder = { id : string option; mutable index : int } -type label = binder -type typeidx = index -type funcidx = index -type tableidx = index -type memidx = index -type globalidx = index -type elemidx = index -type dataidx = index -type localidx = index -type labelidx = index -type fieldidx = index -type tagidx = index + +type var = + | Unresolve of string + | Resolved of { var_name : string; [@ceh.ignore] index : int } + +include struct + let _ = fun (_ : var) -> () + + let equal_var = + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then true + else + match (a__001_, b__002_) with + | Unresolve _a__003_, Unresolve _b__004_ -> + Stdlib.( = ) (_a__003_ : string) _b__004_ + | Unresolve _, _ -> false + | _, Unresolve _ -> false + | Resolved _a__005_, Resolved _b__006_ -> + Stdlib.( = ) (_a__005_.index : int) _b__006_.index + : var -> var -> bool) + + let _ = equal_var + + let (hash_fold_var : Ppx_base.state -> var -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Unresolve _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + Ppx_base.hash_fold_string hsv _a0 + | Resolved _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = hsv in + hsv + in + Ppx_base.hash_fold_int hsv _ir.index + : Ppx_base.state -> var -> Ppx_base.state) + + let _ = hash_fold_var + + let (hash_var : var -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_var hsv arg) + in + fun x -> func x + + let _ = hash_var +end + +type label = string option +type typeidx = { mutable var : var } + +include struct + let _ = fun (_ : typeidx) -> () + + let equal_typeidx = + (fun a__007_ -> + fun b__008_ -> + if Stdlib.( == ) a__007_ b__008_ then true + else equal_var a__007_.var b__008_.var + : typeidx -> typeidx -> bool) + + let _ = equal_typeidx +end + +type funcidx = { mutable var : var } + +include struct + let _ = fun (_ : funcidx) -> () + + let equal_funcidx = + (fun a__009_ -> + fun b__010_ -> + if Stdlib.( == ) a__009_ b__010_ then true + else equal_var a__009_.var b__010_.var + : funcidx -> funcidx -> bool) + + let _ = equal_funcidx +end + +type tableidx = { mutable var : var } + +include struct + let _ = fun (_ : tableidx) -> () + + let equal_tableidx = + (fun a__011_ -> + fun b__012_ -> + if Stdlib.( == ) a__011_ b__012_ then true + else equal_var a__011_.var b__012_.var + : tableidx -> tableidx -> bool) + + let _ = equal_tableidx +end + +type memidx = { mutable var : var } + +include struct + let _ = fun (_ : memidx) -> () + + let equal_memidx = + (fun a__013_ -> + fun b__014_ -> + if Stdlib.( == ) a__013_ b__014_ then true + else equal_var a__013_.var b__014_.var + : memidx -> memidx -> bool) + + let _ = equal_memidx +end + +type globalidx = { mutable var : var } + +include struct + let _ = fun (_ : globalidx) -> () + + let equal_globalidx = + (fun a__015_ -> + fun b__016_ -> + if Stdlib.( == ) a__015_ b__016_ then true + else equal_var a__015_.var b__016_.var + : globalidx -> globalidx -> bool) + + let _ = equal_globalidx +end + +type dataidx = { mutable var : var } + +include struct + let _ = fun (_ : dataidx) -> () + + let equal_dataidx = + (fun a__017_ -> + fun b__018_ -> + if Stdlib.( == ) a__017_ b__018_ then true + else equal_var a__017_.var b__018_.var + : dataidx -> dataidx -> bool) + + let _ = equal_dataidx +end + +type localidx = { mutable var : var } + +include struct + let _ = fun (_ : localidx) -> () + + let equal_localidx = + (fun a__019_ -> + fun b__020_ -> + if Stdlib.( == ) a__019_ b__020_ then true + else equal_var a__019_.var b__020_.var + : localidx -> localidx -> bool) + + let _ = equal_localidx +end + +type labelidx = { mutable var : var } + +include struct + let _ = fun (_ : labelidx) -> () + + let equal_labelidx = + (fun a__021_ -> + fun b__022_ -> + if Stdlib.( == ) a__021_ b__022_ then true + else equal_var a__021_.var b__022_.var + : labelidx -> labelidx -> bool) + + let _ = equal_labelidx +end + +type fieldidx = { mutable var : var } + +include struct + let _ = fun (_ : fieldidx) -> () + + let equal_fieldidx = + (fun a__023_ -> + fun b__024_ -> + if Stdlib.( == ) a__023_ b__024_ then true + else equal_var a__023_.var b__024_.var + : fieldidx -> fieldidx -> bool) + + let _ = equal_fieldidx +end + +type tagidx = { mutable var : var } + +include struct + let _ = fun (_ : tagidx) -> () + + let equal_tagidx = + (fun a__025_ -> + fun b__026_ -> + if Stdlib.( == ) a__025_ b__026_ then true + else equal_var a__025_.var b__026_.var + : tagidx -> tagidx -> bool) + + let _ = equal_tagidx +end + +let hash_fold_typeidx state (i : typeidx) = hash_fold_var state i.var + type numtype = I32 | I64 | F32 | F64 + +include struct + let _ = fun (_ : numtype) -> () + let equal_numtype = (Stdlib.( = ) : numtype -> numtype -> bool) + let _ = equal_numtype + + let (hash_fold_numtype : Ppx_base.state -> numtype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv + (match arg with I32 -> 0 | I64 -> 1 | F32 -> 2 | F64 -> 3) + : Ppx_base.state -> numtype -> Ppx_base.state) + + let _ = hash_fold_numtype + + let (hash_numtype : numtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_numtype hsv arg) + in + fun x -> func x + + let _ = hash_numtype +end + type vectype = V128 +include struct + let _ = fun (_ : vectype) -> () + let equal_vectype = (Stdlib.( = ) : vectype -> vectype -> bool) + let _ = equal_vectype + + let (hash_fold_vectype : Ppx_base.state -> vectype -> Ppx_base.state) = + (fun hsv -> fun arg -> match arg with V128 -> hsv + : Ppx_base.state -> vectype -> Ppx_base.state) + + let _ = hash_fold_vectype + + let (hash_vectype : vectype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_vectype hsv arg) + in + fun x -> func x + + let _ = hash_vectype +end + type absheaptype = | Any | Eq @@ -45,39 +286,721 @@ type absheaptype = | Extern | NoExtern +include struct + let _ = fun (_ : absheaptype) -> () + let equal_absheaptype = (Stdlib.( = ) : absheaptype -> absheaptype -> bool) + let _ = equal_absheaptype + + let (hash_fold_absheaptype : Ppx_base.state -> absheaptype -> Ppx_base.state) + = + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv + (match arg with + | Any -> 0 + | Eq -> 1 + | I31 -> 2 + | Struct -> 3 + | Array -> 4 + | None -> 5 + | Func -> 6 + | NoFunc -> 7 + | Extern -> 8 + | NoExtern -> 9) + : Ppx_base.state -> absheaptype -> Ppx_base.state) + + let _ = hash_fold_absheaptype + + let (hash_absheaptype : absheaptype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_absheaptype hsv arg) + in + fun x -> func x + + let _ = hash_absheaptype +end + type heaptype = Type of typeidx | Absheaptype of absheaptype + +include struct + let _ = fun (_ : heaptype) -> () + + let equal_heaptype = + (fun a__033_ -> + fun b__034_ -> + if Stdlib.( == ) a__033_ b__034_ then true + else + match (a__033_, b__034_) with + | Type _a__035_, Type _b__036_ -> equal_typeidx _a__035_ _b__036_ + | Type _, _ -> false + | _, Type _ -> false + | Absheaptype _a__037_, Absheaptype _b__038_ -> + equal_absheaptype _a__037_ _b__038_ + : heaptype -> heaptype -> bool) + + let _ = equal_heaptype + + let (hash_fold_heaptype : Ppx_base.state -> heaptype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Type _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hash_fold_typeidx hsv _a0 + | Absheaptype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_absheaptype hsv _a0 + : Ppx_base.state -> heaptype -> Ppx_base.state) + + let _ = hash_fold_heaptype + + let (hash_heaptype : heaptype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_heaptype hsv arg) + in + fun x -> func x + + let _ = hash_heaptype +end + type null = Nullable | NonNull + +include struct + let _ = fun (_ : null) -> () + let equal_null = (Stdlib.( = ) : null -> null -> bool) + let _ = equal_null + + let (hash_fold_null : Ppx_base.state -> null -> Ppx_base.state) = + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv + (match arg with Nullable -> 0 | NonNull -> 1) + : Ppx_base.state -> null -> Ppx_base.state) + + let _ = hash_fold_null + + let (hash_null : null -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_null hsv arg) + in + fun x -> func x + + let _ = hash_null +end + type reftype = Ref of null * heaptype + +include struct + let _ = fun (_ : reftype) -> () + + let equal_reftype = + (fun a__041_ -> + fun b__042_ -> + if Stdlib.( == ) a__041_ b__042_ then true + else + match (a__041_, b__042_) with + | Ref (_a__043_, _a__045_), Ref (_b__044_, _b__046_) -> + Stdlib.( && ) + (equal_null _a__043_ _b__044_) + (equal_heaptype _a__045_ _b__046_) + : reftype -> reftype -> bool) + + let _ = equal_reftype + + let (hash_fold_reftype : Ppx_base.state -> reftype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Ref (_a0, _a1) -> + let hsv = hsv in + let hsv = + let hsv = hsv in + hash_fold_null hsv _a0 + in + hash_fold_heaptype hsv _a1 + : Ppx_base.state -> reftype -> Ppx_base.state) + + let _ = hash_fold_reftype + + let (hash_reftype : reftype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_reftype hsv arg) + in + fun x -> func x + + let _ = hash_reftype +end + type valtype = Numtype of numtype | Vectype of vectype | Reftype of reftype +include struct + let _ = fun (_ : valtype) -> () + + let equal_valtype = + (fun a__047_ -> + fun b__048_ -> + if Stdlib.( == ) a__047_ b__048_ then true + else + match (a__047_, b__048_) with + | Numtype _a__049_, Numtype _b__050_ -> + equal_numtype _a__049_ _b__050_ + | Numtype _, _ -> false + | _, Numtype _ -> false + | Vectype _a__051_, Vectype _b__052_ -> + equal_vectype _a__051_ _b__052_ + | Vectype _, _ -> false + | _, Vectype _ -> false + | Reftype _a__053_, Reftype _b__054_ -> + equal_reftype _a__053_ _b__054_ + : valtype -> valtype -> bool) + + let _ = equal_valtype + + let (hash_fold_valtype : Ppx_base.state -> valtype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Numtype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hash_fold_numtype hsv _a0 + | Vectype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_vectype hsv _a0 + | Reftype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = hsv in + hash_fold_reftype hsv _a0 + : Ppx_base.state -> valtype -> Ppx_base.state) + + let _ = hash_fold_valtype + + let (hash_valtype : valtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_valtype hsv arg) + in + fun x -> func x + + let _ = hash_valtype +end + type local = { - id : binder; - source_name : string option; + id : binder; [@ceh.ignore] + source_name : string option; [@ceh.ignore] type_ : valtype; - source_type : Itype.t option; + source_type : Itype.t option; [@ceh.ignore] } +include struct + let _ = fun (_ : local) -> () + + let equal_local = + (fun a__055_ -> + fun b__056_ -> + if Stdlib.( == ) a__055_ b__056_ then true + else equal_valtype a__055_.type_ b__056_.type_ + : local -> local -> bool) + + let _ = equal_local + + let (hash_fold_local : Ppx_base.state -> local -> Ppx_base.state) = + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = + let hsv = hsv in + hsv + in + hsv + in + hash_fold_valtype hsv arg.type_ + in + hsv + + let _ = hash_fold_local + + let (hash_local : local -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_local hsv arg) + in + fun x -> func x + + let _ = hash_local +end + type param = local + +include struct + let _ = fun (_ : param) -> () + let equal_param = (equal_local : param -> param -> bool) + let _ = equal_param + + let (hash_fold_param : Ppx_base.state -> param -> Ppx_base.state) = + hash_fold_local + + and (hash_param : param -> Ppx_base.hash_value) = + let func = hash_local in + fun x -> func x + + let _ = hash_fold_param + and _ = hash_param +end + type result = valtype + +include struct + let _ = fun (_ : result) -> () + let equal_result = (equal_valtype : result -> result -> bool) + let _ = equal_result + + let (hash_fold_result : Ppx_base.state -> result -> Ppx_base.state) = + hash_fold_valtype + + and (hash_result : result -> Ppx_base.hash_value) = + let func = hash_valtype in + fun x -> func x + + let _ = hash_fold_result + and _ = hash_result +end + type functype = Func of param list * result list + +include struct + let _ = fun (_ : functype) -> () + + let equal_functype = + (fun a__061_ -> + fun b__062_ -> + if Stdlib.( == ) a__061_ b__062_ then true + else + match (a__061_, b__062_) with + | Func (_a__063_, _a__065_), Func (_b__064_, _b__066_) -> + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__067_ -> + fun (b__068_ [@merlin.hide]) -> + (equal_param a__067_ b__068_ [@merlin.hide])) + _a__063_ _b__064_) + (Ppx_base.equal_list + (fun a__069_ -> + fun (b__070_ [@merlin.hide]) -> + (equal_result a__069_ b__070_ [@merlin.hide])) + _a__065_ _b__066_) + : functype -> functype -> bool) + + let _ = equal_functype + + let (hash_fold_functype : Ppx_base.state -> functype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Func (_a0, _a1) -> + let hsv = hsv in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_list hash_fold_param hsv _a0 + in + Ppx_base.hash_fold_list hash_fold_result hsv _a1 + : Ppx_base.state -> functype -> Ppx_base.state) + + let _ = hash_fold_functype + + let (hash_functype : functype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_functype hsv arg) + in + fun x -> func x + + let _ = hash_functype +end + type packedtype = I8 | I16 + +include struct + let _ = fun (_ : packedtype) -> () + let equal_packedtype = (Stdlib.( = ) : packedtype -> packedtype -> bool) + let _ = equal_packedtype + + let (hash_fold_packedtype : Ppx_base.state -> packedtype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv (match arg with I8 -> 0 | I16 -> 1) + : Ppx_base.state -> packedtype -> Ppx_base.state) + + let _ = hash_fold_packedtype + + let (hash_packedtype : packedtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_packedtype hsv arg) + in + fun x -> func x + + let _ = hash_packedtype +end + type storagetype = Valtype of valtype | Packedtype of packedtype + +include struct + let _ = fun (_ : storagetype) -> () + + let equal_storagetype = + (fun a__073_ -> + fun b__074_ -> + if Stdlib.( == ) a__073_ b__074_ then true + else + match (a__073_, b__074_) with + | Valtype _a__075_, Valtype _b__076_ -> + equal_valtype _a__075_ _b__076_ + | Valtype _, _ -> false + | _, Valtype _ -> false + | Packedtype _a__077_, Packedtype _b__078_ -> + equal_packedtype _a__077_ _b__078_ + : storagetype -> storagetype -> bool) + + let _ = equal_storagetype + + let (hash_fold_storagetype : Ppx_base.state -> storagetype -> Ppx_base.state) + = + (fun hsv -> + fun arg -> + match arg with + | Valtype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hash_fold_valtype hsv _a0 + | Packedtype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_packedtype hsv _a0 + : Ppx_base.state -> storagetype -> Ppx_base.state) + + let _ = hash_fold_storagetype + + let (hash_storagetype : storagetype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_storagetype hsv arg) + in + fun x -> func x + + let _ = hash_storagetype +end + type mut = Const | Var + +include struct + let _ = fun (_ : mut) -> () + let equal_mut = (Stdlib.( = ) : mut -> mut -> bool) + let _ = equal_mut + + let (hash_fold_mut : Ppx_base.state -> mut -> Ppx_base.state) = + (fun hsv -> + fun arg -> + Ppx_base.hash_fold_int hsv (match arg with Const -> 0 | Var -> 1) + : Ppx_base.state -> mut -> Ppx_base.state) + + let _ = hash_fold_mut + + let (hash_mut : mut -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_mut hsv arg) + in + fun x -> func x + + let _ = hash_mut +end + type fieldtype = { mut : mut; type_ : storagetype } -type field = binder * fieldtype + +include struct + let _ = fun (_ : fieldtype) -> () + + let equal_fieldtype = + (fun a__081_ -> + fun b__082_ -> + if Stdlib.( == ) a__081_ b__082_ then true + else + Stdlib.( && ) + (equal_mut a__081_.mut b__082_.mut) + (equal_storagetype a__081_.type_ b__082_.type_) + : fieldtype -> fieldtype -> bool) + + let _ = equal_fieldtype + + let (hash_fold_fieldtype : Ppx_base.state -> fieldtype -> Ppx_base.state) = + fun hsv -> + fun arg -> + let hsv = + let hsv = hsv in + hash_fold_mut hsv arg.mut + in + hash_fold_storagetype hsv arg.type_ + + let _ = hash_fold_fieldtype + + let (hash_fieldtype : fieldtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_fieldtype hsv arg) + in + fun x -> func x + + let _ = hash_fieldtype +end + +type field = { id : binder; [@ceh.ignore] fieldtype : fieldtype } + +include struct + let _ = fun (_ : field) -> () + + let equal_field = + (fun a__083_ -> + fun b__084_ -> + if Stdlib.( == ) a__083_ b__084_ then true + else equal_fieldtype a__083_.fieldtype b__084_.fieldtype + : field -> field -> bool) + + let _ = equal_field + + let (hash_fold_field : Ppx_base.state -> field -> Ppx_base.state) = + fun hsv -> + fun arg -> + let hsv = + let hsv = hsv in + hsv + in + hash_fold_fieldtype hsv arg.fieldtype + + let _ = hash_fold_field + + let (hash_field : field -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_field hsv arg) + in + fun x -> func x + + let _ = hash_field +end + type arraytype = Array of fieldtype + +include struct + let _ = fun (_ : arraytype) -> () + + let equal_arraytype = + (fun a__085_ -> + fun b__086_ -> + if Stdlib.( == ) a__085_ b__086_ then true + else + match (a__085_, b__086_) with + | Array _a__087_, Array _b__088_ -> equal_fieldtype _a__087_ _b__088_ + : arraytype -> arraytype -> bool) + + let _ = equal_arraytype + + let (hash_fold_arraytype : Ppx_base.state -> arraytype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Array _a0 -> + let hsv = hsv in + let hsv = hsv in + hash_fold_fieldtype hsv _a0 + : Ppx_base.state -> arraytype -> Ppx_base.state) + + let _ = hash_fold_arraytype + + let (hash_arraytype : arraytype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_arraytype hsv arg) + in + fun x -> func x + + let _ = hash_arraytype +end + type structtype = Struct of field list +include struct + let _ = fun (_ : structtype) -> () + + let equal_structtype = + (fun a__089_ -> + fun b__090_ -> + if Stdlib.( == ) a__089_ b__090_ then true + else + match (a__089_, b__090_) with + | Struct _a__091_, Struct _b__092_ -> + Ppx_base.equal_list + (fun a__093_ -> + fun (b__094_ [@merlin.hide]) -> + (equal_field a__093_ b__094_ [@merlin.hide])) + _a__091_ _b__092_ + : structtype -> structtype -> bool) + + let _ = equal_structtype + + let (hash_fold_structtype : Ppx_base.state -> structtype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Struct _a0 -> + let hsv = hsv in + let hsv = hsv in + Ppx_base.hash_fold_list hash_fold_field hsv _a0 + : Ppx_base.state -> structtype -> Ppx_base.state) + + let _ = hash_fold_structtype + + let (hash_structtype : structtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_structtype hsv arg) + in + fun x -> func x + + let _ = hash_structtype +end + type comptype = | Arraytype of arraytype | Structtype of structtype | Functype of functype +include struct + let _ = fun (_ : comptype) -> () + + let equal_comptype = + (fun a__095_ -> + fun b__096_ -> + if Stdlib.( == ) a__095_ b__096_ then true + else + match (a__095_, b__096_) with + | Arraytype _a__097_, Arraytype _b__098_ -> + equal_arraytype _a__097_ _b__098_ + | Arraytype _, _ -> false + | _, Arraytype _ -> false + | Structtype _a__099_, Structtype _b__100_ -> + equal_structtype _a__099_ _b__100_ + | Structtype _, _ -> false + | _, Structtype _ -> false + | Functype _a__101_, Functype _b__102_ -> + equal_functype _a__101_ _b__102_ + : comptype -> comptype -> bool) + + let _ = equal_comptype + + let (hash_fold_comptype : Ppx_base.state -> comptype -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Arraytype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hash_fold_arraytype hsv _a0 + | Structtype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_structtype hsv _a0 + | Functype _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = hsv in + hash_fold_functype hsv _a0 + : Ppx_base.state -> comptype -> Ppx_base.state) + + let _ = hash_fold_comptype + + let (hash_comptype : comptype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_comptype hsv arg) + in + fun x -> func x + + let _ = hash_comptype +end + type subtype = { final : bool; super : typeidx list; type_ : comptype } + +include struct + let _ = fun (_ : subtype) -> () + + let equal_subtype = + (fun a__103_ -> + fun b__104_ -> + if Stdlib.( == ) a__103_ b__104_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__103_.final : bool) b__104_.final) + (Stdlib.( && ) + (Ppx_base.equal_list + (fun a__105_ -> fun b__106_ -> equal_typeidx a__105_ b__106_) + a__103_.super b__104_.super) + (equal_comptype a__103_.type_ b__104_.type_)) + : subtype -> subtype -> bool) + + let _ = equal_subtype + + let (hash_fold_subtype : Ppx_base.state -> subtype -> Ppx_base.state) = + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_bool hsv arg.final + in + Ppx_base.hash_fold_list hash_fold_typeidx hsv arg.super + in + hash_fold_comptype hsv arg.type_ + + let _ = hash_fold_subtype + + let (hash_subtype : subtype -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_subtype hsv arg) + in + fun x -> func x + + let _ = hash_subtype +end + type typedef = binder * subtype type rectype = typedef list type limits = { min : int32; max : int32 option } -type memtype = { limits : limits } +type memtype = { limits : limits; shared : bool } type tabletype = { limits : limits; element_type : reftype } type globaltype = { mut : mut; type_ : valtype } @@ -85,6 +1008,84 @@ type typeuse = | Use of typeidx * param list * valtype list | Inline of param list * valtype list +include struct + let _ = fun (_ : typeuse) -> () + + let equal_typeuse = + (fun a__107_ -> + fun b__108_ -> + if Stdlib.( == ) a__107_ b__108_ then true + else + match (a__107_, b__108_) with + | ( Use (_a__109_, _a__111_, _a__113_), + Use (_b__110_, _b__112_, _b__114_) ) -> + Stdlib.( && ) + (equal_typeidx _a__109_ _b__110_) + (Stdlib.( && ) + (Ppx_base.equal_list + (fun a__115_ -> + fun (b__116_ [@merlin.hide]) -> + (equal_param a__115_ b__116_ [@merlin.hide])) + _a__111_ _b__112_) + (Ppx_base.equal_list + (fun a__117_ -> + fun (b__118_ [@merlin.hide]) -> + (equal_valtype a__117_ b__118_ [@merlin.hide])) + _a__113_ _b__114_)) + | Use _, _ -> false + | _, Use _ -> false + | Inline (_a__119_, _a__121_), Inline (_b__120_, _b__122_) -> + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__123_ -> + fun (b__124_ [@merlin.hide]) -> + (equal_param a__123_ b__124_ [@merlin.hide])) + _a__119_ _b__120_) + (Ppx_base.equal_list + (fun a__125_ -> + fun (b__126_ [@merlin.hide]) -> + (equal_valtype a__125_ b__126_ [@merlin.hide])) + _a__121_ _b__122_) + : typeuse -> typeuse -> bool) + + let _ = equal_typeuse + + let (hash_fold_typeuse : Ppx_base.state -> typeuse -> Ppx_base.state) = + (fun hsv -> + fun arg -> + match arg with + | Use (_a0, _a1, _a2) -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = + let hsv = hsv in + hash_fold_typeidx hsv _a0 + in + Ppx_base.hash_fold_list hash_fold_param hsv _a1 + in + Ppx_base.hash_fold_list hash_fold_valtype hsv _a2 + | Inline (_a0, _a1) -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_list hash_fold_param hsv _a0 + in + Ppx_base.hash_fold_list hash_fold_valtype hsv _a1 + : Ppx_base.state -> typeuse -> Ppx_base.state) + + let _ = hash_fold_typeuse + + let (hash_typeuse : typeuse -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_typeuse hsv arg) + in + fun x -> func x + + let _ = hash_typeuse +end + type importdesc = | Func of binder * typeuse | Table of binder * tabletype @@ -94,26 +1095,99 @@ type importdesc = type import = { module_ : string; name : string; desc : importdesc } type memarg = { align : int32; offset : int32 } + +include struct + let _ = fun (_ : memarg) -> () + + let equal_memarg = + (fun a__127_ -> + fun b__128_ -> + if Stdlib.( == ) a__127_ b__128_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__127_.align : int32) b__128_.align) + (Stdlib.( = ) (a__127_.offset : int32) b__128_.offset) + : memarg -> memarg -> bool) + + let _ = equal_memarg +end + type source_pos = { pkg : string; file : string; line : int; col : int } + +include struct + let _ = fun (_ : source_pos) -> () + + let equal_source_pos = + (fun a__129_ -> + fun b__130_ -> + if Stdlib.( == ) a__129_ b__130_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__129_.pkg : string) b__130_.pkg) + (Stdlib.( && ) + (Stdlib.( = ) (a__129_.file : string) b__130_.file) + (Stdlib.( && ) + (Stdlib.( = ) (a__129_.line : int) b__130_.line) + (Stdlib.( = ) (a__129_.col : int) b__130_.col))) + : source_pos -> source_pos -> bool) + + let _ = equal_source_pos +end + type catch = Catch of tagidx * labelidx +include struct + let _ = fun (_ : catch) -> () + + let equal_catch = + (fun a__131_ -> + fun b__132_ -> + if Stdlib.( == ) a__131_ b__132_ then true + else + match (a__131_, b__132_) with + | Catch (_a__133_, _a__135_), Catch (_b__134_, _b__136_) -> + Stdlib.( && ) + (equal_tagidx _a__133_ _b__134_) + (equal_labelidx _a__135_ _b__136_) + : catch -> catch -> bool) + + let _ = equal_catch +end + +type catchs = catch list + +include struct + let _ = fun (_ : catchs) -> () + + let equal_catchs = + (fun a__137_ -> + fun b__138_ -> + Ppx_base.equal_list + (fun a__139_ -> fun b__140_ -> equal_catch a__139_ b__140_) + a__137_ b__138_ + : catchs -> catchs -> bool) + + let _ = equal_catchs +end + class ['a] mapbase = object - method visit_typeidx : 'a -> typeidx -> typeidx = fun _ e -> e - method visit_dataidx : 'a -> dataidx -> dataidx = fun _ e -> e - method visit_labelidx : 'a -> labelidx -> labelidx = fun _ e -> e - method visit_funcidx : 'a -> funcidx -> funcidx = fun _ e -> e - method visit_tableidx : 'a -> tableidx -> tableidx = fun _ e -> e - method visit_globalidx : 'a -> globalidx -> globalidx = fun _ e -> e - method visit_localidx : 'a -> localidx -> localidx = fun _ e -> e - method visit_fieldidx : 'a -> fieldidx -> fieldidx = fun _ e -> e - method visit_tagidx : 'a -> tagidx -> tagidx = fun _ e -> e - method visit_memarg : 'a -> memarg -> memarg = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_reftype : 'a -> reftype -> reftype = fun _ e -> e - method visit_heaptype : 'a -> heaptype -> heaptype = fun _ e -> e - method visit_typeuse : 'a -> typeuse -> typeuse = fun _ e -> e - method visit_catch : 'a -> catch -> catch = fun _ e -> e + method visit_typeidx : 'a -> typeidx -> typeidx = fun _ -> fun e -> e + method visit_dataidx : 'a -> dataidx -> dataidx = fun _ -> fun e -> e + method visit_labelidx : 'a -> labelidx -> labelidx = fun _ -> fun e -> e + method visit_funcidx : 'a -> funcidx -> funcidx = fun _ -> fun e -> e + method visit_tableidx : 'a -> tableidx -> tableidx = fun _ -> fun e -> e + method visit_globalidx : 'a -> globalidx -> globalidx = fun _ -> fun e -> e + method visit_localidx : 'a -> localidx -> localidx = fun _ -> fun e -> e + method visit_fieldidx : 'a -> fieldidx -> fieldidx = fun _ -> fun e -> e + method visit_tagidx : 'a -> tagidx -> tagidx = fun _ -> fun e -> e + method visit_memarg : 'a -> memarg -> memarg = fun _ -> fun e -> e + method visit_label : 'a -> label -> label = fun _ -> fun e -> e + method visit_reftype : 'a -> reftype -> reftype = fun _ -> fun e -> e + method visit_heaptype : 'a -> heaptype -> heaptype = fun _ -> fun e -> e + method visit_typeuse : 'a -> typeuse -> typeuse = fun _ -> fun e -> e + method visit_catch : 'a -> catch -> catch = fun _ -> fun e -> e + method visit_catchs : 'a -> catchs -> catchs = fun _ -> fun e -> e end type instr = @@ -122,13 +1196,18 @@ type instr = | Array_fill of typeidx | Array_get of typeidx | Array_get_u of typeidx + | Array_get_s of typeidx | Array_len | Array_new of typeidx | Array_new_data of typeidx * dataidx | Array_new_default of typeidx | Array_new_fixed of typeidx * int32 | Array_set of typeidx - | Block of label * typeuse * instr list + | Block of { + label : label; [@ceh.ignore] + typeuse : typeuse; + instrs : instr list; + } | Br of labelidx | Br_if of labelidx | Br_table of labelidx list * labelidx @@ -242,6 +1321,15 @@ type instr = | I32_trunc_sat_f32_u | I32_trunc_sat_f64_s | I32_trunc_sat_f64_u + | I32_atomic_load of memarg + | I32_atomic_load8_u of memarg + | I32_atomic_load16_u of memarg + | I32_atomic_store of memarg + | I32_atomic_store8 of memarg + | I32_atomic_store16 of memarg + | I32_atomic_rmw_cmpxchg of memarg + | I32_atomic_rmw8_cmpxchg_u of memarg + | I32_atomic_rmw16_cmpxchg_u of memarg | I64_add | I64_and | I64_clz @@ -298,16 +1386,27 @@ type instr = | F64x2_mul | F32x4_add | F32x4_mul - | If of label * typeuse * instr list * instr list + | If of { + label : label; [@ceh.ignore] + typeuse : typeuse; + then_ : instr list; + else_ : instr list; + } | Local_get of localidx | Local_set of localidx | Local_tee of localidx - | Loop of label * typeuse * instr list - | Memory_init of typeidx + | Loop of { + label : label; [@ceh.ignore] + typeuse : typeuse; + instrs : instr list; + } + | Memory_init of dataidx | Memory_copy | Memory_grow | Memory_size | Memory_fill + | Memory_atomic_wait32 of memarg + | Memory_atomic_notify of memarg | Ref_eq | Ref_as_non_null | Ref_cast of reftype @@ -322,7 +1421,12 @@ type instr = | Table_get of tableidx | Unreachable | Throw of tagidx - | Try_table of label * typeuse * catch list * instr list + | Try_table of { + label : label; [@ceh.ignore] + typeuse : typeuse; + catchs : catchs; + instrs : instr list; + } | Select | No_op | Source_pos of (source_pos[@visitors.opaque]) @@ -340,103 +1444,137 @@ include struct fun env -> Any_convert_extern method visit_Array_copy : _ -> typeidx -> typeidx -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - let _visitors_r1 = self#visit_typeidx env _visitors_c1 in - Array_copy (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + let _visitors_r1 = self#visit_typeidx env _visitors_c1 in + Array_copy (_visitors_r0, _visitors_r1) method visit_Array_fill : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_fill _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_fill _visitors_r0 method visit_Array_get : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_get _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_get _visitors_r0 method visit_Array_get_u : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_get_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_get_u _visitors_r0 + + method visit_Array_get_s : _ -> typeidx -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_get_s _visitors_r0 method visit_Array_len : _ -> instr = fun env -> Array_len method visit_Array_new : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_new _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_new _visitors_r0 method visit_Array_new_data : _ -> typeidx -> dataidx -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - let _visitors_r1 = self#visit_dataidx env _visitors_c1 in - Array_new_data (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + let _visitors_r1 = self#visit_dataidx env _visitors_c1 in + Array_new_data (_visitors_r0, _visitors_r1) method visit_Array_new_default : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_new_default _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_new_default _visitors_r0 method visit_Array_new_fixed : _ -> typeidx -> int32 -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_c1 - in - Array_new_fixed (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_c1 + in + Array_new_fixed (_visitors_r0, _visitors_r1) method visit_Array_set : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Array_set _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Array_set _visitors_r0 method visit_Block : _ -> label -> typeuse -> instr list -> instr = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = self#visit_label env _visitors_c0 in - let _visitors_r1 = self#visit_typeuse env _visitors_c1 in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_instr env)) - _visitors_c2 - in - Block (_visitors_r0, _visitors_r1, _visitors_r2) + fun env -> + fun _visitors_flabel -> + fun _visitors_ftypeuse -> + fun _visitors_finstrs -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_typeuse env _visitors_ftypeuse in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_instr env)) + _visitors_finstrs + in + Block + { + label = _visitors_r0; + typeuse = _visitors_r1; + instrs = _visitors_r2; + } method visit_Br : _ -> labelidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_labelidx env _visitors_c0 in - Br _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_labelidx env _visitors_c0 in + Br _visitors_r0 method visit_Br_if : _ -> labelidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_labelidx env _visitors_c0 in - Br_if _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_labelidx env _visitors_c0 in + Br_if _visitors_r0 method visit_Br_table : _ -> labelidx list -> labelidx -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_labelidx env)) - _visitors_c0 - in - let _visitors_r1 = self#visit_labelidx env _visitors_c1 in - Br_table (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_labelidx env)) + _visitors_c0 + in + let _visitors_r1 = self#visit_labelidx env _visitors_c1 in + Br_table (_visitors_r0, _visitors_r1) method visit_Call : _ -> funcidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_funcidx env _visitors_c0 in - Call _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_funcidx env _visitors_c0 in + Call _visitors_r0 method visit_Call_indirect : _ -> tableidx -> typeuse -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_tableidx env _visitors_c0 in - let _visitors_r1 = self#visit_typeuse env _visitors_c1 in - Call_indirect (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_tableidx env _visitors_c0 in + let _visitors_r1 = self#visit_typeuse env _visitors_c1 in + Call_indirect (_visitors_r0, _visitors_r1) method visit_Call_ref : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Call_ref _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Call_ref _visitors_r0 method visit_Drop : _ -> instr = fun env -> Drop @@ -446,14 +1584,16 @@ include struct method visit_F64_add : _ -> instr = fun env -> F64_add method visit_F64_const : _ -> string -> float -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_c1 - in - F64_const (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_c1 + in + F64_const (_visitors_r0, _visitors_r1) method visit_F64_convert_i32_s : _ -> instr = fun env -> F64_convert_i32_s method visit_F64_convert_i32_u : _ -> instr = fun env -> F64_convert_i32_u @@ -466,9 +1606,10 @@ include struct method visit_F64_le : _ -> instr = fun env -> F64_le method visit_F64_load : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - F64_load _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + F64_load _visitors_r0 method visit_F64_lt : _ -> instr = fun env -> F64_lt method visit_F64_mul : _ -> instr = fun env -> F64_mul @@ -479,9 +1620,10 @@ include struct fun env -> F64_reinterpret_i64 method visit_F64_store : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - F64_store _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + F64_store _visitors_r0 method visit_F64_sub : _ -> instr = fun env -> F64_sub method visit_F64_sqrt : _ -> instr = fun env -> F64_sqrt @@ -493,14 +1635,16 @@ include struct method visit_F32_add : _ -> instr = fun env -> F32_add method visit_F32_const : _ -> string -> float -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_c1 - in - F32_const (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_c1 + in + F32_const (_visitors_r0, _visitors_r1) method visit_F32_convert_i32_s : _ -> instr = fun env -> F32_convert_i32_s method visit_F32_convert_i32_u : _ -> instr = fun env -> F32_convert_i32_u @@ -514,9 +1658,10 @@ include struct method visit_F32_le : _ -> instr = fun env -> F32_le method visit_F32_load : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - F32_load _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + F32_load _visitors_r0 method visit_F32_lt : _ -> instr = fun env -> F32_lt method visit_F32_mul : _ -> instr = fun env -> F32_mul @@ -529,9 +1674,10 @@ include struct method visit_F32_sqrt : _ -> instr = fun env -> F32_sqrt method visit_F32_store : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - F32_store _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + F32_store _visitors_r0 method visit_F32_sub : _ -> instr = fun env -> F32_sub method visit_F32_abs : _ -> instr = fun env -> F32_abs @@ -550,25 +1696,28 @@ include struct method visit_I64_trunc_f32_u : _ -> instr = fun env -> I64_trunc_f32_u method visit_Global_get : _ -> globalidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_globalidx env _visitors_c0 in - Global_get _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_globalidx env _visitors_c0 in + Global_get _visitors_r0 method visit_Global_set : _ -> globalidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_globalidx env _visitors_c0 in - Global_set _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_globalidx env _visitors_c0 in + Global_set _visitors_r0 method visit_I32_add : _ -> instr = fun env -> I32_add method visit_I32_and : _ -> instr = fun env -> I32_and method visit_I32_clz : _ -> instr = fun env -> I32_clz method visit_I32_const : _ -> int32 -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - I32_const _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + I32_const _visitors_r0 method visit_I32_ctz : _ -> instr = fun env -> I32_ctz method visit_I32_div_s : _ -> instr = fun env -> I32_div_s @@ -583,29 +1732,34 @@ include struct method visit_I32_le_u : _ -> instr = fun env -> I32_le_u method visit_I32_load : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_load _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_load _visitors_r0 method visit_I32_load16_u : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_load16_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_load16_u _visitors_r0 method visit_I32_load16_s : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_load16_s _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_load16_s _visitors_r0 method visit_I32_load8_u : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_load8_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_load8_u _visitors_r0 method visit_I32_load8_s : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_load8_s _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_load8_s _visitors_r0 method visit_I32_lt_s : _ -> instr = fun env -> I32_lt_s method visit_I32_lt_u : _ -> instr = fun env -> I32_lt_u @@ -621,19 +1775,22 @@ include struct method visit_I32_rotl : _ -> instr = fun env -> I32_rotl method visit_I32_store : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_store _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_store _visitors_r0 method visit_I32_store16 : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_store16 _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_store16 _visitors_r0 method visit_I32_store8 : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I32_store8 _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_store8 _visitors_r0 method visit_I32_sub : _ -> instr = fun env -> I32_sub method visit_I32_trunc_f64_s : _ -> instr = fun env -> I32_trunc_f64_s @@ -655,16 +1812,71 @@ include struct method visit_I32_trunc_sat_f64_u : _ -> instr = fun env -> I32_trunc_sat_f64_u + method visit_I32_atomic_load : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_load _visitors_r0 + + method visit_I32_atomic_load8_u : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_load8_u _visitors_r0 + + method visit_I32_atomic_load16_u : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_load16_u _visitors_r0 + + method visit_I32_atomic_store : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_store _visitors_r0 + + method visit_I32_atomic_store8 : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_store8 _visitors_r0 + + method visit_I32_atomic_store16 : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_store16 _visitors_r0 + + method visit_I32_atomic_rmw_cmpxchg : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_rmw_cmpxchg _visitors_r0 + + method visit_I32_atomic_rmw8_cmpxchg_u : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_rmw8_cmpxchg_u _visitors_r0 + + method visit_I32_atomic_rmw16_cmpxchg_u : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I32_atomic_rmw16_cmpxchg_u _visitors_r0 + method visit_I64_add : _ -> instr = fun env -> I64_add method visit_I64_and : _ -> instr = fun env -> I64_and method visit_I64_clz : _ -> instr = fun env -> I64_clz method visit_I64_const : _ -> int64 -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - I64_const _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + I64_const _visitors_r0 method visit_I64_ctz : _ -> instr = fun env -> I64_ctz method visit_I64_div_s : _ -> instr = fun env -> I64_div_s @@ -680,39 +1892,46 @@ include struct method visit_I64_le_u : _ -> instr = fun env -> I64_le_u method visit_I64_load : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load _visitors_r0 method visit_I64_load32_u : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load32_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load32_u _visitors_r0 method visit_I64_load32_s : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load32_s _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load32_s _visitors_r0 method visit_I64_load16_u : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load16_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load16_u _visitors_r0 method visit_I64_load16_s : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load16_s _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load16_s _visitors_r0 method visit_I64_load8_u : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load8_u _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load8_u _visitors_r0 method visit_I64_load8_s : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_load8_s _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_load8_s _visitors_r0 method visit_I64_lt_s : _ -> instr = fun env -> I64_lt_s method visit_I64_lt_u : _ -> instr = fun env -> I64_lt_u @@ -731,24 +1950,28 @@ include struct method visit_I64_shr_u : _ -> instr = fun env -> I64_shr_u method visit_I64_store : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_store _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_store _visitors_r0 method visit_I64_store32 : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_store32 _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_store32 _visitors_r0 method visit_I64_store16 : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_store16 _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_store16 _visitors_r0 method visit_I64_store8 : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - I64_store8 _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + I64_store8 _visitors_r0 method visit_I64_sub : _ -> instr = fun env -> I64_sub method visit_I64_trunc_f64_s : _ -> instr = fun env -> I64_trunc_f64_s @@ -771,394 +1994,496 @@ include struct fun env -> I64_trunc_sat_f64_u method visit_V128_load : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - V128_load _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + V128_load _visitors_r0 method visit_V128_store : _ -> memarg -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_memarg env _visitors_c0 in - V128_store _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + V128_store _visitors_r0 method visit_F64x2_add : _ -> instr = fun env -> F64x2_add method visit_F64x2_mul : _ -> instr = fun env -> F64x2_mul method visit_F32x4_add : _ -> instr = fun env -> F32x4_add method visit_F32x4_mul : _ -> instr = fun env -> F32x4_mul - method visit_If - : _ -> label -> typeuse -> instr list -> instr list -> instr = - fun env _visitors_c0 _visitors_c1 _visitors_c2 _visitors_c3 -> - let _visitors_r0 = self#visit_label env _visitors_c0 in - let _visitors_r1 = self#visit_typeuse env _visitors_c1 in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_instr env)) - _visitors_c2 - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_instr env)) - _visitors_c3 - in - If (_visitors_r0, _visitors_r1, _visitors_r2, _visitors_r3) + method visit_If : + _ -> label -> typeuse -> instr list -> instr list -> instr = + fun env -> + fun _visitors_flabel -> + fun _visitors_ftypeuse -> + fun _visitors_fthen_ -> + fun _visitors_felse_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_typeuse env _visitors_ftypeuse in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_instr env)) + _visitors_fthen_ + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_instr env)) + _visitors_felse_ + in + If + { + label = _visitors_r0; + typeuse = _visitors_r1; + then_ = _visitors_r2; + else_ = _visitors_r3; + } method visit_Local_get : _ -> localidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_localidx env _visitors_c0 in - Local_get _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_localidx env _visitors_c0 in + Local_get _visitors_r0 method visit_Local_set : _ -> localidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_localidx env _visitors_c0 in - Local_set _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_localidx env _visitors_c0 in + Local_set _visitors_r0 method visit_Local_tee : _ -> localidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_localidx env _visitors_c0 in - Local_tee _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_localidx env _visitors_c0 in + Local_tee _visitors_r0 method visit_Loop : _ -> label -> typeuse -> instr list -> instr = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = self#visit_label env _visitors_c0 in - let _visitors_r1 = self#visit_typeuse env _visitors_c1 in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_instr env)) - _visitors_c2 - in - Loop (_visitors_r0, _visitors_r1, _visitors_r2) - - method visit_Memory_init : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Memory_init _visitors_r0 + fun env -> + fun _visitors_flabel -> + fun _visitors_ftypeuse -> + fun _visitors_finstrs -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_typeuse env _visitors_ftypeuse in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_instr env)) + _visitors_finstrs + in + Loop + { + label = _visitors_r0; + typeuse = _visitors_r1; + instrs = _visitors_r2; + } + + method visit_Memory_init : _ -> dataidx -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_dataidx env _visitors_c0 in + Memory_init _visitors_r0 method visit_Memory_copy : _ -> instr = fun env -> Memory_copy method visit_Memory_grow : _ -> instr = fun env -> Memory_grow method visit_Memory_size : _ -> instr = fun env -> Memory_size method visit_Memory_fill : _ -> instr = fun env -> Memory_fill + + method visit_Memory_atomic_wait32 : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + Memory_atomic_wait32 _visitors_r0 + + method visit_Memory_atomic_notify : _ -> memarg -> instr = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_memarg env _visitors_c0 in + Memory_atomic_notify _visitors_r0 + method visit_Ref_eq : _ -> instr = fun env -> Ref_eq method visit_Ref_as_non_null : _ -> instr = fun env -> Ref_as_non_null method visit_Ref_cast : _ -> reftype -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_reftype env _visitors_c0 in - Ref_cast _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_reftype env _visitors_c0 in + Ref_cast _visitors_r0 method visit_Ref_func : _ -> funcidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_funcidx env _visitors_c0 in - Ref_func _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_funcidx env _visitors_c0 in + Ref_func _visitors_r0 method visit_Ref_is_null : _ -> instr = fun env -> Ref_is_null method visit_Ref_null : _ -> heaptype -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_heaptype env _visitors_c0 in - Ref_null _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_heaptype env _visitors_c0 in + Ref_null _visitors_r0 method visit_Return : _ -> instr = fun env -> Return method visit_Struct_get : _ -> typeidx -> fieldidx -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - let _visitors_r1 = self#visit_fieldidx env _visitors_c1 in - Struct_get (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + let _visitors_r1 = self#visit_fieldidx env _visitors_c1 in + Struct_get (_visitors_r0, _visitors_r1) method visit_Struct_new : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Struct_new _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Struct_new _visitors_r0 method visit_Struct_new_default : _ -> typeidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - Struct_new_default _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + Struct_new_default _visitors_r0 method visit_Struct_set : _ -> typeidx -> fieldidx -> instr = - fun env _visitors_c0 _visitors_c1 -> - let _visitors_r0 = self#visit_typeidx env _visitors_c0 in - let _visitors_r1 = self#visit_fieldidx env _visitors_c1 in - Struct_set (_visitors_r0, _visitors_r1) + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + let _visitors_r0 = self#visit_typeidx env _visitors_c0 in + let _visitors_r1 = self#visit_fieldidx env _visitors_c1 in + Struct_set (_visitors_r0, _visitors_r1) method visit_Table_get : _ -> tableidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_tableidx env _visitors_c0 in - Table_get _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_tableidx env _visitors_c0 in + Table_get _visitors_r0 method visit_Unreachable : _ -> instr = fun env -> Unreachable method visit_Throw : _ -> tagidx -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_tagidx env _visitors_c0 in - Throw _visitors_r0 - - method visit_Try_table - : _ -> label -> typeuse -> catch list -> instr list -> instr = - fun env _visitors_c0 _visitors_c1 _visitors_c2 _visitors_c3 -> - let _visitors_r0 = self#visit_label env _visitors_c0 in - let _visitors_r1 = self#visit_typeuse env _visitors_c1 in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_catch env)) - _visitors_c2 - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_instr env)) - _visitors_c3 - in - Try_table (_visitors_r0, _visitors_r1, _visitors_r2, _visitors_r3) + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_tagidx env _visitors_c0 in + Throw _visitors_r0 + + method visit_Try_table : + _ -> label -> typeuse -> catchs -> instr list -> instr = + fun env -> + fun _visitors_flabel -> + fun _visitors_ftypeuse -> + fun _visitors_fcatchs -> + fun _visitors_finstrs -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_typeuse env _visitors_ftypeuse in + let _visitors_r2 = self#visit_catchs env _visitors_fcatchs in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_instr env)) + _visitors_finstrs + in + Try_table + { + label = _visitors_r0; + typeuse = _visitors_r1; + catchs = _visitors_r2; + instrs = _visitors_r3; + } method visit_Select : _ -> instr = fun env -> Select method visit_No_op : _ -> instr = fun env -> No_op method visit_Source_pos : _ -> _ -> instr = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Source_pos _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + Source_pos _visitors_r0 method visit_Prologue_end : _ -> instr = fun env -> Prologue_end method visit_instr : _ -> instr -> instr = - fun env _visitors_this -> - match _visitors_this with - | Any_convert_extern -> self#visit_Any_convert_extern env - | Array_copy (_visitors_c0, _visitors_c1) -> - self#visit_Array_copy env _visitors_c0 _visitors_c1 - | Array_fill _visitors_c0 -> self#visit_Array_fill env _visitors_c0 - | Array_get _visitors_c0 -> self#visit_Array_get env _visitors_c0 - | Array_get_u _visitors_c0 -> self#visit_Array_get_u env _visitors_c0 - | Array_len -> self#visit_Array_len env - | Array_new _visitors_c0 -> self#visit_Array_new env _visitors_c0 - | Array_new_data (_visitors_c0, _visitors_c1) -> - self#visit_Array_new_data env _visitors_c0 _visitors_c1 - | Array_new_default _visitors_c0 -> - self#visit_Array_new_default env _visitors_c0 - | Array_new_fixed (_visitors_c0, _visitors_c1) -> - self#visit_Array_new_fixed env _visitors_c0 _visitors_c1 - | Array_set _visitors_c0 -> self#visit_Array_set env _visitors_c0 - | Block (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Block env _visitors_c0 _visitors_c1 _visitors_c2 - | Br _visitors_c0 -> self#visit_Br env _visitors_c0 - | Br_if _visitors_c0 -> self#visit_Br_if env _visitors_c0 - | Br_table (_visitors_c0, _visitors_c1) -> - self#visit_Br_table env _visitors_c0 _visitors_c1 - | Call _visitors_c0 -> self#visit_Call env _visitors_c0 - | Call_indirect (_visitors_c0, _visitors_c1) -> - self#visit_Call_indirect env _visitors_c0 _visitors_c1 - | Call_ref _visitors_c0 -> self#visit_Call_ref env _visitors_c0 - | Drop -> self#visit_Drop env - | Extern_convert_any -> self#visit_Extern_convert_any env - | F64_add -> self#visit_F64_add env - | F64_const (_visitors_c0, _visitors_c1) -> - self#visit_F64_const env _visitors_c0 _visitors_c1 - | F64_convert_i32_s -> self#visit_F64_convert_i32_s env - | F64_convert_i32_u -> self#visit_F64_convert_i32_u env - | F64_convert_i64_s -> self#visit_F64_convert_i64_s env - | F64_convert_i64_u -> self#visit_F64_convert_i64_u env - | F64_div -> self#visit_F64_div env - | F64_eq -> self#visit_F64_eq env - | F64_ge -> self#visit_F64_ge env - | F64_gt -> self#visit_F64_gt env - | F64_le -> self#visit_F64_le env - | F64_load _visitors_c0 -> self#visit_F64_load env _visitors_c0 - | F64_lt -> self#visit_F64_lt env - | F64_mul -> self#visit_F64_mul env - | F64_ne -> self#visit_F64_ne env - | F64_neg -> self#visit_F64_neg env - | F64_reinterpret_i64 -> self#visit_F64_reinterpret_i64 env - | F64_store _visitors_c0 -> self#visit_F64_store env _visitors_c0 - | F64_sub -> self#visit_F64_sub env - | F64_sqrt -> self#visit_F64_sqrt env - | F64_abs -> self#visit_F64_abs env - | F64_trunc -> self#visit_F64_trunc env - | F64_floor -> self#visit_F64_floor env - | F64_ceil -> self#visit_F64_ceil env - | F64_nearest -> self#visit_F64_nearest env - | F32_add -> self#visit_F32_add env - | F32_const (_visitors_c0, _visitors_c1) -> - self#visit_F32_const env _visitors_c0 _visitors_c1 - | F32_convert_i32_s -> self#visit_F32_convert_i32_s env - | F32_convert_i32_u -> self#visit_F32_convert_i32_u env - | F32_convert_i64_s -> self#visit_F32_convert_i64_s env - | F32_convert_i64_u -> self#visit_F32_convert_i64_u env - | F32_demote_f64 -> self#visit_F32_demote_f64 env - | F32_div -> self#visit_F32_div env - | F32_eq -> self#visit_F32_eq env - | F32_ge -> self#visit_F32_ge env - | F32_gt -> self#visit_F32_gt env - | F32_le -> self#visit_F32_le env - | F32_load _visitors_c0 -> self#visit_F32_load env _visitors_c0 - | F32_lt -> self#visit_F32_lt env - | F32_mul -> self#visit_F32_mul env - | F32_ne -> self#visit_F32_ne env - | F32_neg -> self#visit_F32_neg env - | F32_reinterpret_i32 -> self#visit_F32_reinterpret_i32 env - | F32_sqrt -> self#visit_F32_sqrt env - | F32_store _visitors_c0 -> self#visit_F32_store env _visitors_c0 - | F32_sub -> self#visit_F32_sub env - | F32_abs -> self#visit_F32_abs env - | F32_trunc -> self#visit_F32_trunc env - | F32_floor -> self#visit_F32_floor env - | F32_ceil -> self#visit_F32_ceil env - | F32_nearest -> self#visit_F32_nearest env - | F64_promote_f32 -> self#visit_F64_promote_f32 env - | I32_reinterpret_f32 -> self#visit_I32_reinterpret_f32 env - | I32_trunc_f32_s -> self#visit_I32_trunc_f32_s env - | I32_trunc_f32_u -> self#visit_I32_trunc_f32_u env - | I64_trunc_f32_s -> self#visit_I64_trunc_f32_s env - | I64_trunc_f32_u -> self#visit_I64_trunc_f32_u env - | Global_get _visitors_c0 -> self#visit_Global_get env _visitors_c0 - | Global_set _visitors_c0 -> self#visit_Global_set env _visitors_c0 - | I32_add -> self#visit_I32_add env - | I32_and -> self#visit_I32_and env - | I32_clz -> self#visit_I32_clz env - | I32_const _visitors_c0 -> self#visit_I32_const env _visitors_c0 - | I32_ctz -> self#visit_I32_ctz env - | I32_div_s -> self#visit_I32_div_s env - | I32_div_u -> self#visit_I32_div_u env - | I32_eq -> self#visit_I32_eq env - | I32_eqz -> self#visit_I32_eqz env - | I32_ge_s -> self#visit_I32_ge_s env - | I32_ge_u -> self#visit_I32_ge_u env - | I32_gt_s -> self#visit_I32_gt_s env - | I32_gt_u -> self#visit_I32_gt_u env - | I32_le_s -> self#visit_I32_le_s env - | I32_le_u -> self#visit_I32_le_u env - | I32_load _visitors_c0 -> self#visit_I32_load env _visitors_c0 - | I32_load16_u _visitors_c0 -> - self#visit_I32_load16_u env _visitors_c0 - | I32_load16_s _visitors_c0 -> - self#visit_I32_load16_s env _visitors_c0 - | I32_load8_u _visitors_c0 -> self#visit_I32_load8_u env _visitors_c0 - | I32_load8_s _visitors_c0 -> self#visit_I32_load8_s env _visitors_c0 - | I32_lt_s -> self#visit_I32_lt_s env - | I32_lt_u -> self#visit_I32_lt_u env - | I32_mul -> self#visit_I32_mul env - | I32_ne -> self#visit_I32_ne env - | I32_or -> self#visit_I32_or env - | I32_popcnt -> self#visit_I32_popcnt env - | I32_rem_s -> self#visit_I32_rem_s env - | I32_rem_u -> self#visit_I32_rem_u env - | I32_shl -> self#visit_I32_shl env - | I32_shr_s -> self#visit_I32_shr_s env - | I32_shr_u -> self#visit_I32_shr_u env - | I32_rotl -> self#visit_I32_rotl env - | I32_store _visitors_c0 -> self#visit_I32_store env _visitors_c0 - | I32_store16 _visitors_c0 -> self#visit_I32_store16 env _visitors_c0 - | I32_store8 _visitors_c0 -> self#visit_I32_store8 env _visitors_c0 - | I32_sub -> self#visit_I32_sub env - | I32_trunc_f64_s -> self#visit_I32_trunc_f64_s env - | I32_trunc_f64_u -> self#visit_I32_trunc_f64_u env - | I32_wrap_i64 -> self#visit_I32_wrap_i64 env - | I32_xor -> self#visit_I32_xor env - | I32_extend_8_s -> self#visit_I32_extend_8_s env - | I32_extend_16_s -> self#visit_I32_extend_16_s env - | I32_trunc_sat_f32_s -> self#visit_I32_trunc_sat_f32_s env - | I32_trunc_sat_f32_u -> self#visit_I32_trunc_sat_f32_u env - | I32_trunc_sat_f64_s -> self#visit_I32_trunc_sat_f64_s env - | I32_trunc_sat_f64_u -> self#visit_I32_trunc_sat_f64_u env - | I64_add -> self#visit_I64_add env - | I64_and -> self#visit_I64_and env - | I64_clz -> self#visit_I64_clz env - | I64_const _visitors_c0 -> self#visit_I64_const env _visitors_c0 - | I64_ctz -> self#visit_I64_ctz env - | I64_div_s -> self#visit_I64_div_s env - | I64_div_u -> self#visit_I64_div_u env - | I64_eq -> self#visit_I64_eq env - | I64_extend_i32_s -> self#visit_I64_extend_i32_s env - | I64_extend_i32_u -> self#visit_I64_extend_i32_u env - | I64_ge_s -> self#visit_I64_ge_s env - | I64_gt_s -> self#visit_I64_gt_s env - | I64_le_s -> self#visit_I64_le_s env - | I64_ge_u -> self#visit_I64_ge_u env - | I64_gt_u -> self#visit_I64_gt_u env - | I64_le_u -> self#visit_I64_le_u env - | I64_load _visitors_c0 -> self#visit_I64_load env _visitors_c0 - | I64_load32_u _visitors_c0 -> - self#visit_I64_load32_u env _visitors_c0 - | I64_load32_s _visitors_c0 -> - self#visit_I64_load32_s env _visitors_c0 - | I64_load16_u _visitors_c0 -> - self#visit_I64_load16_u env _visitors_c0 - | I64_load16_s _visitors_c0 -> - self#visit_I64_load16_s env _visitors_c0 - | I64_load8_u _visitors_c0 -> self#visit_I64_load8_u env _visitors_c0 - | I64_load8_s _visitors_c0 -> self#visit_I64_load8_s env _visitors_c0 - | I64_lt_s -> self#visit_I64_lt_s env - | I64_lt_u -> self#visit_I64_lt_u env - | I64_mul -> self#visit_I64_mul env - | I64_ne -> self#visit_I64_ne env - | I64_or -> self#visit_I64_or env - | I64_popcnt -> self#visit_I64_popcnt env - | I64_reinterpret_f64 -> self#visit_I64_reinterpret_f64 env - | I64_rem_s -> self#visit_I64_rem_s env - | I64_rem_u -> self#visit_I64_rem_u env - | I64_shl -> self#visit_I64_shl env - | I64_shr_s -> self#visit_I64_shr_s env - | I64_shr_u -> self#visit_I64_shr_u env - | I64_store _visitors_c0 -> self#visit_I64_store env _visitors_c0 - | I64_store32 _visitors_c0 -> self#visit_I64_store32 env _visitors_c0 - | I64_store16 _visitors_c0 -> self#visit_I64_store16 env _visitors_c0 - | I64_store8 _visitors_c0 -> self#visit_I64_store8 env _visitors_c0 - | I64_sub -> self#visit_I64_sub env - | I64_trunc_f64_s -> self#visit_I64_trunc_f64_s env - | I64_trunc_f64_u -> self#visit_I64_trunc_f64_u env - | I64_xor -> self#visit_I64_xor env - | I64_extend_8_s -> self#visit_I64_extend_8_s env - | I64_extend_16_s -> self#visit_I64_extend_16_s env - | I64_extend_32_s -> self#visit_I64_extend_32_s env - | I64_trunc_sat_f32_s -> self#visit_I64_trunc_sat_f32_s env - | I64_trunc_sat_f32_u -> self#visit_I64_trunc_sat_f32_u env - | I64_trunc_sat_f64_s -> self#visit_I64_trunc_sat_f64_s env - | I64_trunc_sat_f64_u -> self#visit_I64_trunc_sat_f64_u env - | V128_load _visitors_c0 -> self#visit_V128_load env _visitors_c0 - | V128_store _visitors_c0 -> self#visit_V128_store env _visitors_c0 - | F64x2_add -> self#visit_F64x2_add env - | F64x2_mul -> self#visit_F64x2_mul env - | F32x4_add -> self#visit_F32x4_add env - | F32x4_mul -> self#visit_F32x4_mul env - | If (_visitors_c0, _visitors_c1, _visitors_c2, _visitors_c3) -> - self#visit_If env _visitors_c0 _visitors_c1 _visitors_c2 - _visitors_c3 - | Local_get _visitors_c0 -> self#visit_Local_get env _visitors_c0 - | Local_set _visitors_c0 -> self#visit_Local_set env _visitors_c0 - | Local_tee _visitors_c0 -> self#visit_Local_tee env _visitors_c0 - | Loop (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Loop env _visitors_c0 _visitors_c1 _visitors_c2 - | Memory_init _visitors_c0 -> self#visit_Memory_init env _visitors_c0 - | Memory_copy -> self#visit_Memory_copy env - | Memory_grow -> self#visit_Memory_grow env - | Memory_size -> self#visit_Memory_size env - | Memory_fill -> self#visit_Memory_fill env - | Ref_eq -> self#visit_Ref_eq env - | Ref_as_non_null -> self#visit_Ref_as_non_null env - | Ref_cast _visitors_c0 -> self#visit_Ref_cast env _visitors_c0 - | Ref_func _visitors_c0 -> self#visit_Ref_func env _visitors_c0 - | Ref_is_null -> self#visit_Ref_is_null env - | Ref_null _visitors_c0 -> self#visit_Ref_null env _visitors_c0 - | Return -> self#visit_Return env - | Struct_get (_visitors_c0, _visitors_c1) -> - self#visit_Struct_get env _visitors_c0 _visitors_c1 - | Struct_new _visitors_c0 -> self#visit_Struct_new env _visitors_c0 - | Struct_new_default _visitors_c0 -> - self#visit_Struct_new_default env _visitors_c0 - | Struct_set (_visitors_c0, _visitors_c1) -> - self#visit_Struct_set env _visitors_c0 _visitors_c1 - | Table_get _visitors_c0 -> self#visit_Table_get env _visitors_c0 - | Unreachable -> self#visit_Unreachable env - | Throw _visitors_c0 -> self#visit_Throw env _visitors_c0 - | Try_table (_visitors_c0, _visitors_c1, _visitors_c2, _visitors_c3) - -> - self#visit_Try_table env _visitors_c0 _visitors_c1 _visitors_c2 - _visitors_c3 - | Select -> self#visit_Select env - | No_op -> self#visit_No_op env - | Source_pos _visitors_c0 -> self#visit_Source_pos env _visitors_c0 - | Prologue_end -> self#visit_Prologue_end env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Any_convert_extern -> self#visit_Any_convert_extern env + | Array_copy (_visitors_c0, _visitors_c1) -> + self#visit_Array_copy env _visitors_c0 _visitors_c1 + | Array_fill _visitors_c0 -> self#visit_Array_fill env _visitors_c0 + | Array_get _visitors_c0 -> self#visit_Array_get env _visitors_c0 + | Array_get_u _visitors_c0 -> self#visit_Array_get_u env _visitors_c0 + | Array_get_s _visitors_c0 -> self#visit_Array_get_s env _visitors_c0 + | Array_len -> self#visit_Array_len env + | Array_new _visitors_c0 -> self#visit_Array_new env _visitors_c0 + | Array_new_data (_visitors_c0, _visitors_c1) -> + self#visit_Array_new_data env _visitors_c0 _visitors_c1 + | Array_new_default _visitors_c0 -> + self#visit_Array_new_default env _visitors_c0 + | Array_new_fixed (_visitors_c0, _visitors_c1) -> + self#visit_Array_new_fixed env _visitors_c0 _visitors_c1 + | Array_set _visitors_c0 -> self#visit_Array_set env _visitors_c0 + | Block + { + label = _visitors_flabel; + typeuse = _visitors_ftypeuse; + instrs = _visitors_finstrs; + } -> + self#visit_Block env _visitors_flabel _visitors_ftypeuse + _visitors_finstrs + | Br _visitors_c0 -> self#visit_Br env _visitors_c0 + | Br_if _visitors_c0 -> self#visit_Br_if env _visitors_c0 + | Br_table (_visitors_c0, _visitors_c1) -> + self#visit_Br_table env _visitors_c0 _visitors_c1 + | Call _visitors_c0 -> self#visit_Call env _visitors_c0 + | Call_indirect (_visitors_c0, _visitors_c1) -> + self#visit_Call_indirect env _visitors_c0 _visitors_c1 + | Call_ref _visitors_c0 -> self#visit_Call_ref env _visitors_c0 + | Drop -> self#visit_Drop env + | Extern_convert_any -> self#visit_Extern_convert_any env + | F64_add -> self#visit_F64_add env + | F64_const (_visitors_c0, _visitors_c1) -> + self#visit_F64_const env _visitors_c0 _visitors_c1 + | F64_convert_i32_s -> self#visit_F64_convert_i32_s env + | F64_convert_i32_u -> self#visit_F64_convert_i32_u env + | F64_convert_i64_s -> self#visit_F64_convert_i64_s env + | F64_convert_i64_u -> self#visit_F64_convert_i64_u env + | F64_div -> self#visit_F64_div env + | F64_eq -> self#visit_F64_eq env + | F64_ge -> self#visit_F64_ge env + | F64_gt -> self#visit_F64_gt env + | F64_le -> self#visit_F64_le env + | F64_load _visitors_c0 -> self#visit_F64_load env _visitors_c0 + | F64_lt -> self#visit_F64_lt env + | F64_mul -> self#visit_F64_mul env + | F64_ne -> self#visit_F64_ne env + | F64_neg -> self#visit_F64_neg env + | F64_reinterpret_i64 -> self#visit_F64_reinterpret_i64 env + | F64_store _visitors_c0 -> self#visit_F64_store env _visitors_c0 + | F64_sub -> self#visit_F64_sub env + | F64_sqrt -> self#visit_F64_sqrt env + | F64_abs -> self#visit_F64_abs env + | F64_trunc -> self#visit_F64_trunc env + | F64_floor -> self#visit_F64_floor env + | F64_ceil -> self#visit_F64_ceil env + | F64_nearest -> self#visit_F64_nearest env + | F32_add -> self#visit_F32_add env + | F32_const (_visitors_c0, _visitors_c1) -> + self#visit_F32_const env _visitors_c0 _visitors_c1 + | F32_convert_i32_s -> self#visit_F32_convert_i32_s env + | F32_convert_i32_u -> self#visit_F32_convert_i32_u env + | F32_convert_i64_s -> self#visit_F32_convert_i64_s env + | F32_convert_i64_u -> self#visit_F32_convert_i64_u env + | F32_demote_f64 -> self#visit_F32_demote_f64 env + | F32_div -> self#visit_F32_div env + | F32_eq -> self#visit_F32_eq env + | F32_ge -> self#visit_F32_ge env + | F32_gt -> self#visit_F32_gt env + | F32_le -> self#visit_F32_le env + | F32_load _visitors_c0 -> self#visit_F32_load env _visitors_c0 + | F32_lt -> self#visit_F32_lt env + | F32_mul -> self#visit_F32_mul env + | F32_ne -> self#visit_F32_ne env + | F32_neg -> self#visit_F32_neg env + | F32_reinterpret_i32 -> self#visit_F32_reinterpret_i32 env + | F32_sqrt -> self#visit_F32_sqrt env + | F32_store _visitors_c0 -> self#visit_F32_store env _visitors_c0 + | F32_sub -> self#visit_F32_sub env + | F32_abs -> self#visit_F32_abs env + | F32_trunc -> self#visit_F32_trunc env + | F32_floor -> self#visit_F32_floor env + | F32_ceil -> self#visit_F32_ceil env + | F32_nearest -> self#visit_F32_nearest env + | F64_promote_f32 -> self#visit_F64_promote_f32 env + | I32_reinterpret_f32 -> self#visit_I32_reinterpret_f32 env + | I32_trunc_f32_s -> self#visit_I32_trunc_f32_s env + | I32_trunc_f32_u -> self#visit_I32_trunc_f32_u env + | I64_trunc_f32_s -> self#visit_I64_trunc_f32_s env + | I64_trunc_f32_u -> self#visit_I64_trunc_f32_u env + | Global_get _visitors_c0 -> self#visit_Global_get env _visitors_c0 + | Global_set _visitors_c0 -> self#visit_Global_set env _visitors_c0 + | I32_add -> self#visit_I32_add env + | I32_and -> self#visit_I32_and env + | I32_clz -> self#visit_I32_clz env + | I32_const _visitors_c0 -> self#visit_I32_const env _visitors_c0 + | I32_ctz -> self#visit_I32_ctz env + | I32_div_s -> self#visit_I32_div_s env + | I32_div_u -> self#visit_I32_div_u env + | I32_eq -> self#visit_I32_eq env + | I32_eqz -> self#visit_I32_eqz env + | I32_ge_s -> self#visit_I32_ge_s env + | I32_ge_u -> self#visit_I32_ge_u env + | I32_gt_s -> self#visit_I32_gt_s env + | I32_gt_u -> self#visit_I32_gt_u env + | I32_le_s -> self#visit_I32_le_s env + | I32_le_u -> self#visit_I32_le_u env + | I32_load _visitors_c0 -> self#visit_I32_load env _visitors_c0 + | I32_load16_u _visitors_c0 -> + self#visit_I32_load16_u env _visitors_c0 + | I32_load16_s _visitors_c0 -> + self#visit_I32_load16_s env _visitors_c0 + | I32_load8_u _visitors_c0 -> self#visit_I32_load8_u env _visitors_c0 + | I32_load8_s _visitors_c0 -> self#visit_I32_load8_s env _visitors_c0 + | I32_lt_s -> self#visit_I32_lt_s env + | I32_lt_u -> self#visit_I32_lt_u env + | I32_mul -> self#visit_I32_mul env + | I32_ne -> self#visit_I32_ne env + | I32_or -> self#visit_I32_or env + | I32_popcnt -> self#visit_I32_popcnt env + | I32_rem_s -> self#visit_I32_rem_s env + | I32_rem_u -> self#visit_I32_rem_u env + | I32_shl -> self#visit_I32_shl env + | I32_shr_s -> self#visit_I32_shr_s env + | I32_shr_u -> self#visit_I32_shr_u env + | I32_rotl -> self#visit_I32_rotl env + | I32_store _visitors_c0 -> self#visit_I32_store env _visitors_c0 + | I32_store16 _visitors_c0 -> self#visit_I32_store16 env _visitors_c0 + | I32_store8 _visitors_c0 -> self#visit_I32_store8 env _visitors_c0 + | I32_sub -> self#visit_I32_sub env + | I32_trunc_f64_s -> self#visit_I32_trunc_f64_s env + | I32_trunc_f64_u -> self#visit_I32_trunc_f64_u env + | I32_wrap_i64 -> self#visit_I32_wrap_i64 env + | I32_xor -> self#visit_I32_xor env + | I32_extend_8_s -> self#visit_I32_extend_8_s env + | I32_extend_16_s -> self#visit_I32_extend_16_s env + | I32_trunc_sat_f32_s -> self#visit_I32_trunc_sat_f32_s env + | I32_trunc_sat_f32_u -> self#visit_I32_trunc_sat_f32_u env + | I32_trunc_sat_f64_s -> self#visit_I32_trunc_sat_f64_s env + | I32_trunc_sat_f64_u -> self#visit_I32_trunc_sat_f64_u env + | I32_atomic_load _visitors_c0 -> + self#visit_I32_atomic_load env _visitors_c0 + | I32_atomic_load8_u _visitors_c0 -> + self#visit_I32_atomic_load8_u env _visitors_c0 + | I32_atomic_load16_u _visitors_c0 -> + self#visit_I32_atomic_load16_u env _visitors_c0 + | I32_atomic_store _visitors_c0 -> + self#visit_I32_atomic_store env _visitors_c0 + | I32_atomic_store8 _visitors_c0 -> + self#visit_I32_atomic_store8 env _visitors_c0 + | I32_atomic_store16 _visitors_c0 -> + self#visit_I32_atomic_store16 env _visitors_c0 + | I32_atomic_rmw_cmpxchg _visitors_c0 -> + self#visit_I32_atomic_rmw_cmpxchg env _visitors_c0 + | I32_atomic_rmw8_cmpxchg_u _visitors_c0 -> + self#visit_I32_atomic_rmw8_cmpxchg_u env _visitors_c0 + | I32_atomic_rmw16_cmpxchg_u _visitors_c0 -> + self#visit_I32_atomic_rmw16_cmpxchg_u env _visitors_c0 + | I64_add -> self#visit_I64_add env + | I64_and -> self#visit_I64_and env + | I64_clz -> self#visit_I64_clz env + | I64_const _visitors_c0 -> self#visit_I64_const env _visitors_c0 + | I64_ctz -> self#visit_I64_ctz env + | I64_div_s -> self#visit_I64_div_s env + | I64_div_u -> self#visit_I64_div_u env + | I64_eq -> self#visit_I64_eq env + | I64_extend_i32_s -> self#visit_I64_extend_i32_s env + | I64_extend_i32_u -> self#visit_I64_extend_i32_u env + | I64_ge_s -> self#visit_I64_ge_s env + | I64_gt_s -> self#visit_I64_gt_s env + | I64_le_s -> self#visit_I64_le_s env + | I64_ge_u -> self#visit_I64_ge_u env + | I64_gt_u -> self#visit_I64_gt_u env + | I64_le_u -> self#visit_I64_le_u env + | I64_load _visitors_c0 -> self#visit_I64_load env _visitors_c0 + | I64_load32_u _visitors_c0 -> + self#visit_I64_load32_u env _visitors_c0 + | I64_load32_s _visitors_c0 -> + self#visit_I64_load32_s env _visitors_c0 + | I64_load16_u _visitors_c0 -> + self#visit_I64_load16_u env _visitors_c0 + | I64_load16_s _visitors_c0 -> + self#visit_I64_load16_s env _visitors_c0 + | I64_load8_u _visitors_c0 -> self#visit_I64_load8_u env _visitors_c0 + | I64_load8_s _visitors_c0 -> self#visit_I64_load8_s env _visitors_c0 + | I64_lt_s -> self#visit_I64_lt_s env + | I64_lt_u -> self#visit_I64_lt_u env + | I64_mul -> self#visit_I64_mul env + | I64_ne -> self#visit_I64_ne env + | I64_or -> self#visit_I64_or env + | I64_popcnt -> self#visit_I64_popcnt env + | I64_reinterpret_f64 -> self#visit_I64_reinterpret_f64 env + | I64_rem_s -> self#visit_I64_rem_s env + | I64_rem_u -> self#visit_I64_rem_u env + | I64_shl -> self#visit_I64_shl env + | I64_shr_s -> self#visit_I64_shr_s env + | I64_shr_u -> self#visit_I64_shr_u env + | I64_store _visitors_c0 -> self#visit_I64_store env _visitors_c0 + | I64_store32 _visitors_c0 -> self#visit_I64_store32 env _visitors_c0 + | I64_store16 _visitors_c0 -> self#visit_I64_store16 env _visitors_c0 + | I64_store8 _visitors_c0 -> self#visit_I64_store8 env _visitors_c0 + | I64_sub -> self#visit_I64_sub env + | I64_trunc_f64_s -> self#visit_I64_trunc_f64_s env + | I64_trunc_f64_u -> self#visit_I64_trunc_f64_u env + | I64_xor -> self#visit_I64_xor env + | I64_extend_8_s -> self#visit_I64_extend_8_s env + | I64_extend_16_s -> self#visit_I64_extend_16_s env + | I64_extend_32_s -> self#visit_I64_extend_32_s env + | I64_trunc_sat_f32_s -> self#visit_I64_trunc_sat_f32_s env + | I64_trunc_sat_f32_u -> self#visit_I64_trunc_sat_f32_u env + | I64_trunc_sat_f64_s -> self#visit_I64_trunc_sat_f64_s env + | I64_trunc_sat_f64_u -> self#visit_I64_trunc_sat_f64_u env + | V128_load _visitors_c0 -> self#visit_V128_load env _visitors_c0 + | V128_store _visitors_c0 -> self#visit_V128_store env _visitors_c0 + | F64x2_add -> self#visit_F64x2_add env + | F64x2_mul -> self#visit_F64x2_mul env + | F32x4_add -> self#visit_F32x4_add env + | F32x4_mul -> self#visit_F32x4_mul env + | If + { + label = _visitors_flabel; + typeuse = _visitors_ftypeuse; + then_ = _visitors_fthen_; + else_ = _visitors_felse_; + } -> + self#visit_If env _visitors_flabel _visitors_ftypeuse + _visitors_fthen_ _visitors_felse_ + | Local_get _visitors_c0 -> self#visit_Local_get env _visitors_c0 + | Local_set _visitors_c0 -> self#visit_Local_set env _visitors_c0 + | Local_tee _visitors_c0 -> self#visit_Local_tee env _visitors_c0 + | Loop + { + label = _visitors_flabel; + typeuse = _visitors_ftypeuse; + instrs = _visitors_finstrs; + } -> + self#visit_Loop env _visitors_flabel _visitors_ftypeuse + _visitors_finstrs + | Memory_init _visitors_c0 -> self#visit_Memory_init env _visitors_c0 + | Memory_copy -> self#visit_Memory_copy env + | Memory_grow -> self#visit_Memory_grow env + | Memory_size -> self#visit_Memory_size env + | Memory_fill -> self#visit_Memory_fill env + | Memory_atomic_wait32 _visitors_c0 -> + self#visit_Memory_atomic_wait32 env _visitors_c0 + | Memory_atomic_notify _visitors_c0 -> + self#visit_Memory_atomic_notify env _visitors_c0 + | Ref_eq -> self#visit_Ref_eq env + | Ref_as_non_null -> self#visit_Ref_as_non_null env + | Ref_cast _visitors_c0 -> self#visit_Ref_cast env _visitors_c0 + | Ref_func _visitors_c0 -> self#visit_Ref_func env _visitors_c0 + | Ref_is_null -> self#visit_Ref_is_null env + | Ref_null _visitors_c0 -> self#visit_Ref_null env _visitors_c0 + | Return -> self#visit_Return env + | Struct_get (_visitors_c0, _visitors_c1) -> + self#visit_Struct_get env _visitors_c0 _visitors_c1 + | Struct_new _visitors_c0 -> self#visit_Struct_new env _visitors_c0 + | Struct_new_default _visitors_c0 -> + self#visit_Struct_new_default env _visitors_c0 + | Struct_set (_visitors_c0, _visitors_c1) -> + self#visit_Struct_set env _visitors_c0 _visitors_c1 + | Table_get _visitors_c0 -> self#visit_Table_get env _visitors_c0 + | Unreachable -> self#visit_Unreachable env + | Throw _visitors_c0 -> self#visit_Throw env _visitors_c0 + | Try_table + { + label = _visitors_flabel; + typeuse = _visitors_ftypeuse; + catchs = _visitors_fcatchs; + instrs = _visitors_finstrs; + } -> + self#visit_Try_table env _visitors_flabel _visitors_ftypeuse + _visitors_fcatchs _visitors_finstrs + | Select -> self#visit_Select env + | No_op -> self#visit_No_op env + | Source_pos _visitors_c0 -> self#visit_Source_pos env _visitors_c0 + | Prologue_end -> self#visit_Prologue_end env end [@@@VISITORS.END] @@ -1166,9 +2491,829 @@ end include struct let _ = fun (_ : instr) -> () + + let rec equal_instr = + (fun a__141_ -> + fun b__142_ -> + if Stdlib.( == ) a__141_ b__142_ then true + else + match (a__141_, b__142_) with + | Any_convert_extern, Any_convert_extern -> true + | Any_convert_extern, _ -> false + | _, Any_convert_extern -> false + | Array_copy (_a__143_, _a__145_), Array_copy (_b__144_, _b__146_) -> + Stdlib.( && ) + (equal_typeidx _a__143_ _b__144_) + (equal_typeidx _a__145_ _b__146_) + | Array_copy _, _ -> false + | _, Array_copy _ -> false + | Array_fill _a__147_, Array_fill _b__148_ -> + equal_typeidx _a__147_ _b__148_ + | Array_fill _, _ -> false + | _, Array_fill _ -> false + | Array_get _a__149_, Array_get _b__150_ -> + equal_typeidx _a__149_ _b__150_ + | Array_get _, _ -> false + | _, Array_get _ -> false + | Array_get_u _a__151_, Array_get_u _b__152_ -> + equal_typeidx _a__151_ _b__152_ + | Array_get_u _, _ -> false + | _, Array_get_u _ -> false + | Array_get_s _a__153_, Array_get_s _b__154_ -> + equal_typeidx _a__153_ _b__154_ + | Array_get_s _, _ -> false + | _, Array_get_s _ -> false + | Array_len, Array_len -> true + | Array_len, _ -> false + | _, Array_len -> false + | Array_new _a__155_, Array_new _b__156_ -> + equal_typeidx _a__155_ _b__156_ + | Array_new _, _ -> false + | _, Array_new _ -> false + | ( Array_new_data (_a__157_, _a__159_), + Array_new_data (_b__158_, _b__160_) ) -> + Stdlib.( && ) + (equal_typeidx _a__157_ _b__158_) + (equal_dataidx _a__159_ _b__160_) + | Array_new_data _, _ -> false + | _, Array_new_data _ -> false + | Array_new_default _a__161_, Array_new_default _b__162_ -> + equal_typeidx _a__161_ _b__162_ + | Array_new_default _, _ -> false + | _, Array_new_default _ -> false + | ( Array_new_fixed (_a__163_, _a__165_), + Array_new_fixed (_b__164_, _b__166_) ) -> + Stdlib.( && ) + (equal_typeidx _a__163_ _b__164_) + (Stdlib.( = ) (_a__165_ : int32) _b__166_) + | Array_new_fixed _, _ -> false + | _, Array_new_fixed _ -> false + | Array_set _a__167_, Array_set _b__168_ -> + equal_typeidx _a__167_ _b__168_ + | Array_set _, _ -> false + | _, Array_set _ -> false + | Block _a__169_, Block _b__170_ -> + Stdlib.( && ) + (equal_typeuse _a__169_.typeuse _b__170_.typeuse) + (Ppx_base.equal_list + (fun a__171_ -> + fun (b__172_ [@merlin.hide]) -> + (equal_instr a__171_ b__172_ [@merlin.hide])) + _a__169_.instrs _b__170_.instrs) + | Block _, _ -> false + | _, Block _ -> false + | Br _a__173_, Br _b__174_ -> equal_labelidx _a__173_ _b__174_ + | Br _, _ -> false + | _, Br _ -> false + | Br_if _a__175_, Br_if _b__176_ -> equal_labelidx _a__175_ _b__176_ + | Br_if _, _ -> false + | _, Br_if _ -> false + | Br_table (_a__177_, _a__179_), Br_table (_b__178_, _b__180_) -> + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__181_ -> + fun (b__182_ [@merlin.hide]) -> + (equal_labelidx a__181_ b__182_ [@merlin.hide])) + _a__177_ _b__178_) + (equal_labelidx _a__179_ _b__180_) + | Br_table _, _ -> false + | _, Br_table _ -> false + | Call _a__183_, Call _b__184_ -> equal_funcidx _a__183_ _b__184_ + | Call _, _ -> false + | _, Call _ -> false + | ( Call_indirect (_a__185_, _a__187_), + Call_indirect (_b__186_, _b__188_) ) -> + Stdlib.( && ) + (equal_tableidx _a__185_ _b__186_) + (equal_typeuse _a__187_ _b__188_) + | Call_indirect _, _ -> false + | _, Call_indirect _ -> false + | Call_ref _a__189_, Call_ref _b__190_ -> + equal_typeidx _a__189_ _b__190_ + | Call_ref _, _ -> false + | _, Call_ref _ -> false + | Drop, Drop -> true + | Drop, _ -> false + | _, Drop -> false + | Extern_convert_any, Extern_convert_any -> true + | Extern_convert_any, _ -> false + | _, Extern_convert_any -> false + | F64_add, F64_add -> true + | F64_add, _ -> false + | _, F64_add -> false + | F64_const (_a__191_, _a__193_), F64_const (_b__192_, _b__194_) -> + Stdlib.( && ) + (Stdlib.( = ) (_a__191_ : string) _b__192_) + (Stdlib.( = ) (_a__193_ : float) _b__194_) + | F64_const _, _ -> false + | _, F64_const _ -> false + | F64_convert_i32_s, F64_convert_i32_s -> true + | F64_convert_i32_s, _ -> false + | _, F64_convert_i32_s -> false + | F64_convert_i32_u, F64_convert_i32_u -> true + | F64_convert_i32_u, _ -> false + | _, F64_convert_i32_u -> false + | F64_convert_i64_s, F64_convert_i64_s -> true + | F64_convert_i64_s, _ -> false + | _, F64_convert_i64_s -> false + | F64_convert_i64_u, F64_convert_i64_u -> true + | F64_convert_i64_u, _ -> false + | _, F64_convert_i64_u -> false + | F64_div, F64_div -> true + | F64_div, _ -> false + | _, F64_div -> false + | F64_eq, F64_eq -> true + | F64_eq, _ -> false + | _, F64_eq -> false + | F64_ge, F64_ge -> true + | F64_ge, _ -> false + | _, F64_ge -> false + | F64_gt, F64_gt -> true + | F64_gt, _ -> false + | _, F64_gt -> false + | F64_le, F64_le -> true + | F64_le, _ -> false + | _, F64_le -> false + | F64_load _a__195_, F64_load _b__196_ -> + equal_memarg _a__195_ _b__196_ + | F64_load _, _ -> false + | _, F64_load _ -> false + | F64_lt, F64_lt -> true + | F64_lt, _ -> false + | _, F64_lt -> false + | F64_mul, F64_mul -> true + | F64_mul, _ -> false + | _, F64_mul -> false + | F64_ne, F64_ne -> true + | F64_ne, _ -> false + | _, F64_ne -> false + | F64_neg, F64_neg -> true + | F64_neg, _ -> false + | _, F64_neg -> false + | F64_reinterpret_i64, F64_reinterpret_i64 -> true + | F64_reinterpret_i64, _ -> false + | _, F64_reinterpret_i64 -> false + | F64_store _a__197_, F64_store _b__198_ -> + equal_memarg _a__197_ _b__198_ + | F64_store _, _ -> false + | _, F64_store _ -> false + | F64_sub, F64_sub -> true + | F64_sub, _ -> false + | _, F64_sub -> false + | F64_sqrt, F64_sqrt -> true + | F64_sqrt, _ -> false + | _, F64_sqrt -> false + | F64_abs, F64_abs -> true + | F64_abs, _ -> false + | _, F64_abs -> false + | F64_trunc, F64_trunc -> true + | F64_trunc, _ -> false + | _, F64_trunc -> false + | F64_floor, F64_floor -> true + | F64_floor, _ -> false + | _, F64_floor -> false + | F64_ceil, F64_ceil -> true + | F64_ceil, _ -> false + | _, F64_ceil -> false + | F64_nearest, F64_nearest -> true + | F64_nearest, _ -> false + | _, F64_nearest -> false + | F32_add, F32_add -> true + | F32_add, _ -> false + | _, F32_add -> false + | F32_const (_a__199_, _a__201_), F32_const (_b__200_, _b__202_) -> + Stdlib.( && ) + (Stdlib.( = ) (_a__199_ : string) _b__200_) + (Stdlib.( = ) (_a__201_ : float) _b__202_) + | F32_const _, _ -> false + | _, F32_const _ -> false + | F32_convert_i32_s, F32_convert_i32_s -> true + | F32_convert_i32_s, _ -> false + | _, F32_convert_i32_s -> false + | F32_convert_i32_u, F32_convert_i32_u -> true + | F32_convert_i32_u, _ -> false + | _, F32_convert_i32_u -> false + | F32_convert_i64_s, F32_convert_i64_s -> true + | F32_convert_i64_s, _ -> false + | _, F32_convert_i64_s -> false + | F32_convert_i64_u, F32_convert_i64_u -> true + | F32_convert_i64_u, _ -> false + | _, F32_convert_i64_u -> false + | F32_demote_f64, F32_demote_f64 -> true + | F32_demote_f64, _ -> false + | _, F32_demote_f64 -> false + | F32_div, F32_div -> true + | F32_div, _ -> false + | _, F32_div -> false + | F32_eq, F32_eq -> true + | F32_eq, _ -> false + | _, F32_eq -> false + | F32_ge, F32_ge -> true + | F32_ge, _ -> false + | _, F32_ge -> false + | F32_gt, F32_gt -> true + | F32_gt, _ -> false + | _, F32_gt -> false + | F32_le, F32_le -> true + | F32_le, _ -> false + | _, F32_le -> false + | F32_load _a__203_, F32_load _b__204_ -> + equal_memarg _a__203_ _b__204_ + | F32_load _, _ -> false + | _, F32_load _ -> false + | F32_lt, F32_lt -> true + | F32_lt, _ -> false + | _, F32_lt -> false + | F32_mul, F32_mul -> true + | F32_mul, _ -> false + | _, F32_mul -> false + | F32_ne, F32_ne -> true + | F32_ne, _ -> false + | _, F32_ne -> false + | F32_neg, F32_neg -> true + | F32_neg, _ -> false + | _, F32_neg -> false + | F32_reinterpret_i32, F32_reinterpret_i32 -> true + | F32_reinterpret_i32, _ -> false + | _, F32_reinterpret_i32 -> false + | F32_sqrt, F32_sqrt -> true + | F32_sqrt, _ -> false + | _, F32_sqrt -> false + | F32_store _a__205_, F32_store _b__206_ -> + equal_memarg _a__205_ _b__206_ + | F32_store _, _ -> false + | _, F32_store _ -> false + | F32_sub, F32_sub -> true + | F32_sub, _ -> false + | _, F32_sub -> false + | F32_abs, F32_abs -> true + | F32_abs, _ -> false + | _, F32_abs -> false + | F32_trunc, F32_trunc -> true + | F32_trunc, _ -> false + | _, F32_trunc -> false + | F32_floor, F32_floor -> true + | F32_floor, _ -> false + | _, F32_floor -> false + | F32_ceil, F32_ceil -> true + | F32_ceil, _ -> false + | _, F32_ceil -> false + | F32_nearest, F32_nearest -> true + | F32_nearest, _ -> false + | _, F32_nearest -> false + | F64_promote_f32, F64_promote_f32 -> true + | F64_promote_f32, _ -> false + | _, F64_promote_f32 -> false + | I32_reinterpret_f32, I32_reinterpret_f32 -> true + | I32_reinterpret_f32, _ -> false + | _, I32_reinterpret_f32 -> false + | I32_trunc_f32_s, I32_trunc_f32_s -> true + | I32_trunc_f32_s, _ -> false + | _, I32_trunc_f32_s -> false + | I32_trunc_f32_u, I32_trunc_f32_u -> true + | I32_trunc_f32_u, _ -> false + | _, I32_trunc_f32_u -> false + | I64_trunc_f32_s, I64_trunc_f32_s -> true + | I64_trunc_f32_s, _ -> false + | _, I64_trunc_f32_s -> false + | I64_trunc_f32_u, I64_trunc_f32_u -> true + | I64_trunc_f32_u, _ -> false + | _, I64_trunc_f32_u -> false + | Global_get _a__207_, Global_get _b__208_ -> + equal_globalidx _a__207_ _b__208_ + | Global_get _, _ -> false + | _, Global_get _ -> false + | Global_set _a__209_, Global_set _b__210_ -> + equal_globalidx _a__209_ _b__210_ + | Global_set _, _ -> false + | _, Global_set _ -> false + | I32_add, I32_add -> true + | I32_add, _ -> false + | _, I32_add -> false + | I32_and, I32_and -> true + | I32_and, _ -> false + | _, I32_and -> false + | I32_clz, I32_clz -> true + | I32_clz, _ -> false + | _, I32_clz -> false + | I32_const _a__211_, I32_const _b__212_ -> + Stdlib.( = ) (_a__211_ : int32) _b__212_ + | I32_const _, _ -> false + | _, I32_const _ -> false + | I32_ctz, I32_ctz -> true + | I32_ctz, _ -> false + | _, I32_ctz -> false + | I32_div_s, I32_div_s -> true + | I32_div_s, _ -> false + | _, I32_div_s -> false + | I32_div_u, I32_div_u -> true + | I32_div_u, _ -> false + | _, I32_div_u -> false + | I32_eq, I32_eq -> true + | I32_eq, _ -> false + | _, I32_eq -> false + | I32_eqz, I32_eqz -> true + | I32_eqz, _ -> false + | _, I32_eqz -> false + | I32_ge_s, I32_ge_s -> true + | I32_ge_s, _ -> false + | _, I32_ge_s -> false + | I32_ge_u, I32_ge_u -> true + | I32_ge_u, _ -> false + | _, I32_ge_u -> false + | I32_gt_s, I32_gt_s -> true + | I32_gt_s, _ -> false + | _, I32_gt_s -> false + | I32_gt_u, I32_gt_u -> true + | I32_gt_u, _ -> false + | _, I32_gt_u -> false + | I32_le_s, I32_le_s -> true + | I32_le_s, _ -> false + | _, I32_le_s -> false + | I32_le_u, I32_le_u -> true + | I32_le_u, _ -> false + | _, I32_le_u -> false + | I32_load _a__213_, I32_load _b__214_ -> + equal_memarg _a__213_ _b__214_ + | I32_load _, _ -> false + | _, I32_load _ -> false + | I32_load16_u _a__215_, I32_load16_u _b__216_ -> + equal_memarg _a__215_ _b__216_ + | I32_load16_u _, _ -> false + | _, I32_load16_u _ -> false + | I32_load16_s _a__217_, I32_load16_s _b__218_ -> + equal_memarg _a__217_ _b__218_ + | I32_load16_s _, _ -> false + | _, I32_load16_s _ -> false + | I32_load8_u _a__219_, I32_load8_u _b__220_ -> + equal_memarg _a__219_ _b__220_ + | I32_load8_u _, _ -> false + | _, I32_load8_u _ -> false + | I32_load8_s _a__221_, I32_load8_s _b__222_ -> + equal_memarg _a__221_ _b__222_ + | I32_load8_s _, _ -> false + | _, I32_load8_s _ -> false + | I32_lt_s, I32_lt_s -> true + | I32_lt_s, _ -> false + | _, I32_lt_s -> false + | I32_lt_u, I32_lt_u -> true + | I32_lt_u, _ -> false + | _, I32_lt_u -> false + | I32_mul, I32_mul -> true + | I32_mul, _ -> false + | _, I32_mul -> false + | I32_ne, I32_ne -> true + | I32_ne, _ -> false + | _, I32_ne -> false + | I32_or, I32_or -> true + | I32_or, _ -> false + | _, I32_or -> false + | I32_popcnt, I32_popcnt -> true + | I32_popcnt, _ -> false + | _, I32_popcnt -> false + | I32_rem_s, I32_rem_s -> true + | I32_rem_s, _ -> false + | _, I32_rem_s -> false + | I32_rem_u, I32_rem_u -> true + | I32_rem_u, _ -> false + | _, I32_rem_u -> false + | I32_shl, I32_shl -> true + | I32_shl, _ -> false + | _, I32_shl -> false + | I32_shr_s, I32_shr_s -> true + | I32_shr_s, _ -> false + | _, I32_shr_s -> false + | I32_shr_u, I32_shr_u -> true + | I32_shr_u, _ -> false + | _, I32_shr_u -> false + | I32_rotl, I32_rotl -> true + | I32_rotl, _ -> false + | _, I32_rotl -> false + | I32_store _a__223_, I32_store _b__224_ -> + equal_memarg _a__223_ _b__224_ + | I32_store _, _ -> false + | _, I32_store _ -> false + | I32_store16 _a__225_, I32_store16 _b__226_ -> + equal_memarg _a__225_ _b__226_ + | I32_store16 _, _ -> false + | _, I32_store16 _ -> false + | I32_store8 _a__227_, I32_store8 _b__228_ -> + equal_memarg _a__227_ _b__228_ + | I32_store8 _, _ -> false + | _, I32_store8 _ -> false + | I32_sub, I32_sub -> true + | I32_sub, _ -> false + | _, I32_sub -> false + | I32_trunc_f64_s, I32_trunc_f64_s -> true + | I32_trunc_f64_s, _ -> false + | _, I32_trunc_f64_s -> false + | I32_trunc_f64_u, I32_trunc_f64_u -> true + | I32_trunc_f64_u, _ -> false + | _, I32_trunc_f64_u -> false + | I32_wrap_i64, I32_wrap_i64 -> true + | I32_wrap_i64, _ -> false + | _, I32_wrap_i64 -> false + | I32_xor, I32_xor -> true + | I32_xor, _ -> false + | _, I32_xor -> false + | I32_extend_8_s, I32_extend_8_s -> true + | I32_extend_8_s, _ -> false + | _, I32_extend_8_s -> false + | I32_extend_16_s, I32_extend_16_s -> true + | I32_extend_16_s, _ -> false + | _, I32_extend_16_s -> false + | I32_trunc_sat_f32_s, I32_trunc_sat_f32_s -> true + | I32_trunc_sat_f32_s, _ -> false + | _, I32_trunc_sat_f32_s -> false + | I32_trunc_sat_f32_u, I32_trunc_sat_f32_u -> true + | I32_trunc_sat_f32_u, _ -> false + | _, I32_trunc_sat_f32_u -> false + | I32_trunc_sat_f64_s, I32_trunc_sat_f64_s -> true + | I32_trunc_sat_f64_s, _ -> false + | _, I32_trunc_sat_f64_s -> false + | I32_trunc_sat_f64_u, I32_trunc_sat_f64_u -> true + | I32_trunc_sat_f64_u, _ -> false + | _, I32_trunc_sat_f64_u -> false + | I32_atomic_load _a__229_, I32_atomic_load _b__230_ -> + equal_memarg _a__229_ _b__230_ + | I32_atomic_load _, _ -> false + | _, I32_atomic_load _ -> false + | I32_atomic_load8_u _a__231_, I32_atomic_load8_u _b__232_ -> + equal_memarg _a__231_ _b__232_ + | I32_atomic_load8_u _, _ -> false + | _, I32_atomic_load8_u _ -> false + | I32_atomic_load16_u _a__233_, I32_atomic_load16_u _b__234_ -> + equal_memarg _a__233_ _b__234_ + | I32_atomic_load16_u _, _ -> false + | _, I32_atomic_load16_u _ -> false + | I32_atomic_store _a__235_, I32_atomic_store _b__236_ -> + equal_memarg _a__235_ _b__236_ + | I32_atomic_store _, _ -> false + | _, I32_atomic_store _ -> false + | I32_atomic_store8 _a__237_, I32_atomic_store8 _b__238_ -> + equal_memarg _a__237_ _b__238_ + | I32_atomic_store8 _, _ -> false + | _, I32_atomic_store8 _ -> false + | I32_atomic_store16 _a__239_, I32_atomic_store16 _b__240_ -> + equal_memarg _a__239_ _b__240_ + | I32_atomic_store16 _, _ -> false + | _, I32_atomic_store16 _ -> false + | I32_atomic_rmw_cmpxchg _a__241_, I32_atomic_rmw_cmpxchg _b__242_ -> + equal_memarg _a__241_ _b__242_ + | I32_atomic_rmw_cmpxchg _, _ -> false + | _, I32_atomic_rmw_cmpxchg _ -> false + | ( I32_atomic_rmw8_cmpxchg_u _a__243_, + I32_atomic_rmw8_cmpxchg_u _b__244_ ) -> + equal_memarg _a__243_ _b__244_ + | I32_atomic_rmw8_cmpxchg_u _, _ -> false + | _, I32_atomic_rmw8_cmpxchg_u _ -> false + | ( I32_atomic_rmw16_cmpxchg_u _a__245_, + I32_atomic_rmw16_cmpxchg_u _b__246_ ) -> + equal_memarg _a__245_ _b__246_ + | I32_atomic_rmw16_cmpxchg_u _, _ -> false + | _, I32_atomic_rmw16_cmpxchg_u _ -> false + | I64_add, I64_add -> true + | I64_add, _ -> false + | _, I64_add -> false + | I64_and, I64_and -> true + | I64_and, _ -> false + | _, I64_and -> false + | I64_clz, I64_clz -> true + | I64_clz, _ -> false + | _, I64_clz -> false + | I64_const _a__247_, I64_const _b__248_ -> + Stdlib.( = ) (_a__247_ : int64) _b__248_ + | I64_const _, _ -> false + | _, I64_const _ -> false + | I64_ctz, I64_ctz -> true + | I64_ctz, _ -> false + | _, I64_ctz -> false + | I64_div_s, I64_div_s -> true + | I64_div_s, _ -> false + | _, I64_div_s -> false + | I64_div_u, I64_div_u -> true + | I64_div_u, _ -> false + | _, I64_div_u -> false + | I64_eq, I64_eq -> true + | I64_eq, _ -> false + | _, I64_eq -> false + | I64_extend_i32_s, I64_extend_i32_s -> true + | I64_extend_i32_s, _ -> false + | _, I64_extend_i32_s -> false + | I64_extend_i32_u, I64_extend_i32_u -> true + | I64_extend_i32_u, _ -> false + | _, I64_extend_i32_u -> false + | I64_ge_s, I64_ge_s -> true + | I64_ge_s, _ -> false + | _, I64_ge_s -> false + | I64_gt_s, I64_gt_s -> true + | I64_gt_s, _ -> false + | _, I64_gt_s -> false + | I64_le_s, I64_le_s -> true + | I64_le_s, _ -> false + | _, I64_le_s -> false + | I64_ge_u, I64_ge_u -> true + | I64_ge_u, _ -> false + | _, I64_ge_u -> false + | I64_gt_u, I64_gt_u -> true + | I64_gt_u, _ -> false + | _, I64_gt_u -> false + | I64_le_u, I64_le_u -> true + | I64_le_u, _ -> false + | _, I64_le_u -> false + | I64_load _a__249_, I64_load _b__250_ -> + equal_memarg _a__249_ _b__250_ + | I64_load _, _ -> false + | _, I64_load _ -> false + | I64_load32_u _a__251_, I64_load32_u _b__252_ -> + equal_memarg _a__251_ _b__252_ + | I64_load32_u _, _ -> false + | _, I64_load32_u _ -> false + | I64_load32_s _a__253_, I64_load32_s _b__254_ -> + equal_memarg _a__253_ _b__254_ + | I64_load32_s _, _ -> false + | _, I64_load32_s _ -> false + | I64_load16_u _a__255_, I64_load16_u _b__256_ -> + equal_memarg _a__255_ _b__256_ + | I64_load16_u _, _ -> false + | _, I64_load16_u _ -> false + | I64_load16_s _a__257_, I64_load16_s _b__258_ -> + equal_memarg _a__257_ _b__258_ + | I64_load16_s _, _ -> false + | _, I64_load16_s _ -> false + | I64_load8_u _a__259_, I64_load8_u _b__260_ -> + equal_memarg _a__259_ _b__260_ + | I64_load8_u _, _ -> false + | _, I64_load8_u _ -> false + | I64_load8_s _a__261_, I64_load8_s _b__262_ -> + equal_memarg _a__261_ _b__262_ + | I64_load8_s _, _ -> false + | _, I64_load8_s _ -> false + | I64_lt_s, I64_lt_s -> true + | I64_lt_s, _ -> false + | _, I64_lt_s -> false + | I64_lt_u, I64_lt_u -> true + | I64_lt_u, _ -> false + | _, I64_lt_u -> false + | I64_mul, I64_mul -> true + | I64_mul, _ -> false + | _, I64_mul -> false + | I64_ne, I64_ne -> true + | I64_ne, _ -> false + | _, I64_ne -> false + | I64_or, I64_or -> true + | I64_or, _ -> false + | _, I64_or -> false + | I64_popcnt, I64_popcnt -> true + | I64_popcnt, _ -> false + | _, I64_popcnt -> false + | I64_reinterpret_f64, I64_reinterpret_f64 -> true + | I64_reinterpret_f64, _ -> false + | _, I64_reinterpret_f64 -> false + | I64_rem_s, I64_rem_s -> true + | I64_rem_s, _ -> false + | _, I64_rem_s -> false + | I64_rem_u, I64_rem_u -> true + | I64_rem_u, _ -> false + | _, I64_rem_u -> false + | I64_shl, I64_shl -> true + | I64_shl, _ -> false + | _, I64_shl -> false + | I64_shr_s, I64_shr_s -> true + | I64_shr_s, _ -> false + | _, I64_shr_s -> false + | I64_shr_u, I64_shr_u -> true + | I64_shr_u, _ -> false + | _, I64_shr_u -> false + | I64_store _a__263_, I64_store _b__264_ -> + equal_memarg _a__263_ _b__264_ + | I64_store _, _ -> false + | _, I64_store _ -> false + | I64_store32 _a__265_, I64_store32 _b__266_ -> + equal_memarg _a__265_ _b__266_ + | I64_store32 _, _ -> false + | _, I64_store32 _ -> false + | I64_store16 _a__267_, I64_store16 _b__268_ -> + equal_memarg _a__267_ _b__268_ + | I64_store16 _, _ -> false + | _, I64_store16 _ -> false + | I64_store8 _a__269_, I64_store8 _b__270_ -> + equal_memarg _a__269_ _b__270_ + | I64_store8 _, _ -> false + | _, I64_store8 _ -> false + | I64_sub, I64_sub -> true + | I64_sub, _ -> false + | _, I64_sub -> false + | I64_trunc_f64_s, I64_trunc_f64_s -> true + | I64_trunc_f64_s, _ -> false + | _, I64_trunc_f64_s -> false + | I64_trunc_f64_u, I64_trunc_f64_u -> true + | I64_trunc_f64_u, _ -> false + | _, I64_trunc_f64_u -> false + | I64_xor, I64_xor -> true + | I64_xor, _ -> false + | _, I64_xor -> false + | I64_extend_8_s, I64_extend_8_s -> true + | I64_extend_8_s, _ -> false + | _, I64_extend_8_s -> false + | I64_extend_16_s, I64_extend_16_s -> true + | I64_extend_16_s, _ -> false + | _, I64_extend_16_s -> false + | I64_extend_32_s, I64_extend_32_s -> true + | I64_extend_32_s, _ -> false + | _, I64_extend_32_s -> false + | I64_trunc_sat_f32_s, I64_trunc_sat_f32_s -> true + | I64_trunc_sat_f32_s, _ -> false + | _, I64_trunc_sat_f32_s -> false + | I64_trunc_sat_f32_u, I64_trunc_sat_f32_u -> true + | I64_trunc_sat_f32_u, _ -> false + | _, I64_trunc_sat_f32_u -> false + | I64_trunc_sat_f64_s, I64_trunc_sat_f64_s -> true + | I64_trunc_sat_f64_s, _ -> false + | _, I64_trunc_sat_f64_s -> false + | I64_trunc_sat_f64_u, I64_trunc_sat_f64_u -> true + | I64_trunc_sat_f64_u, _ -> false + | _, I64_trunc_sat_f64_u -> false + | V128_load _a__271_, V128_load _b__272_ -> + equal_memarg _a__271_ _b__272_ + | V128_load _, _ -> false + | _, V128_load _ -> false + | V128_store _a__273_, V128_store _b__274_ -> + equal_memarg _a__273_ _b__274_ + | V128_store _, _ -> false + | _, V128_store _ -> false + | F64x2_add, F64x2_add -> true + | F64x2_add, _ -> false + | _, F64x2_add -> false + | F64x2_mul, F64x2_mul -> true + | F64x2_mul, _ -> false + | _, F64x2_mul -> false + | F32x4_add, F32x4_add -> true + | F32x4_add, _ -> false + | _, F32x4_add -> false + | F32x4_mul, F32x4_mul -> true + | F32x4_mul, _ -> false + | _, F32x4_mul -> false + | If _a__275_, If _b__276_ -> + Stdlib.( && ) + (equal_typeuse _a__275_.typeuse _b__276_.typeuse) + (Stdlib.( && ) + (Ppx_base.equal_list + (fun a__277_ -> + fun (b__278_ [@merlin.hide]) -> + (equal_instr a__277_ b__278_ [@merlin.hide])) + _a__275_.then_ _b__276_.then_) + (Ppx_base.equal_list + (fun a__279_ -> + fun (b__280_ [@merlin.hide]) -> + (equal_instr a__279_ b__280_ [@merlin.hide])) + _a__275_.else_ _b__276_.else_)) + | If _, _ -> false + | _, If _ -> false + | Local_get _a__281_, Local_get _b__282_ -> + equal_localidx _a__281_ _b__282_ + | Local_get _, _ -> false + | _, Local_get _ -> false + | Local_set _a__283_, Local_set _b__284_ -> + equal_localidx _a__283_ _b__284_ + | Local_set _, _ -> false + | _, Local_set _ -> false + | Local_tee _a__285_, Local_tee _b__286_ -> + equal_localidx _a__285_ _b__286_ + | Local_tee _, _ -> false + | _, Local_tee _ -> false + | Loop _a__287_, Loop _b__288_ -> + Stdlib.( && ) + (equal_typeuse _a__287_.typeuse _b__288_.typeuse) + (Ppx_base.equal_list + (fun a__289_ -> + fun (b__290_ [@merlin.hide]) -> + (equal_instr a__289_ b__290_ [@merlin.hide])) + _a__287_.instrs _b__288_.instrs) + | Loop _, _ -> false + | _, Loop _ -> false + | Memory_init _a__291_, Memory_init _b__292_ -> + equal_dataidx _a__291_ _b__292_ + | Memory_init _, _ -> false + | _, Memory_init _ -> false + | Memory_copy, Memory_copy -> true + | Memory_copy, _ -> false + | _, Memory_copy -> false + | Memory_grow, Memory_grow -> true + | Memory_grow, _ -> false + | _, Memory_grow -> false + | Memory_size, Memory_size -> true + | Memory_size, _ -> false + | _, Memory_size -> false + | Memory_fill, Memory_fill -> true + | Memory_fill, _ -> false + | _, Memory_fill -> false + | Memory_atomic_wait32 _a__293_, Memory_atomic_wait32 _b__294_ -> + equal_memarg _a__293_ _b__294_ + | Memory_atomic_wait32 _, _ -> false + | _, Memory_atomic_wait32 _ -> false + | Memory_atomic_notify _a__295_, Memory_atomic_notify _b__296_ -> + equal_memarg _a__295_ _b__296_ + | Memory_atomic_notify _, _ -> false + | _, Memory_atomic_notify _ -> false + | Ref_eq, Ref_eq -> true + | Ref_eq, _ -> false + | _, Ref_eq -> false + | Ref_as_non_null, Ref_as_non_null -> true + | Ref_as_non_null, _ -> false + | _, Ref_as_non_null -> false + | Ref_cast _a__297_, Ref_cast _b__298_ -> + equal_reftype _a__297_ _b__298_ + | Ref_cast _, _ -> false + | _, Ref_cast _ -> false + | Ref_func _a__299_, Ref_func _b__300_ -> + equal_funcidx _a__299_ _b__300_ + | Ref_func _, _ -> false + | _, Ref_func _ -> false + | Ref_is_null, Ref_is_null -> true + | Ref_is_null, _ -> false + | _, Ref_is_null -> false + | Ref_null _a__301_, Ref_null _b__302_ -> + equal_heaptype _a__301_ _b__302_ + | Ref_null _, _ -> false + | _, Ref_null _ -> false + | Return, Return -> true + | Return, _ -> false + | _, Return -> false + | Struct_get (_a__303_, _a__305_), Struct_get (_b__304_, _b__306_) -> + Stdlib.( && ) + (equal_typeidx _a__303_ _b__304_) + (equal_fieldidx _a__305_ _b__306_) + | Struct_get _, _ -> false + | _, Struct_get _ -> false + | Struct_new _a__307_, Struct_new _b__308_ -> + equal_typeidx _a__307_ _b__308_ + | Struct_new _, _ -> false + | _, Struct_new _ -> false + | Struct_new_default _a__309_, Struct_new_default _b__310_ -> + equal_typeidx _a__309_ _b__310_ + | Struct_new_default _, _ -> false + | _, Struct_new_default _ -> false + | Struct_set (_a__311_, _a__313_), Struct_set (_b__312_, _b__314_) -> + Stdlib.( && ) + (equal_typeidx _a__311_ _b__312_) + (equal_fieldidx _a__313_ _b__314_) + | Struct_set _, _ -> false + | _, Struct_set _ -> false + | Table_get _a__315_, Table_get _b__316_ -> + equal_tableidx _a__315_ _b__316_ + | Table_get _, _ -> false + | _, Table_get _ -> false + | Unreachable, Unreachable -> true + | Unreachable, _ -> false + | _, Unreachable -> false + | Throw _a__317_, Throw _b__318_ -> equal_tagidx _a__317_ _b__318_ + | Throw _, _ -> false + | _, Throw _ -> false + | Try_table _a__319_, Try_table _b__320_ -> + Stdlib.( && ) + (equal_typeuse _a__319_.typeuse _b__320_.typeuse) + (Stdlib.( && ) + (equal_catchs _a__319_.catchs _b__320_.catchs) + (Ppx_base.equal_list + (fun a__321_ -> + fun (b__322_ [@merlin.hide]) -> + (equal_instr a__321_ b__322_ [@merlin.hide])) + _a__319_.instrs _b__320_.instrs)) + | Try_table _, _ -> false + | _, Try_table _ -> false + | Select, Select -> true + | Select, _ -> false + | _, Select -> false + | No_op, No_op -> true + | No_op, _ -> false + | _, No_op -> false + | Source_pos _a__323_, Source_pos _b__324_ -> + equal_source_pos _a__323_ _b__324_ + | Source_pos _, _ -> false + | _, Source_pos _ -> false + | Prologue_end, Prologue_end -> true + : instr -> instr -> bool) + + let _ = equal_instr end type expr = instr list + +include struct + let _ = fun (_ : expr) -> () + + let equal_expr = + (fun a__325_ -> + fun b__326_ -> + Ppx_base.equal_list + (fun a__327_ -> fun b__328_ -> equal_instr a__327_ b__328_) + a__325_ b__326_ + : expr -> expr -> bool) + + let _ = equal_expr +end + type extra_info = { mutable low_pc : int; mutable high_pc : int } type func = { @@ -1181,7 +3326,13 @@ type func = { } type table = { id : binder; type_ : tabletype; init : expr } + +let default_table_name = "$moonbit.global" + type mem = { id : binder; type_ : memtype } + +let default_memory_name = "$moonbit.memory" + type global = { id : binder; type_ : globaltype; init : expr } type exportdesc = @@ -1198,10 +3349,10 @@ type datamode = DMPassive | DMActive of memidx * expr type data = { id : binder; data_str : string; mode : datamode } type tag = { id : binder; type_ : typeuse } -type 'a mk_modulefield = +type modulefield = | Rectype of rectype | Import of import - | Func of 'a + | Func of func | Table of table | Mem of mem | Global of global @@ -1211,8 +3362,4 @@ type 'a mk_modulefield = | Data of data | Tag of tag -type modulefield = func mk_modulefield -type modulefield_new = W.t mk_modulefield -type 'a mk_module = { id : binder; fields : 'a mk_modulefield list } -type module_ = func mk_module -type module_new = W.t mk_module +type module_ = { id : binder; fields : modulefield list } diff --git a/src/basic_int_util.ml b/src/dwarfsm_basic.ml similarity index 85% rename from src/basic_int_util.ml rename to src/dwarfsm_basic.ml index 205d2f8..3ef90b7 100644 --- a/src/basic_int_util.ml +++ b/src/dwarfsm_basic.ml @@ -13,7 +13,6 @@ *) -let rec power_2_above x n = - if x >= n then x - else if x * 2 > Sys.max_array_length then x - else power_2_above (x * 2) n +type relocatable_pc = int ref * int + +let absolute_pc_of ((base, offset) : relocatable_pc) = base.contents + offset diff --git a/src/dwarfsm_elim_equivdefn.ml b/src/dwarfsm_elim_equivdefn.ml new file mode 100644 index 0000000..17b9a63 --- /dev/null +++ b/src/dwarfsm_elim_equivdefn.ml @@ -0,0 +1,413 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ast = Dwarfsm_ast +module String_table = Basic_hash_string +module StringSet = Basic_set_string + +type fn_table = Ast.func String_table.t +type index_table = string String_table.t +type unchecked_typs = Ast.typeidx list String_table.t +type unchecked_fns = Ast.funcidx list String_table.t +type fnsig = Ast.param list * Ast.result list * Ast.local list + +include struct + let _ = fun (_ : fnsig) -> () + + let equal_fnsig = + (fun a__001_ -> + fun b__002_ -> + let t__003_, t__004_, t__005_ = a__001_ in + let t__006_, t__007_, t__008_ = b__002_ in + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__009_ -> fun b__010_ -> Ast.equal_param a__009_ b__010_) + t__003_ t__006_) + (Stdlib.( && ) + (Ppx_base.equal_list + (fun a__011_ -> fun b__012_ -> Ast.equal_result a__011_ b__012_) + t__004_ t__007_) + (Ppx_base.equal_list + (fun a__013_ -> fun b__014_ -> Ast.equal_local a__013_ b__014_) + t__005_ t__008_)) + : fnsig -> fnsig -> bool) + + let _ = equal_fnsig + + let (hash_fold_fnsig : Ppx_base.state -> fnsig -> Ppx_base.state) = + fun hsv -> + fun arg -> + let e0, e1, e2 = arg in + let hsv = Ppx_base.hash_fold_list Ast.hash_fold_param hsv e0 in + let hsv = Ppx_base.hash_fold_list Ast.hash_fold_result hsv e1 in + let hsv = Ppx_base.hash_fold_list Ast.hash_fold_local hsv e2 in + hsv + + let _ = hash_fold_fnsig + + let (hash_fnsig : fnsig -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_fnsig hsv arg) + in + fun x -> func x + + let _ = hash_fnsig +end + +module SubtypHash = struct + type t = Ast.subtype + + let equal = Ast.equal_subtype + let hash = Ast.hash_subtype + let sexp_of_t _ = assert false +end + +module SubtypMap = Basic_hashf.Make (SubtypHash) + +module FnSigHash = struct + type t = fnsig + + let equal = equal_fnsig + let hash = hash_fnsig + let sexp_of_t _ = assert false +end + +module FnSigMap = Basic_hashf.Make (FnSigHash) + +let equal_funcidx = Ast.equal_funcidx +and equal_typeuse = Ast.equal_typeuse +and equal_catchs = Ast.equal_catchs +and equal_instr = Ast.equal_instr + +module Implicits (Arg : sig + val unchecked_fns : unchecked_fns + val unchecked_typs : unchecked_typs + val type_equiv_relation : index_table + val func_equiv_relation : index_table + val fns : fn_table + val subtyp_set : string SubtypMap.t + val func_set : Ast.func list FnSigMap.t +end) = +struct + let unchecked_fns = Arg.unchecked_fns + let unchecked_typs = Arg.unchecked_typs + let type_equiv_relation = Arg.type_equiv_relation + let func_equiv_relation = Arg.func_equiv_relation + let fns = Arg.fns + let subtyp_set = Arg.subtyp_set + let func_set = Arg.func_set + + let add_unchecked_typ name idx = + match String_table.find_opt unchecked_typs name with + | None -> String_table.add unchecked_typs name [ idx ] + | Some fns -> String_table.replace unchecked_typs name (idx :: fns) + + let add_unchecked_fn name idx = + match String_table.find_opt unchecked_fns name with + | None -> String_table.add unchecked_fns name [ idx ] + | Some fns -> String_table.replace unchecked_fns name (idx :: fns) + + let rewrite_typeidx (typeidx : Ast.typeidx) = + match[@warning "-fragile-match"] typeidx.var with + | Unresolve name -> ( + match String_table.find_opt type_equiv_relation name with + | None -> add_unchecked_typ name typeidx + | Some rootname -> typeidx.var <- Unresolve rootname) + | _ -> assert false + + let rewrite_funcidx (funcidx : Ast.funcidx) = + match[@warning "-fragile-match"] funcidx.var with + | Unresolve name -> ( + match String_table.find_opt func_equiv_relation name with + | None -> add_unchecked_fn name funcidx + | Some rootname -> funcidx.var <- Unresolve rootname) + | _ -> assert false + + let rewrite_valtype (valtype : Ast.valtype) = + match valtype with + | Reftype (Ref (_, Type typeidx)) -> rewrite_typeidx typeidx + | _ -> () + + let rewrite_local (local : Ast.local) = rewrite_valtype local.type_ + + let rewrite_subtype (subtype : Ast.subtype) = + let rewrite_fieldtype (fieldtype : Ast.fieldtype) = + match fieldtype.type_ with + | Valtype valtype -> rewrite_valtype valtype + | _ -> () + in + let rewrite_field (field : Ast.field) = rewrite_fieldtype field.fieldtype in + match subtype.type_ with + | Arraytype (Array fieldtype) -> rewrite_fieldtype fieldtype + | Structtype (Struct fieldlist) -> Basic_lst.iter fieldlist ~f:rewrite_field + | Functype (Func (params, results)) -> + Basic_lst.iter params ~f:rewrite_local; + Basic_lst.iter results ~f:rewrite_valtype + + let rewrite_typeuse (typeuse : Ast.typeuse) = + match typeuse with + | Use (typeidx, params, results) -> + rewrite_typeidx typeidx; + Basic_lst.iter params ~f:rewrite_local; + Basic_lst.iter results ~f:rewrite_valtype + | Inline (params, results) -> + Basic_lst.iter params ~f:rewrite_local; + Basic_lst.iter results ~f:rewrite_valtype + + let rewrite_fnsig (fnsig : fnsig) = + let params, results, locals = fnsig in + Basic_lst.iter params ~f:rewrite_local; + Basic_lst.iter results ~f:rewrite_valtype; + Basic_lst.iter locals ~f:rewrite_local + + let rewrite_typedef (typedef : Ast.typedef) = + let binder, subtype = typedef in + rewrite_subtype subtype; + match[@warning "-fragile-match"] binder with + | { id = Some name; _ } -> ( + match SubtypMap.find_opt subtyp_set subtype with + | None -> + SubtypMap.add subtyp_set subtype name; + String_table.add type_equiv_relation name name; + Some (binder, subtype) + | Some rootname -> + String_table.add type_equiv_relation name rootname; + (match String_table.find_opt unchecked_typs name with + | None -> () + | Some typeidxes -> + Basic_lst.iter typeidxes ~f:(fun (idx : Ast.typeidx) -> + idx.var <- Unresolve rootname)); + None) + | _ -> assert false + + let get_fnsig (func : Ast.func) = + match func.type_ with + | Use (typeidx, params, results) -> + rewrite_typeidx typeidx; + (params, results, func.locals) + | Inline (params, results) -> (params, results, func.locals) + + let rec equal_instrs_with ~(visited_l : StringSet.t) + ~(visited_r : StringSet.t) (lhs : Ast.instr list) (rhs : Ast.instr list) = + match (lhs, rhs) with + | [], [] -> true + | instr_l :: lhs, instr_r :: rhs -> + (match (instr_l, instr_r) with + | ( Call ({ var = Unresolve name_l } as funcidx_l), + Call ({ var = Unresolve name_r } as funcidx_r) ) + | ( Ref_func ({ var = Unresolve name_l; _ } as funcidx_l), + Ref_func ({ var = Unresolve name_r; _ } as funcidx_r) ) -> ( + (StringSet.mem visited_l name_l && StringSet.mem visited_r name_r) + || equal_funcidx funcidx_l funcidx_r + || + let left = String_table.find_opt fns name_l in + let right = String_table.find_opt fns name_r in + match (left, right) with + | Some left, Some right -> ( + match[@warning "-fragile-match"] (left.id, right.id) with + | { id = Some name_l; _ }, { id = Some name_r; _ } -> + let visited_l = StringSet.add visited_l name_l in + let visited_r = StringSet.add visited_r name_r in + rewrite_instrs left.code; + rewrite_instrs right.code; + let lhs = left.code in + let rhs = right.code in + equal_instrs_with ~visited_l ~visited_r lhs rhs + | _ -> assert false) + | _ -> false) + | ( Try_table + { typeuse = typeuse_l; catchs = catchs_l; instrs = code_l; _ }, + Try_table + { typeuse = typeuse_r; catchs = catchs_r; instrs = code_r; _ } ) + -> + equal_typeuse typeuse_l typeuse_r + && equal_catchs catchs_l catchs_r + && equal_instrs_with ~visited_l ~visited_r code_l code_r + | ( Loop { typeuse = typeuse_l; instrs = code_l; _ }, + Loop { typeuse = typeuse_r; instrs = code_r; _ } ) -> + equal_typeuse typeuse_l typeuse_r + && equal_instrs_with ~visited_l ~visited_r code_l code_r + | ( Block { typeuse = typeuse_l; instrs = code_l; _ }, + Block { typeuse = typeuse_r; instrs = code_r; _ } ) -> + equal_typeuse typeuse_l typeuse_r + && equal_instrs_with ~visited_l ~visited_r code_l code_r + | ( If { typeuse = typeuse_l; then_ = then_l; else_ = else_l; _ }, + If { typeuse = typeuse_r; then_ = then_r; else_ = else_r; _ } ) -> + equal_typeuse typeuse_l typeuse_r + && equal_instrs_with ~visited_l ~visited_r then_l then_r + && equal_instrs_with ~visited_l ~visited_r else_l else_r + | _ -> equal_instr instr_l instr_r) + && equal_instrs_with ~visited_l ~visited_r lhs rhs + | _ -> false + + and rewrite_instrs (instrs : Ast.instr list) = + match instrs with + | [] -> () + | instr :: instrs -> + (match instr with + | Array_copy (typeidx1, typeidx2) -> + rewrite_typeidx typeidx1; + rewrite_typeidx typeidx2 + | Array_fill typeidx -> rewrite_typeidx typeidx + | Array_get typeidx -> rewrite_typeidx typeidx + | Array_get_s typeidx -> rewrite_typeidx typeidx + | Array_get_u typeidx -> rewrite_typeidx typeidx + | Array_new typeidx -> rewrite_typeidx typeidx + | Array_new_data (typeidx, _) -> rewrite_typeidx typeidx + | Array_new_default typeidx -> rewrite_typeidx typeidx + | Array_new_fixed (typeidx, _) -> rewrite_typeidx typeidx + | Array_set typeidx -> rewrite_typeidx typeidx + | Call funcidx -> rewrite_funcidx funcidx + | Call_indirect (_, typeuse) -> rewrite_typeuse typeuse + | Call_ref typeidx -> rewrite_typeidx typeidx + | Ref_cast (Ref (_, Type typeidx)) -> rewrite_typeidx typeidx + | Ref_func funcidx -> rewrite_funcidx funcidx + | Ref_null (Type typeidx) -> rewrite_typeidx typeidx + | Struct_get (typeidx, _) -> rewrite_typeidx typeidx + | Struct_new typeidx -> rewrite_typeidx typeidx + | Struct_new_default typeidx -> rewrite_typeidx typeidx + | Struct_set (typeidx, _) -> rewrite_typeidx typeidx + | Try_table { typeuse; instrs; _ } + | Loop { typeuse; instrs; _ } + | Block { typeuse; instrs; _ } -> + rewrite_typeuse typeuse; + rewrite_instrs instrs + | If { typeuse; then_; else_; _ } -> + rewrite_typeuse typeuse; + rewrite_instrs then_; + rewrite_instrs else_ + | _ -> ()); + rewrite_instrs instrs + + let rewrite_func (func : Ast.func) = + (match[@warning "-fragile-match"] func.id with + | { id = Some name; _ } -> ( + let fnsig = get_fnsig func in + rewrite_fnsig fnsig; + rewrite_instrs func.code; + match FnSigMap.find_opt func_set fnsig with + | None -> + FnSigMap.add func_set fnsig [ func ]; + String_table.add func_equiv_relation name name; + Some func + | Some funclist -> + let res = ref (Some func) in + let rec aux (funcs : Ast.func list) = + match funcs with + | [] -> + FnSigMap.replace func_set fnsig (func :: funclist); + String_table.add func_equiv_relation name name + | f :: funcs -> ( + match[@warning "-fragile-match"] f.id with + | { id = Some fname; _ } -> + if + equal_instrs_with + ~visited_l:(StringSet.singleton fname) + ~visited_r:(StringSet.singleton name) f.code + func.code + then ( + res := None; + match[@warning "-fragile-match"] f.id with + | { id = Some rootname; _ } -> ( + String_table.add func_equiv_relation name rootname; + match String_table.find_opt unchecked_fns name with + | None -> () + | Some funcidxes -> + Basic_lst.iter funcidxes + ~f:(fun (idx : Ast.funcidx) -> + idx.var <- Unresolve rootname)) + | _ -> assert false) + else aux funcs + | _ -> assert false) + in + aux funclist; + !res) + | _ -> assert false + : Ast.func option) + + let elim_equiv_defn (module_ : Ast.module_) = + (let rec aux (mfs : Ast.modulefield list) = + match mfs with + | [] -> [] + | mf :: mfs -> ( + match mf with + | Import { desc = Func (funcidx, _); _ } -> ( + match[@warning "-fragile-match"] funcidx with + | { id = Some name; _ } -> + String_table.add func_equiv_relation name name; + mf :: aux mfs + | _ -> assert false) + | Global { type_ = { type_ = valtype; _ }; init; _ } -> + rewrite_valtype valtype; + rewrite_instrs init; + mf :: aux mfs + | Rectype (typedef :: []) -> ( + match rewrite_typedef typedef with + | None -> aux mfs + | Some typedef -> Ast.Rectype [ typedef ] :: aux mfs) + | Rectype typedefs -> + let typedefs = + List.concat_map + (fun typedef -> + match rewrite_typedef typedef with + | None -> [] + | Some typedef -> [ typedef ]) + typedefs + in + Ast.Rectype typedefs :: aux mfs + | Func func -> ( + match rewrite_func func with + | None -> aux mfs + | Some func -> Ast.Func func :: aux mfs) + | Export { desc = Func funcidx; _ } | Start funcidx -> + rewrite_funcidx funcidx; + mf :: aux mfs + | Elem { list; _ } -> + Basic_lst.iter list ~f:rewrite_instrs; + mf :: aux mfs + | _ -> mf :: aux mfs) + in + let module_ = { module_ with fields = aux module_.fields } in + module_ + : Ast.module_) +end + +let create_fn_table (mfs : Ast.modulefield list) = + (let fns = String_table.create 400 in + let aux (mf : Ast.modulefield) = + match mf with + | Func ({ id = { id = Some name; _ }; _ } as func) -> + String_table.add fns name func + | _ -> () + in + Basic_lst.iter mfs ~f:aux; + fns + : fn_table) + +let elim_equiv_defn (module_ : Ast.module_) = + (let module I = Implicits (struct + let type_equiv_relation : index_table = String_table.create 500 + let func_equiv_relation : index_table = String_table.create 500 + let unchecked_fns : unchecked_fns = String_table.create 500 + let unchecked_typs : unchecked_typs = String_table.create 500 + let subtyp_set = SubtypMap.create 500 + let func_set = FnSigMap.create 500 + let fns = create_fn_table module_.fields + end) in + Dwarfsm_local_resolve.resolve module_; + I.elim_equiv_defn module_ + : Ast.module_) diff --git a/src/dwarfsm_encode.ml b/src/dwarfsm_encode.ml index a0047d7..d4a6b32 100644 --- a/src/dwarfsm_encode.ml +++ b/src/dwarfsm_encode.ml @@ -13,7 +13,6 @@ *) -module Config = Basic_config module Byteseq = Basic_byteseq module Vec = Basic_vec module Hash_string = Basic_hash_string @@ -33,16 +32,14 @@ and json_string = Basic_encoders.json_string let equal_code_pos (pc1, (pos1 : Ast.source_pos)) (pc2, (pos2 : Ast.source_pos)) = - Dwarf_basic.absolute_pc_of pc1 = Dwarf_basic.absolute_pc_of pc2 + Dwarfsm_basic.absolute_pc_of pc1 = Dwarfsm_basic.absolute_pc_of pc2 && pos1.pkg = pos2.pkg && pos1.file = pos2.file && pos1.line = pos2.line && pos1.col = pos2.col let module_ ~emit_names m = let ctx = Encode_context.make_context () in Encode_resolve.resolve ctx m; - let wasm = - Encode_wasm.encode ~emit_names ctx - in + let wasm = Encode_wasm.encode ~emit_names ctx in Byteseq.to_string wasm let module_with_source_map ~file ?source_map_url ?source_loader m = @@ -133,7 +130,7 @@ let module_with_source_map ~file ?source_map_url ?source_loader m = in if not !no_comma_mappings then mappings_buf ^^= string ","; no_comma_mappings := false; - let addr = codesec_offset + Dwarf_basic.absolute_pc_of rel_pc in + let addr = codesec_offset + Dwarfsm_basic.absolute_pc_of rel_pc in mappings_buf ^^= field addr last_addr ^^ field file_index last_src_file ^^ field line last_src_line diff --git a/src/dwarfsm_encode_context.ml b/src/dwarfsm_encode_context.ml index 57a66b8..a0e2fdf 100644 --- a/src/dwarfsm_encode_context.ml +++ b/src/dwarfsm_encode_context.ml @@ -43,8 +43,6 @@ type spaces = { tags : space; } -type extra_info = { mutable low_pc : int; mutable high_pc : int } - type context = { spaces : spaces; types : rectype Vec.t; @@ -57,8 +55,8 @@ type context = { mutable start : start option; elems : elem Vec.t; datas : data Vec.t; - aux : extra_info; tags : tag Vec.t; + aux : Dwarfsm_ast.extra_info; } let make_space () = { next_index = 0; map = Hash_string.create 0 } @@ -88,6 +86,6 @@ let make_context () = start = None; elems = Vec.empty (); datas = Vec.empty (); - aux = { low_pc = 0; high_pc = 0 }; tags = Vec.empty (); + aux = { low_pc = 0; high_pc = 0 }; } diff --git a/src/dwarfsm_encode_resolve.ml b/src/dwarfsm_encode_resolve.ml index d5cc099..c69cccf 100644 --- a/src/dwarfsm_encode_resolve.ml +++ b/src/dwarfsm_encode_resolve.ml @@ -77,11 +77,11 @@ struct | Import ip -> ( Vec.push ctx.imports ip; match ip.desc with - | Func (id, _) -> bind_func id |> ignore - | Table (id, _) -> bind_table id |> ignore - | Memory (id, _) -> bind_mem id |> ignore - | Global (id, _) -> bind_global id |> ignore - | Tag (id, _) -> bind_tag id |> ignore) + | Func (id, _) -> ignore (bind_func id) + | Table (id, _) -> ignore (bind_table id) + | Memory (id, _) -> ignore (bind_mem id) + | Global (id, _) -> ignore (bind_global id) + | Tag (id, _) -> ignore (bind_tag id)) | _ -> () let non_import_field (mf : modulefield) = @@ -89,11 +89,11 @@ struct | Import _ -> () | Rectype rt -> Vec.push ctx.types rt; - let field ~struct_type_index ((id, _ft) : field) = - bind_field struct_type_index id |> ignore + let field ~struct_type_index (field : field) = + ignore (bind_field struct_type_index field.id) in let structtype ~index (Struct ft : structtype) = - List.iter (field ~struct_type_index:index) ft + Basic_lst.iter ft ~f:(field ~struct_type_index:index) in let comptype ~index (ct : comptype) = match ct with Structtype t -> structtype ~index t | _ -> () @@ -103,7 +103,7 @@ struct let index = bind_type id in subtype ~index st in - List.iter typedef rt + Basic_lst.iter rt ~f:typedef | Func fn -> Vec.push ctx.funcs fn; let index = bind_func fn.id in @@ -111,39 +111,39 @@ struct match fn.type_ with Use (_, pts, _) -> pts | Inline (pts, _) -> pts in let param ~func_index ({ id; _ } : param) = - bind_local func_index id |> ignore + ignore (bind_local func_index id) in let local ~func_index ({ id; _ } : local) = - bind_local func_index id |> ignore + ignore (bind_local func_index id) in - List.iter (param ~func_index:index) pts; - List.iter (local ~func_index:index) fn.locals + Basic_lst.iter pts ~f:(param ~func_index:index); + Basic_lst.iter fn.locals ~f:(local ~func_index:index) | Table t -> Vec.push ctx.tables t; - bind_table t.id |> ignore + ignore (bind_table t.id) | Mem m -> Vec.push ctx.mems m; - bind_mem m.id |> ignore + ignore (bind_mem m.id) | Global g -> Vec.push ctx.globals g; - bind_global g.id |> ignore + ignore (bind_global g.id) | Export ep -> Vec.push ctx.exports ep | Start s -> - assert (Option.is_none ctx.start); + assert (match ctx.start with None -> true | _ -> false); ctx.start <- Some s | Elem e -> Vec.push ctx.elems e; - bind_elem e.id |> ignore + ignore (bind_elem e.id) | Data d -> Vec.push ctx.datas d; - bind_data d.id |> ignore + ignore (bind_data d.id) | Tag t -> Vec.push ctx.tags t; - bind_tag t.id |> ignore + ignore (bind_tag t.id) let module_ (m : module_) = - Lst.iter m.fields import_field; - Lst.iter m.fields non_import_field + Lst.iter m.fields ~f:import_field; + Lst.iter m.fields ~f:non_import_field end let resolve ctx module_ = diff --git a/src/dwarfsm_encode_wasm.ml b/src/dwarfsm_encode_wasm.ml index 6b4de38..1b6eed3 100644 --- a/src/dwarfsm_encode_wasm.ml +++ b/src/dwarfsm_encode_wasm.ml @@ -21,7 +21,6 @@ module Hash_int = Basic_hash_int module Encode_context = Dwarfsm_encode_context module Ast = Dwarfsm_ast -type index = Ast.index type binder = Ast.binder type label = Ast.label type typeidx = Ast.typeidx @@ -65,11 +64,6 @@ type elem = Ast.elem type data = Ast.data type tag = Ast.tag -let vec_of_list l = - let vec = Vec.empty () in - Lst.iter l (fun it -> Vec.push vec it); - vec - module Implicits (Arg : sig val ctx : Encode_context.context val add_code_pos : (int ref * int -> Ast.source_pos -> unit) option @@ -121,22 +115,15 @@ struct let ( ^^ ) = Byteseq.concat let magic = Byteseq.of_string "\000asm" let version = Byteseq.of_string "\001\000\000\000" - let vec_inner vec f = Vec.fold_left ~f:(fun t x -> t ^^ f x) Byteseq.empty vec + + let vec_inner vec f = + Vec.fold_left ~f:(fun t -> fun x -> t ^^ f x) Byteseq.empty vec + let vec vec f = int_uleb128 (Vec.length vec) ^^ vec_inner vec f let byte_vec x = int_uleb128 (String.length x) ^^ Byteseq.of_string x let name x = byte_vec x let mut = function Ast.Var -> byte 0x01 | Ast.Const -> byte 0x00 - let resolve_index (space : Encode_context.space) (var : index) = - let i = - match var with - | { index; _ } when index <> -1 -> index - | { var_name = Some name; _ } -> Hash_string.find_exn space.map name - | _ -> assert false - in - var.index <- i; - i - let resolve_binder (space : Encode_context.space) (binder : binder) = let i = match binder with @@ -147,46 +134,48 @@ struct binder.index <- i; i - let index space i = - let i = resolve_index space i in - int_sleb128 i - let binder space binder = let i = resolve_binder space binder in int_sleb128 i - let typeidx (i : typeidx) = index spaces.types i + let resolve_var_ (space : Encode_context.space) (v : Ast.var) = + match v with + | Unresolve var_name -> Hash_string.find_exn space.map var_name + | Resolved { index; _ } -> index + + let resolve_var (space : Encode_context.space) (v : Ast.var) = + int_sleb128 (resolve_var_ space v) + + let typeidx (i : typeidx) = resolve_var spaces.types i.var let structandfieldidx (t : typeidx) (f : fieldidx) = - let ti = resolve_index spaces.types t in - typeidx t ^^ index (Hash_int.find_exn spaces.fields ti) f + let typeidx = resolve_var_ spaces.types t.var in + let space = Hash_int.find_exn spaces.fields typeidx in + let fieldidx = resolve_var_ space f.var in + int_sleb128 typeidx ^^ int_sleb128 fieldidx - let funcidx (i : funcidx) = index spaces.funcs i + let funcidx (i : funcidx) = resolve_var spaces.funcs i.var let labelidx (i : labelidx) = - let i = - if i.index >= 0 then i.index - else - let name = Option.get i.var_name in + match i.var with + | Resolved { index; _ } -> int_sleb128 index + | Unresolve name -> let rec aux i (l : label list) = match l with - | { id = Some name'; _ } :: _ when name = name' -> i + | Some name' :: _ when name = name' -> i | [] -> -1 | _ :: l -> aux (i + 1) l in - aux 0 !curr_labels - in - assert (i >= 0); - int_sleb128 i + int_sleb128 (aux 0 !curr_labels) let localidx (i : localidx) = - index (Hash_int.find_exn spaces.locals !curr_func_idx) i + resolve_var (Hash_int.find_exn spaces.locals !curr_func_idx) i.var - let tableidx (i : tableidx) = index spaces.tables i - let memidx (i : memidx) = index spaces.mems i - let globalidx (i : globalidx) = index spaces.globals i - let dataidx (i : dataidx) = index spaces.datas i - let tagidx (i : tagidx) = index spaces.tags i + let tableidx (i : tableidx) = resolve_var spaces.tables i.var + let memidx (i : memidx) = resolve_var spaces.mems i.var + let globalidx (i : globalidx) = resolve_var spaces.globals i.var + let dataidx (i : dataidx) = resolve_var spaces.datas i.var + let tagidx (i : tagidx) = resolve_var spaces.tags i.var let heaptype (ht : heaptype) = match ht with @@ -224,37 +213,39 @@ struct | Valtype vt -> valtype vt let fieldtype (ft : fieldtype) = storagetype ft.type_ ^^ mut ft.mut - let field ((_, ft) : field) = fieldtype ft + let field (field : field) = fieldtype field.fieldtype let param (p : param) = valtype p.type_ let functype (t : functype) = let (Func (pts, rts)) = t in - byte 0x60 ^^ vec (vec_of_list pts) param ^^ vec (vec_of_list rts) valtype + byte 0x60 ^^ vec (Vec.of_list pts) param ^^ vec (Vec.of_list rts) valtype let comptype (ct : comptype) = match ct with | Arraytype (Array ft) -> byte 0x5e ^^ fieldtype ft - | Structtype (Struct ft) -> byte 0x5f ^^ vec (vec_of_list ft) field + | Structtype (Struct ft) -> byte 0x5f ^^ vec (Vec.of_list ft) field | Functype ft -> functype ft let subtype (st : subtype) = if st.super = [] && st.final then comptype st.type_ else byte (if st.final then 0x4f else 0x50) - ^^ vec (vec_of_list st.super) typeidx + ^^ vec (Vec.of_list st.super) typeidx ^^ comptype st.type_ let typedef ((id, st) : typedef) = - let encoded = subtype st |> Byteseq.to_string in - (if match st.type_ with Functype (Func _) -> true | _ -> false then - let encoded_typeidx = binder spaces.types id |> Byteseq.to_string in - Hash_string.replace inline_types encoded encoded_typeidx); + let encoded = Byteseq.to_string (subtype st) in + (match st.type_ with + | Functype (Func _) -> + let encoded_typeidx = Byteseq.to_string (binder spaces.types id) in + Hash_string.replace inline_types encoded encoded_typeidx + | _ -> ()); Byteseq.of_string encoded let rectype (rt : rectype) = match rt with | tdef :: [] -> typedef tdef - | tdefs -> byte 0x4e ^^ vec (vec_of_list tdefs) typedef + | tdefs -> byte 0x4e ^^ vec (Vec.of_list tdefs) typedef let limits (lim : limits) = match lim with @@ -263,21 +254,27 @@ struct byte 0x01 ^^ int32_uleb128 min ^^ int32_uleb128 max let tabletype (t : tabletype) = reftype t.element_type ^^ limits t.limits - let memtype (t : memtype) = limits t.limits + + let memtype (t : memtype) = + match (t.limits.max, t.shared) with + | Some max, true -> + byte 0x03 ^^ int32_uleb128 t.limits.min ^^ int32_uleb128 max + | _ -> limits t.limits + let globaltype (t : globaltype) = valtype t.type_ ^^ mut t.mut let typeuse (t : typeuse) = match t with | Use (id, _, _) -> typeidx id | Inline (pts, rts) -> - let encoded = functype (Func (pts, rts)) |> Byteseq.to_string in + let encoded = Byteseq.to_string (functype (Func (pts, rts))) in let encoded_typeidx = Hash_string.find_or_update inline_types encoded ~update:(fun _ -> let index = spaces.types.next_index in spaces.types.next_index <- index + 1; incr num_distinct_inline_types; inline_types_buf ^^= Byteseq.of_string encoded; - typeidx { var_name = None; index } |> Byteseq.to_string) + Byteseq.to_string (int_sleb128 index)) in Byteseq.of_string encoded_typeidx @@ -300,17 +297,17 @@ struct [ int_uleb128 count ^^ Byteseq.of_string prev_encoded ] | [], None -> [] | l :: ls, None -> - let encoded = local l |> Byteseq.to_string in + let encoded = Byteseq.to_string (local l) in partition (Some (1, encoded)) ls | l :: ls, Some (count, prev_encoded) -> - let encoded = local l |> Byteseq.to_string in + let encoded = Byteseq.to_string (local l) in if String.equal encoded prev_encoded then partition (Some (count + 1, prev_encoded)) ls else (int_uleb128 count ^^ Byteseq.of_string prev_encoded) :: partition (Some (1, encoded)) ls in - vec (vec_of_list (partition None ls)) Fun.id + vec (Vec.of_list (partition None ls)) Fun.id let blocktype (t : typeuse) = match t with @@ -330,6 +327,7 @@ struct | Array_fill x -> byte 0xfb ^^ int_uleb128 16 ^^ typeidx x | Array_get x -> byte 0xfb ^^ int_uleb128 11 ^^ typeidx x | Array_get_u x -> byte 0xfb ^^ int_uleb128 13 ^^ typeidx x + | Array_get_s x -> byte 0xfb ^^ int_uleb128 12 ^^ typeidx x | Array_len -> byte 0xfb ^^ int_uleb128 15 | Array_new x -> byte 0xfb ^^ int_uleb128 6 ^^ typeidx x | Array_new_data (x, y) -> @@ -338,15 +336,15 @@ struct | Array_new_fixed (x, n) -> byte 0xfb ^^ int_uleb128 8 ^^ typeidx x ^^ int32_uleb128 n | Array_set x -> byte 0xfb ^^ int_uleb128 14 ^^ typeidx x - | Block (l, bt, in1) -> - enter_label l (fun () -> - let preceded = byte 0x02 ^^ blocktype bt in + | Block { label; typeuse; instrs } -> + enter_label label (fun () -> + let preceded = byte 0x02 ^^ blocktype typeuse in let base = base + Byteseq.length preceded in - preceded ^^ instr_list ~base in1 ^^ byte 0x0b) + preceded ^^ instr_list ~base instrs ^^ byte 0x0b) | Br l -> byte 0x0c ^^ labelidx l | Br_if l -> byte 0x0d ^^ labelidx l | Br_table (ls, l) -> - byte 0x0e ^^ vec (vec_of_list ls) labelidx ^^ labelidx l + byte 0x0e ^^ vec (Vec.of_list ls) labelidx ^^ labelidx l | Call x -> byte 0x10 ^^ funcidx x | Call_indirect (x, y) -> byte 0x11 ^^ typeuse y ^^ tableidx x | Call_ref x -> byte 0x14 ^^ typeidx x @@ -457,6 +455,15 @@ struct | I32_trunc_sat_f32_u -> byte 0xFC ^^ int_uleb128 1 | I32_trunc_sat_f64_s -> byte 0xFC ^^ int_uleb128 2 | I32_trunc_sat_f64_u -> byte 0xFC ^^ int_uleb128 3 + | I32_atomic_load m -> byte 0xfe ^^ byte 0x10 ^^ memarg m + | I32_atomic_load16_u m -> byte 0xfe ^^ byte 0x13 ^^ memarg m + | I32_atomic_load8_u m -> byte 0xfe ^^ byte 0x12 ^^ memarg m + | I32_atomic_store m -> byte 0xfe ^^ byte 0x17 ^^ memarg m + | I32_atomic_store16 m -> byte 0xfe ^^ byte 0x1a ^^ memarg m + | I32_atomic_store8 m -> byte 0xfe ^^ byte 0x19 ^^ memarg m + | I32_atomic_rmw_cmpxchg m -> byte 0xfe ^^ byte 0x48 ^^ memarg m + | I32_atomic_rmw8_cmpxchg_u m -> byte 0xfe ^^ byte 0x4a ^^ memarg m + | I32_atomic_rmw16_cmpxchg_u m -> byte 0xfe ^^ byte 0x4b ^^ memarg m | I64_add -> byte 0x7c | I64_and -> byte 0x83 | I64_clz -> byte 0x79 @@ -513,32 +520,34 @@ struct | F64x2_mul -> byte 0xFD ^^ int_uleb128 242 | F32x4_add -> byte 0xFD ^^ int_uleb128 228 | F32x4_mul -> byte 0xFD ^^ int_uleb128 230 - | If (l, bt, in1, []) -> - enter_label l (fun () -> - let preceded = byte 0x04 ^^ blocktype bt in + | If { label; typeuse; then_; else_ = [] } -> + enter_label label (fun () -> + let preceded = byte 0x04 ^^ blocktype typeuse in let base = base + Byteseq.length preceded in - preceded ^^ instr_list ~base in1 ^^ byte 0x0b) - | If (l, bt, in1, in2) -> - enter_label l (fun () -> + preceded ^^ instr_list ~base then_ ^^ byte 0x0b) + | If { label; typeuse; then_; else_ } -> + enter_label label (fun () -> let base0 = base in - let preceded = byte 0x04 ^^ blocktype bt in + let preceded = byte 0x04 ^^ blocktype typeuse in let base = base0 + Byteseq.length preceded in - let preceded = preceded ^^ instr_list ~base in1 ^^ byte 0x05 in + let preceded = preceded ^^ instr_list ~base then_ ^^ byte 0x05 in let base = base0 + Byteseq.length preceded in - preceded ^^ instr_list ~base in2 ^^ byte 0x0b) + preceded ^^ instr_list ~base else_ ^^ byte 0x0b) | Local_get x -> byte 0x20 ^^ localidx x | Local_set x -> byte 0x21 ^^ localidx x | Local_tee x -> byte 0x22 ^^ localidx x - | Loop (l, bt, in1) -> - enter_label l (fun () -> - let preceded = byte 0x03 ^^ blocktype bt in + | Loop { label; typeuse; instrs } -> + enter_label label (fun () -> + let preceded = byte 0x03 ^^ blocktype typeuse in let base = base + Byteseq.length preceded in - preceded ^^ instr_list ~base in1 ^^ byte 0x0b) + preceded ^^ instr_list ~base instrs ^^ byte 0x0b) | Memory_init x -> byte 0xfc ^^ int_uleb128 8 ^^ dataidx x ^^ byte 0x00 | Memory_copy -> byte 0xfc ^^ int_uleb128 10 ^^ byte 0x00 ^^ byte 0x00 | Memory_grow -> byte 0x40 ^^ byte 0x00 | Memory_size -> byte 0x3f ^^ byte 0x00 | Memory_fill -> byte 0xfc ^^ int_uleb128 11 ^^ byte 0x00 + | Memory_atomic_notify m -> byte 0xfe ^^ byte 0x00 ^^ memarg m + | Memory_atomic_wait32 m -> byte 0xfe ^^ byte 0x01 ^^ memarg m | Ref_eq -> byte 0xd3 | Ref_as_non_null -> byte 0xd4 | Ref_cast (Ref (NonNull, ht)) -> byte 0xfb ^^ int_uleb128 22 ^^ heaptype ht @@ -555,11 +564,11 @@ struct | Table_get table_idx -> byte 0x25 ^^ tableidx table_idx | Unreachable -> byte 0x00 | Throw x -> byte 0x08 ^^ tagidx x - | Try_table (l, bt, cs, es) -> - let catch_seq = vec (vec_of_list cs) catch in - enter_label l (fun () -> - byte 0x1f ^^ blocktype bt ^^ catch_seq ^^ instr_list ~base es - ^^ byte 0x0b) + | Try_table { label; typeuse; catchs; instrs } -> + let catch_seq = vec (Vec.of_list catchs) catch in + enter_label label (fun () -> + byte 0x1f ^^ blocktype typeuse ^^ catch_seq + ^^ instr_list ~base instrs ^^ byte 0x0b) | Select -> byte 0x1b | No_op -> Byteseq.empty | Source_pos pos -> @@ -571,9 +580,10 @@ struct and instr_list ~base (l : instr list) = List.fold_left - (fun t i -> - let base = base + Byteseq.length t in - t ^^ instr ~base i) + (fun t -> + fun i -> + let base = base + Byteseq.length t in + t ^^ instr ~base i) Byteseq.empty l and expr (e : instr list) = instr_list ~base:0 e ^^ byte 0x0b @@ -621,32 +631,30 @@ struct in match el with | { mode = EMActive (t, e); type_ = Ref (Nullable, Absheaptype Func); _ } - when resolve_index spaces.tables t = 0 -> - int_uleb128 0 ^^ expr e ^^ vec (vec_of_list el.list) funcrefitem + when resolve_var_ spaces.tables t.var = 0 -> + int_uleb128 0 ^^ expr e ^^ vec (Vec.of_list el.list) funcrefitem | { mode = EMPassive; type_ = Ref (NonNull, Absheaptype Func); _ } -> - int_uleb128 1 ^^ byte 0x00 ^^ vec (vec_of_list el.list) funcrefitem + int_uleb128 1 ^^ byte 0x00 ^^ vec (Vec.of_list el.list) funcrefitem | { mode = EMActive (t, e); type_ = Ref (NonNull, Absheaptype Func); _ } -> int_uleb128 2 ^^ tableidx t ^^ expr e ^^ byte 0x00 - ^^ vec (vec_of_list el.list) funcrefitem + ^^ vec (Vec.of_list el.list) funcrefitem | { mode = EMDeclarative; type_ = Ref (NonNull, Absheaptype Func); _ } -> - int_uleb128 3 ^^ byte 0x00 ^^ vec (vec_of_list el.list) funcrefitem + int_uleb128 3 ^^ byte 0x00 ^^ vec (Vec.of_list el.list) funcrefitem | { mode = EMActive (t, e); type_ = Ref (Nullable, Absheaptype Func); _ } - when resolve_index spaces.tables t = 0 -> - int_uleb128 4 ^^ expr e ^^ vec (vec_of_list el.list) funcrefitem + when resolve_var_ spaces.tables t.var = 0 -> + int_uleb128 4 ^^ expr e ^^ vec (Vec.of_list el.list) funcrefitem | { mode = EMPassive; type_; list; _ } -> - int_uleb128 5 ^^ reftype type_ ^^ vec (vec_of_list list) expr + int_uleb128 5 ^^ reftype type_ ^^ vec (Vec.of_list list) expr | { mode = EMActive (t, e); type_; list; _ } -> int_uleb128 6 ^^ tableidx t ^^ expr e ^^ reftype type_ - ^^ vec (vec_of_list list) expr + ^^ vec (Vec.of_list list) expr | { mode = EMDeclarative; type_; list; _ } -> - int_uleb128 7 ^^ reftype type_ ^^ vec (vec_of_list list) expr + int_uleb128 7 ^^ reftype type_ ^^ vec (Vec.of_list list) expr let data (d : data) = match d.mode with | DMPassive -> int_uleb128 1 ^^ byte_vec d.data_str - | DMActive ({ index = 0; _ }, e) -> - int_uleb128 0 ^^ expr e ^^ byte_vec d.data_str - | DMActive (_, _) -> assert false + | DMActive (i, e) -> memidx i ^^ expr e ^^ byte_vec d.data_str let tag (t : tag) = byte 0x00 ^^ typeuse t.type_ @@ -666,13 +674,13 @@ struct in let pairs = Vec.empty () in Hash_string.iter space.map (fun entry -> Vec.push pairs entry); - Vec.sort pairs (fun (_, idx1) (_, idx2) -> idx1 - idx2); + Vec.sort pairs (fun (_, idx1) -> fun (_, idx2) -> idx1 - idx2); vec pairs (fun (name, idx) -> nameassoc idx name) in let indirectnamemap spaces = let pairs = Vec.empty () in Hash_int.iter spaces (fun entry -> Vec.push pairs entry); - Vec.sort pairs (fun (idx1, _) (idx2, _) -> idx1 - idx2); + Vec.sort pairs (fun (idx1, _) -> fun (idx2, _) -> idx1 - idx2); vec pairs (fun (idx, space) -> int_uleb128 idx ^^ namemap space) in customsection "name" @@ -738,17 +746,17 @@ struct | None -> () | Some custom_sections -> let secs = custom_sections () in - Lst.iter secs (fun (name, content) -> + Lst.iter secs ~f:(fun (name, content) -> buf ^^= customsection name content) in !buf end -let encode ?add_code_pos ?set_prologue_end ?custom_sections ~emit_names ctx = +let encode ?add_code_pos ?custom_sections ~emit_names ctx = let module I = Implicits (struct let ctx = ctx let add_code_pos = add_code_pos - let set_prologue_end = set_prologue_end + let set_prologue_end = None let custom_sections = custom_sections let emit_names = emit_names end) in diff --git a/src/dwarfsm_instr_utils.ml b/src/dwarfsm_instr_utils.ml new file mode 100644 index 0000000..9df897d --- /dev/null +++ b/src/dwarfsm_instr_utils.ml @@ -0,0 +1,76 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ast = Dwarfsm_ast + +let rec map (instrs : Ast.instr list) (f : Ast.instr -> Ast.instr) = + match instrs with + | [] -> [] + | instr :: instrs -> + (match instr with + | If { label; typeuse; then_; else_ } -> + let then_ = map then_ f in + let else_ = map else_ f in + f (If { label; typeuse; then_; else_ }) + | Block { label; typeuse; instrs } -> + let instrs = map instrs f in + f (Block { label; typeuse; instrs }) + | Loop { label; typeuse; instrs } -> + let instrs = map instrs f in + f (Loop { label; typeuse; instrs }) + | Try_table { label; typeuse; catchs; instrs } -> + let instrs = map instrs f in + f (Try_table { label; typeuse; catchs; instrs }) + | _ -> f instr) + :: map instrs f + +let rec concat_map (instrs : Ast.instr list) (f : Ast.instr -> Ast.instr list) = + match instrs with + | [] -> [] + | instr :: instrs -> + let res = + match instr with + | If { label; typeuse; then_; else_ } -> + let then_ = concat_map then_ f in + let else_ = concat_map else_ f in + f (If { label; typeuse; then_; else_ }) + | Block { label; typeuse; instrs } -> + let instrs = concat_map instrs f in + f (Block { label; typeuse; instrs }) + | Loop { label; typeuse; instrs } -> + let instrs = concat_map instrs f in + f (Loop { label; typeuse; instrs }) + | Try_table { label; typeuse; catchs; instrs } -> + let instrs = concat_map instrs f in + f (Try_table { label; typeuse; catchs; instrs }) + | _ -> f instr + in + res @ concat_map instrs f +[@@dead "+concat_map"] + +let rec iter (instrs : Ast.instr list) (f : Ast.instr -> unit) = + (match instrs with + | [] -> () + | instr :: instrs -> + f instr; + (match instr with + | If { then_; else_; _ } -> + iter then_ f; + iter else_ f + | Block { instrs; _ } | Loop { instrs; _ } | Try_table { instrs; _ } -> + iter instrs f + | _ -> ()); + iter instrs f + : unit) diff --git a/src/dwarfsm_itype.ml b/src/dwarfsm_itype.ml index fc95b88..b49f7e1 100644 --- a/src/dwarfsm_itype.ml +++ b/src/dwarfsm_itype.ml @@ -20,6 +20,8 @@ type t = | Bool | Unit | Byte + | Int16 + | UInt16 | Int64 | UInt64 | Float @@ -27,36 +29,6 @@ type t = include struct let _ = fun (_ : t) -> () - let equal = (Stdlib.( = ) : t -> t -> bool) - let _ = equal - - let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - Ppx_base.hash_fold_int hsv - (match arg with - | Int -> 0 - | Uint -> 1 - | Char -> 2 - | Bool -> 3 - | Unit -> 4 - | Byte -> 5 - | Int64 -> 6 - | UInt64 -> 7 - | Float -> 8 - | Double -> 9) - : Ppx_base.state -> t -> Ppx_base.state) - - let _ = hash_fold_t - - let (hash : t -> Ppx_base.hash_value) = - let func arg = - Ppx_base.get_hash_value - (let hsv = Ppx_base.create () in - hash_fold_t hsv arg) - in - fun x -> func x - - let _ = hash let sexp_of_t = (function @@ -66,6 +38,8 @@ include struct | Bool -> S.Atom "Bool" | Unit -> S.Atom "Unit" | Byte -> S.Atom "Byte" + | Int16 -> S.Atom "Int16" + | UInt16 -> S.Atom "UInt16" | Int64 -> S.Atom "Int64" | UInt64 -> S.Atom "UInt64" | Float -> S.Atom "Float" @@ -74,19 +48,3 @@ include struct let _ = sexp_of_t end - -let name = function - | Int -> "Int" - | Uint -> "Uint" - | Char -> "Char" - | Bool -> "Bool" - | Unit -> "Unit" - | Byte -> "Byte" - | Int64 -> "Int64" - | UInt64 -> "UInt64" - | Float -> "Float" - | Double -> "Double" - -let byte_size = function - | Int | Uint | Char | Bool | Unit | Byte | Float -> 4 - | Int64 | UInt64 | Double -> 8 diff --git a/src/dwarfsm_local_resolve.ml b/src/dwarfsm_local_resolve.ml new file mode 100644 index 0000000..af72598 --- /dev/null +++ b/src/dwarfsm_local_resolve.ml @@ -0,0 +1,105 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ast = Dwarfsm_ast +module String_table = Basic_hash_string +module Lst = Basic_lst +module Encode_context = Dwarfsm_encode_context + +let resolve_localidx_and_labelidx (fn : Ast.func) = + let local_space = Encode_context.make_space () in + let bind_local (id : Ast.binder) = + let index = local_space.next_index in + local_space.next_index <- local_space.next_index + 1; + let () = + match id.id with + | Some name -> String_table.add local_space.map name index + | None -> () + in + id.index <- index + in + let curr_labels : Ast.label list ref = ref [] in + let enter_label l f = + let prev_labels = !curr_labels in + curr_labels := l :: prev_labels; + let () = f () in + curr_labels := prev_labels + in + let localidx (i : Ast.localidx) = + match i.var with + | Unresolve var_name -> + i.var <- + Ast.Resolved + { var_name; index = String_table.find_exn local_space.map var_name } + | Resolved _ -> () + in + let labelidx (i : Ast.labelidx) = + match i.var with + | Resolved _ -> () + | Unresolve name -> + let rec aux i (l : Ast.label list) = + match l with + | Some name' :: _ when name = name' -> i + | [] -> -1 + | _ :: l -> aux (i + 1) l + in + i.var <- Resolved { var_name = name; index = aux 0 !curr_labels } + in + let rec aux (instrs : Ast.instr list) = + match instrs with + | [] -> () + | instr :: instrs -> + (match instr with + | Br l -> labelidx l + | Br_if l -> labelidx l + | Br_table (ls, l) -> + labelidx l; + Lst.iter ls ~f:labelidx + | Local_get x -> localidx x + | Local_set x -> localidx x + | Local_tee x -> localidx x + | Loop { label; instrs; _ } -> enter_label label (fun () -> aux instrs) + | If { label; then_; else_; _ } -> + enter_label label (fun () -> + aux then_; + aux else_) + | Block { label; instrs; _ } -> enter_label label (fun () -> aux instrs) + | Try_table { label; catchs; instrs; _ } -> + Lst.iter catchs ~f:(fun (catch : Ast.catch) -> + match catch with Catch (_, i) -> labelidx i); + enter_label label (fun () -> aux instrs) + | _ -> ()); + aux instrs + in + let pts = + match fn.type_ with Use (_, pts, _) -> pts | Inline (pts, _) -> pts + in + let param ({ id; _ } : Ast.param) = bind_local id in + let local ({ id; _ } : Ast.local) = bind_local id in + Lst.iter pts ~f:param; + Lst.iter fn.locals ~f:local; + aux fn.code + +let resolve (module_ : Ast.module_) = + let rec aux (mfs : Ast.modulefield list) = + match mfs with + | [] -> () + | mf :: mfs -> + (match mf with + | Func func -> resolve_localidx_and_labelidx func + | _ -> ()); + aux mfs + in + aux module_.fields diff --git a/src/dwarfsm_parse.ml b/src/dwarfsm_parse.ml index c77f00b..3e3fabd 100644 --- a/src/dwarfsm_parse.ml +++ b/src/dwarfsm_parse.ml @@ -14,9 +14,9 @@ module Itype = Dwarfsm_itype +module Lst = Basic_lst module Ast = Dwarfsm_ast -type var = Dwarfsm_ast.var type binder = Dwarfsm_ast.binder type heaptype = Dwarfsm_ast.heaptype type storagetype = Dwarfsm_ast.storagetype @@ -38,8 +38,6 @@ type expr = Dwarfsm_ast.expr type modulefield = Dwarfsm_ast.modulefield type importdesc = Dwarfsm_ast.importdesc type module_ = Dwarfsm_ast.module_ -type modulefield_new = Dwarfsm_ast.modulefield_new -type module_new = Dwarfsm_ast.module_new exception Parse_failure of { input : W.t; syntax : string } exception Unclosed_structured_instr of { instr : string } @@ -54,11 +52,12 @@ let () = syntax; " with input "; W.to_string input; - ]) + ] [@merlin.hide]) | Unclosed_structured_instr { instr } -> Some - ("Dwarfsm parse failure: unclosed structured instruction " ^ instr + (("Dwarfsm parse failure: unclosed structured instruction " ^ instr : Stdlib.String.t) + [@merlin.hide]) | _ -> None) let is_id x = String.starts_with ~prefix:"$" x @@ -156,11 +155,57 @@ let binder : W.t list -> binder * W.t list = function | W.Atom x :: v when is_id x -> ({ id = Some x; index = -1 }, v) | v -> ({ id = None; index = -1 }, v) -let index v : var = - match v with - | W.Atom x when is_id x -> { var_name = Some x; index = -1 } - | W.Atom x when is_nat x -> { var_name = None; index = int_of_string x } - | w -> raise (Parse_failure { input = w; syntax = "index" }) +let label : W.t list -> Ast.label * W.t list = function + | W.Atom x :: v when is_id x -> (Some x, v) + | v -> (None, v) + +let fieldidx v = + (let var : Ast.var = + match v with + | W.Atom x when is_id x -> Unresolve x + | W.Atom x when is_nat x -> + Resolved { var_name = ""; index = int_of_string x } + | w -> raise (Parse_failure { input = w; syntax = "fieldidx" }) + in + { var } + : Ast.fieldidx) + +let var v = + (match v with + | W.Atom x when is_id x -> Unresolve x + | w -> raise (Parse_failure { input = w; syntax = "var" }) + : Ast.var) + +let memidx v = ({ var = var v } : Ast.memidx) +let dataidx v = ({ var = var v } : Ast.dataidx) +let tableidx v = ({ var = var v } : Ast.tableidx) +let funcidx v = ({ var = var v } : Ast.funcidx) +let typeidx v = ({ var = var v } : Ast.typeidx) +let globalidx v = ({ var = var v } : Ast.globalidx) + +let localidx v = + (let var : Ast.var = + match v with + | W.Atom x when is_id x -> Unresolve x + | W.Atom x when is_nat x -> + Resolved { var_name = ""; index = int_of_string x } + | w -> raise (Parse_failure { input = w; syntax = "localidx" }) + in + { var } + : Ast.localidx) + +let labelidx v = + (let var : Ast.var = + match v with + | W.Atom x when is_id x -> Unresolve x + | W.Atom x when is_nat x -> + Resolved { var_name = ""; index = int_of_string x } + | w -> raise (Parse_failure { input = w; syntax = "localidx" }) + in + { var } + : Ast.labelidx) + +let tagidx v = ({ var = var v } : Ast.tagidx) let heaptype : W.t -> heaptype = function | (Atom "any" : W.t) -> Absheaptype Any @@ -173,7 +218,7 @@ let heaptype : W.t -> heaptype = function | (Atom "nofunc" : W.t) -> Absheaptype NoFunc | (Atom "extern" : W.t) -> Absheaptype Extern | (Atom "noextern" : W.t) -> Absheaptype NoExtern - | w -> Type (index w) + | w -> Type (typeidx w) let storagetype : W.t -> storagetype = function | (Atom "i8" : W.t) -> Packedtype I8 @@ -196,7 +241,6 @@ let storagetype : W.t -> storagetype = function Valtype (Reftype (Ref (Nullable, Absheaptype None))) | (Atom "funcref" : W.t) -> Valtype (Reftype (Ref (Nullable, Absheaptype Func))) - | (Atom "func" : W.t) -> Valtype (Reftype (Ref (NonNull, Absheaptype Func))) | (Atom "nullfuncref" : W.t) -> Valtype (Reftype (Ref (Nullable, Absheaptype NoFunc))) | (Atom "externref" : W.t) -> @@ -220,7 +264,6 @@ let valtype : W.t -> valtype = function | (Atom "arrayref" : W.t) -> Reftype (Ref (Nullable, Absheaptype Array)) | (Atom "nullref" : W.t) -> Reftype (Ref (Nullable, Absheaptype None)) | (Atom "funcref" : W.t) -> Reftype (Ref (Nullable, Absheaptype Func)) - | (Atom "func" : W.t) -> Reftype (Ref (NonNull, Absheaptype Func)) | (Atom "nullfuncref" : W.t) -> Reftype (Ref (Nullable, Absheaptype NoFunc)) | (Atom "externref" : W.t) -> Reftype (Ref (Nullable, Absheaptype Extern)) | (Atom "nullexternref" : W.t) -> @@ -236,15 +279,14 @@ let reftype : W.t -> reftype = function | (Atom "arrayref" : W.t) -> Ref (Nullable, Absheaptype Array) | (Atom "nullref" : W.t) -> Ref (Nullable, Absheaptype None) | (Atom "funcref" : W.t) -> Ref (Nullable, Absheaptype Func) - | (Atom "func" : W.t) -> Ref (NonNull, Absheaptype Func) | (Atom "nullfuncref" : W.t) -> Ref (Nullable, Absheaptype NoFunc) | (Atom "externref" : W.t) -> Ref (Nullable, Absheaptype Extern) | (Atom "nullexternref" : W.t) -> Ref (Nullable, Absheaptype NoExtern) | w -> raise (Parse_failure { input = w; syntax = "reftype" }) -let mut p : W.t -> Ast.mut * 'a = function - | (List [ Atom "mut"; w ] : W.t) -> (Var, p w) - | w -> (Const, p w) +let mut p = + (function (List [ Atom "mut"; w ] : W.t) -> (Var, p w) | w -> (Const, p w) + : W.t -> Ast.mut * 'a) let source_name_opt = function | (List [ Atom "source_name"; w ] : W.t) :: v -> (Some (string w), v) @@ -257,6 +299,8 @@ let source_type_inner : W.t -> Itype.t = function | (Atom "bool" : W.t) -> Bool | (Atom "unit" : W.t) -> Unit | (Atom "byte" : W.t) -> Byte + | (Atom "int16" : W.t) -> Int16 + | (Atom "uint16" : W.t) -> UInt16 | (Atom "int64" : W.t) -> Int64 | (Atom "uint64" : W.t) -> UInt64 | (Atom "float" : W.t) -> Float @@ -292,10 +336,11 @@ let field : W.t -> field = match w with | (List [ Atom "field"; name; ty ] : W.t) -> ( match name with - | Atom x when is_id x -> ({ id = Some x; index = -1 }, fieldtype ty) + | Atom x when is_id x -> + { id = { id = Some x; index = -1 }; fieldtype = fieldtype ty } | _ -> fail ()) | (List [ Atom "field"; ty ] : W.t) -> - ({ id = None; index = -1 }, fieldtype ty) + { id = { id = None; index = -1 }; fieldtype = fieldtype ty } | _ -> fail () let rec params : W.t list -> param list * W.t list = @@ -326,7 +371,7 @@ let rec params : W.t list -> param list * W.t list = go (param :: tail) v | [] -> tail in - (go tail v, v3)) + (go tail (List.rev v), v3)) | v -> ([], v) let result : W.t -> valtype = @@ -340,10 +385,10 @@ let result : W.t -> valtype = let comptype : W.t -> comptype = function | (List [ Atom "array"; w ] : W.t) -> Arraytype (Array (fieldtype w)) - | (List (Atom "struct" :: v) : W.t) -> Structtype (Struct (List.map field v)) + | (List (Atom "struct" :: v) : W.t) -> Structtype (Struct (Lst.map v field)) | (List (Atom "func" :: v) : W.t) -> let params, v = params v in - let results = List.map result v in + let results = Lst.map v result in Functype (Func (params, results)) | w -> raise (Parse_failure { input = w; syntax = "comptype" }) @@ -353,7 +398,7 @@ let rec subtype : W.t -> subtype = match w with | (List (Atom "sub" :: v) : W.t) -> let final, v = final v in - let super, v = repeat index v in + let super, v = repeat typeidx v in let w = assert_list_singleton v fail in { final; super; type_ = comptype w } | w -> { final = true; super = []; type_ = comptype w } @@ -374,7 +419,7 @@ let typedef : W.t -> binder * subtype = let typeuse : W.t list -> typeuse * W.t list = function | (List [ Atom "type"; w ] : W.t) :: v -> - let idx = index w in + let idx = typeidx w in let params, v = params v in let results, v = repeat result v in (Use (idx, params, results), v) @@ -389,6 +434,11 @@ let limits : W.t list -> limits * W.t list = function | w :: v when is_nat (symbol w) -> ({ min = u32 w; max = None }, v) | v -> raise (Parse_failure { input = W.List v; syntax = "limits" }) +let shared : W.t list -> bool * W.t list = function + | (Atom "shared" : W.t) :: v -> (true, v) + | (Atom "unshared" : W.t) :: v -> (false, v) + | v -> (false, v) + let local : W.t -> local = fun w -> let fail () = raise (Parse_failure { input = w; syntax = "local" }) in @@ -408,41 +458,69 @@ let offset_opt : W.t list -> int32 option * W.t list = function (Some (Int32.of_string ("0u" ^ lit)), v) | v -> (None, v) +let int32_log2 (i : int32) = + (match i with + | 1l -> 0l + | 2l -> 1l + | 4l -> 2l + | 8l -> 3l + | 16l -> 4l + | 32l -> 5l + | 64l -> 6l + | 128l -> 7l + | 256l -> 8l + | 512l -> 9l + | 1024l -> 10l + | 2048l -> 11l + | 4096l -> 12l + | _ -> assert false + : int32) + let align_opt : W.t list -> int32 option * W.t list = function | Atom s :: v when String.starts_with ~prefix:"align=" s -> let lit = String.sub s 6 (String.length s - 6) in - (Some (Int32.of_string ("0u" ^ lit)), v) + (Some (int32_log2 (Int32.of_string ("0u" ^ lit))), v) | v -> (None, v) let memarg : W.t list -> memarg * W.t list = fun v -> let offset, v = offset_opt v in let align, v = align_opt v in - let offset = offset |> Option.value ~default:0l in - let align = align |> Option.value ~default:0l in + let offset = Option.value ~default:0l offset in + let align = Option.value ~default:0l align in ({ offset; align }, v) +let memarg_n : int32 -> W.t list -> memarg * W.t list = + fun n -> + fun v -> + let offset, v = offset_opt v in + let align, v = align_opt v in + let offset = Option.value ~default:0l offset in + let align = Option.value ~default:n align in + ({ offset; align }, v) + let rec plaininstr : W.t list -> instr * W.t list = function | (Atom "any.convert_extern" : W.t) :: v -> (Any_convert_extern, v) | (Atom "array.copy" : W.t) :: (w : W.t) :: (w2 : W.t) :: v -> - (Array_copy (index w, index w2), v) - | (Atom "array.fill" : W.t) :: (w : W.t) :: v -> (Array_fill (index w), v) - | (Atom "array.get" : W.t) :: (w : W.t) :: v -> (Array_get (index w), v) - | (Atom "array.get_u" : W.t) :: (w : W.t) :: v -> (Array_get_u (index w), v) + (Array_copy (typeidx w, typeidx w2), v) + | (Atom "array.fill" : W.t) :: (w : W.t) :: v -> (Array_fill (typeidx w), v) + | (Atom "array.get" : W.t) :: (w : W.t) :: v -> (Array_get (typeidx w), v) + | (Atom "array.get_s" : W.t) :: (w : W.t) :: v -> (Array_get_s (typeidx w), v) + | (Atom "array.get_u" : W.t) :: (w : W.t) :: v -> (Array_get_u (typeidx w), v) | (Atom "array.len" : W.t) :: v -> (Array_len, v) - | (Atom "array.new" : W.t) :: (w : W.t) :: v -> (Array_new (index w), v) + | (Atom "array.new" : W.t) :: (w : W.t) :: v -> (Array_new (typeidx w), v) | (Atom "array.new_data" : W.t) :: (w : W.t) :: (w2 : W.t) :: v -> - (Array_new_data (index w, index w2), v) + (Array_new_data (typeidx w, dataidx w2), v) | (Atom "array.new_fixed" : W.t) :: (w : W.t) :: (w2 : W.t) :: v -> - (Array_new_fixed (index w, u32 w2), v) + (Array_new_fixed (typeidx w, u32 w2), v) | (Atom "array.new_default" : W.t) :: (w : W.t) :: v -> - (Array_new_default (index w), v) - | (Atom "array.set" : W.t) :: (w : W.t) :: v -> (Array_set (index w), v) + (Array_new_default (typeidx w), v) + | (Atom "array.set" : W.t) :: (w : W.t) :: v -> (Array_set (typeidx w), v) | (Atom "block" : W.t) :: v -> - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let (instrs, v), end_ = - instrlist ?label:label.id ~allow_else:false ~allow_end:true v + instrlist ?label ~allow_else:false ~allow_end:true v in let () = match end_ with @@ -450,21 +528,21 @@ let rec plaininstr : W.t list -> instr * W.t list = function | `End -> () | `Nil -> raise (Unclosed_structured_instr { instr = "block" }) in - (Block (label, type_, instrs), v) - | (Atom "br" : W.t) :: (w : W.t) :: v -> (Br (index w), v) - | (Atom "br_if" : W.t) :: (w : W.t) :: v -> (Br_if (index w), v) + (Block { label; typeuse = type_; instrs }, v) + | (Atom "br" : W.t) :: (w : W.t) :: v -> (Br (labelidx w), v) + | (Atom "br_if" : W.t) :: (w : W.t) :: v -> (Br_if (labelidx w), v) | (Atom "br_table" : W.t) :: v -> - let labels, v = repeat index v in + let labels, v = repeat labelidx v in let labels, last_label = Basic_lst.split_at_last labels in (Br_table (labels, last_label), v) - | (Atom "call" : W.t) :: (w : W.t) :: v -> (Call (index w), v) + | (Atom "call" : W.t) :: (w : W.t) :: v -> (Call (funcidx w), v) | (Atom "call_indirect" : W.t) :: (w : W.t) :: v when is_symbol w -> let type_, v = typeuse v in - (Call_indirect (index w, type_), v) + (Call_indirect (tableidx w, type_), v) | (Atom "call_indirect" : W.t) :: v -> let type_, v = typeuse v in - (Call_indirect ({ var_name = None; index = 0 }, type_), v) - | (Atom "call_ref" : W.t) :: (w : W.t) :: v -> (Call_ref (index w), v) + (Call_indirect ({ var = Unresolve Ast.default_table_name }, type_), v) + | (Atom "call_ref" : W.t) :: (w : W.t) :: v -> (Call_ref (typeidx w), v) | (Atom "drop" : W.t) :: v -> (Drop, v) | (Atom "extern.convert_any" : W.t) :: v -> (Extern_convert_any, v) | (Atom "f64.add" : W.t) :: v -> (F64_add, v) @@ -534,8 +612,8 @@ let rec plaininstr : W.t list -> instr * W.t list = function | (Atom "i32.trunc_f32_u" : W.t) :: v -> (I32_trunc_f32_u, v) | (Atom "i64.trunc_f32_s" : W.t) :: v -> (I64_trunc_f32_s, v) | (Atom "i64.trunc_f32_u" : W.t) :: v -> (I64_trunc_f32_u, v) - | (Atom "global.get" : W.t) :: (w : W.t) :: v -> (Global_get (index w), v) - | (Atom "global.set" : W.t) :: (w : W.t) :: v -> (Global_set (index w), v) + | (Atom "global.get" : W.t) :: (w : W.t) :: v -> (Global_get (globalidx w), v) + | (Atom "global.set" : W.t) :: (w : W.t) :: v -> (Global_set (globalidx w), v) | (Atom "i32.add" : W.t) :: v -> (I32_add, v) | (Atom "i32.and" : W.t) :: v -> (I32_and, v) | (Atom "i32.clz" : W.t) :: v -> (I32_clz, v) @@ -598,6 +676,33 @@ let rec plaininstr : W.t list -> instr * W.t list = function | (Atom "i32.trunc_sat_f32_u" : W.t) :: v -> (I32_trunc_sat_f32_u, v) | (Atom "i32.trunc_sat_f64_s" : W.t) :: v -> (I32_trunc_sat_f64_s, v) | (Atom "i32.trunc_sat_f64_u" : W.t) :: v -> (I32_trunc_sat_f64_u, v) + | (Atom "i32.atomic.load" : W.t) :: v -> + let memarg, v = memarg_n 2l v in + (I32_atomic_load memarg, v) + | (Atom "i32.atomic.load8_u" : W.t) :: v -> + let memarg, v = memarg_n 0l v in + (I32_atomic_load8_u memarg, v) + | (Atom "i32.atomic.load16_u" : W.t) :: v -> + let memarg, v = memarg_n 1l v in + (I32_atomic_load16_u memarg, v) + | (Atom "i32.atomic.store" : W.t) :: v -> + let memarg, v = memarg_n 2l v in + (I32_atomic_store memarg, v) + | (Atom "i32.atomic.store8" : W.t) :: v -> + let memarg, v = memarg_n 0l v in + (I32_atomic_store8 memarg, v) + | (Atom "i32.atomic.store16" : W.t) :: v -> + let memarg, v = memarg_n 1l v in + (I32_atomic_store16 memarg, v) + | (Atom "i32.atomic.rmw.cmpxchg" : W.t) :: v -> + let memarg, v = memarg_n 2l v in + (I32_atomic_rmw_cmpxchg memarg, v) + | (Atom "i32.atomic.rmw8.cmpxchg_u" : W.t) :: v -> + let memarg, v = memarg_n 0l v in + (I32_atomic_rmw8_cmpxchg_u memarg, v) + | (Atom "i32.atomic.rmw16.cmpxchg_u" : W.t) :: v -> + let memarg, v = memarg_n 1l v in + (I32_atomic_rmw16_cmpxchg_u memarg, v) | (Atom "i64.add" : W.t) :: v -> (I64_add, v) | (Atom "i64.and" : W.t) :: v -> (I64_and, v) | (Atom "i64.clz" : W.t) :: v -> (I64_clz, v) @@ -681,15 +786,15 @@ let rec plaininstr : W.t list -> instr * W.t list = function | (Atom "f32x4.add" : W.t) :: v -> (F32x4_add, v) | (Atom "f32x4.mul" : W.t) :: v -> (F32x4_mul, v) | (Atom "if" : W.t) :: v -> ( - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let (instrs, v), (end_ : [ `Else | `End | `Nil ]) = - instrlist ?label:label.id ~allow_else:true ~allow_end:true v + instrlist ?label ~allow_else:true ~allow_end:true v in match end_ with | `Else -> let (instrs2, v), end_ = - instrlist ?label:label.id ~allow_else:false ~allow_end:true v + instrlist ?label ~allow_else:false ~allow_end:true v in let () = match end_ with @@ -697,17 +802,17 @@ let rec plaininstr : W.t list -> instr * W.t list = function | `End -> () | `Nil -> raise (Unclosed_structured_instr { instr = "if" }) in - (If (label, type_, instrs, instrs2), v) - | `End -> (If (label, type_, instrs, []), v) + (If { label; typeuse = type_; then_ = instrs; else_ = instrs2 }, v) + | `End -> (If { label; typeuse = type_; then_ = instrs; else_ = [] }, v) | `Nil -> raise (Unclosed_structured_instr { instr = "if" })) - | (Atom "local.get" : W.t) :: (w : W.t) :: v -> (Local_get (index w), v) - | (Atom "local.set" : W.t) :: (w : W.t) :: v -> (Local_set (index w), v) - | (Atom "local.tee" : W.t) :: (w : W.t) :: v -> (Local_tee (index w), v) + | (Atom "local.get" : W.t) :: (w : W.t) :: v -> (Local_get (localidx w), v) + | (Atom "local.set" : W.t) :: (w : W.t) :: v -> (Local_set (localidx w), v) + | (Atom "local.tee" : W.t) :: (w : W.t) :: v -> (Local_tee (localidx w), v) | (Atom "loop" : W.t) :: v -> - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let (instrs, v), _end = - instrlist ?label:label.id ~allow_else:false ~allow_end:true v + instrlist ?label ~allow_else:false ~allow_end:true v in let () = match _end with @@ -715,29 +820,35 @@ let rec plaininstr : W.t list -> instr * W.t list = function | `End -> () | `Nil -> raise (Unclosed_structured_instr { instr = "loop" }) in - (Loop (label, type_, instrs), v) - | (Atom "memory.init" : W.t) :: (w : W.t) :: v -> (Memory_init (index w), v) + (Loop { label; typeuse = type_; instrs }, v) + | (Atom "memory.init" : W.t) :: (w : W.t) :: v -> (Memory_init (dataidx w), v) | (Atom "memory.copy" : W.t) :: v -> (Memory_copy, v) | (Atom "memory.grow" : W.t) :: v -> (Memory_grow, v) | (Atom "memory.size" : W.t) :: v -> (Memory_size, v) | (Atom "memory.fill" : W.t) :: v -> (Memory_fill, v) + | (Atom "memory.atomic.wait32" : W.t) :: v -> + let memarg, v = memarg_n 2l v in + (Memory_atomic_wait32 memarg, v) + | (Atom "memory.atomic.notify" : W.t) :: v -> + let memarg, v = memarg_n 2l v in + (Memory_atomic_notify memarg, v) | (Atom "ref.eq" : W.t) :: v -> (Ref_eq, v) | (Atom "ref.as_non_null" : W.t) :: v -> (Ref_as_non_null, v) | (Atom "ref.cast" : W.t) :: (w : W.t) :: v -> (Ref_cast (reftype w), v) - | (Atom "ref.func" : W.t) :: (w : W.t) :: v -> (Ref_func (index w), v) + | (Atom "ref.func" : W.t) :: (w : W.t) :: v -> (Ref_func (funcidx w), v) | (Atom "ref.is_null" : W.t) :: v -> (Ref_is_null, v) | (Atom "ref.null" : W.t) :: (w : W.t) :: v -> (Ref_null (heaptype w), v) | (Atom "return" : W.t) :: v -> (Return, v) | (Atom "struct.get" : W.t) :: (w : W.t) :: (w2 : W.t) :: v -> - (Struct_get (index w, index w2), v) - | (Atom "struct.new" : W.t) :: (w : W.t) :: v -> (Struct_new (index w), v) + (Struct_get (typeidx w, fieldidx w2), v) + | (Atom "struct.new" : W.t) :: (w : W.t) :: v -> (Struct_new (typeidx w), v) | (Atom "struct.new_default" : W.t) :: (w : W.t) :: v -> - (Struct_new_default (index w), v) + (Struct_new_default (typeidx w), v) | (Atom "struct.set" : W.t) :: (w : W.t) :: (w2 : W.t) :: v -> - (Struct_set (index w, index w2), v) - | (Atom "table.get" : W.t) :: (w : W.t) :: v -> (Table_get (index w), v) + (Struct_set (typeidx w, fieldidx w2), v) + | (Atom "table.get" : W.t) :: (w : W.t) :: v -> (Table_get (tableidx w), v) | (Atom "unreachable" : W.t) :: v -> (Unreachable, v) - | (Atom "throw" : W.t) :: (w : W.t) :: v -> (Throw (index w), v) + | (Atom "throw" : W.t) :: (w : W.t) :: v -> (Throw (tagidx w), v) | (Atom "select" : W.t) :: v -> (Select, v) | (Atom "nop" : W.t) :: v -> (No_op, v) | (Atom "source_pos" : W.t) @@ -759,45 +870,45 @@ let rec plaininstr : W.t list -> instr * W.t list = function and foldedinstr : W.t -> instr list = function | (List (Atom "block" :: v) : W.t) -> - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let instrs = expr v in - [ Block (label, type_, instrs) ] + [ Block { label; typeuse = type_; instrs } ] | (List (Atom "loop" :: v) : W.t) -> - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let instrs = expr v in - [ Loop (label, type_, instrs) ] + [ Loop { label; typeuse = type_; instrs } ] | (List (Atom "if" :: v) : W.t) as w -> let fail () = raise (Parse_failure { input = w; syntax = "if" }) in - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in let instrs, v = repeat foldedinstr v in - let instrs1, v = + let then_, v = match v with | (List (Atom "then" :: v2) : W.t) :: v -> (expr v2, v) | v -> ([], v) in - let instrs2, v = + let else_, v = match v with | (List (Atom "else" :: v2) : W.t) :: v -> (expr v2, v) | v -> ([], v) in assert_list_empty v fail; - List.flatten instrs @ [ If (label, type_, instrs1, instrs2) ] + Lst.concat instrs @ [ If { label; typeuse = type_; then_; else_ } ] | (List (Atom "try_table" :: v) : W.t) -> - let label, v = binder v in + let label, v = label v in let type_, v = typeuse v in - let cs, v = repeat catch v in - let es = expr v in - [ Try_table (label, type_, cs, es) ] + let catchs, v = repeat catch v in + let instrs = expr v in + [ Try_table { label; typeuse = type_; catchs; instrs } ] | (List (w :: v) : W.t) -> let instr, v = plaininstr (w :: v) in Basic_lst.flat_map_append ~f:foldedinstr v ~init:[ instr ] | w -> raise (Parse_failure { input = w; syntax = "foldedinstr" }) and catch : W.t -> catch = function - | (List [ Atom "catch"; w1; w2 ] : W.t) -> Catch (index w1, index w2) + | (List [ Atom "catch"; w1; w2 ] : W.t) -> Catch (tagidx w1, labelidx w2) | w -> raise (Parse_failure { input = w; syntax = "catch" }) and instrlist : @@ -806,29 +917,35 @@ and instrlist : allow_end:bool -> W.t list -> (instr list * W.t list) * [ `Else | `End | `Nil ] = - fun ?label ~allow_else ~allow_end v -> - let end_ = ref `Nil in - let rec aux v acc = - match v with - | [] -> - end_ := `Nil; - (acc, []) - | (Atom "else" : W.t) :: v when allow_else -> - end_ := `Else; - (acc, v) - | (Atom "end" : W.t) :: v when allow_end -> - end_ := `End; - let v = - match (label, v) with Some l, w :: v when symbol w = l -> v | _ -> v - in - (acc, v) - | ((List _ : W.t) as w) :: v -> aux v (List.rev_append (foldedinstr w) acc) - | v -> - let instr, v = plaininstr v in - aux v (instr :: acc) - in - let instrs, v = aux v [] in - ((List.rev instrs, v), !end_) + fun ?label -> + fun ~allow_else -> + fun ~allow_end -> + fun v -> + let end_ = ref `Nil in + let rec aux v acc = + match v with + | [] -> + end_ := `Nil; + (acc, []) + | (Atom "else" : W.t) :: v when allow_else -> + end_ := `Else; + (acc, v) + | (Atom "end" : W.t) :: v when allow_end -> + end_ := `End; + let v = + match (label, v) with + | Some l, w :: v when symbol w = l -> v + | _ -> v + in + (acc, v) + | ((List _ : W.t) as w) :: v -> + aux v (List.rev_append (foldedinstr w) acc) + | v -> + let instr, v = plaininstr v in + aux v (instr :: acc) + in + let instrs, v = aux v [] in + ((List.rev instrs, v), !end_) and expr : W.t list -> instr list = fun v -> @@ -853,7 +970,7 @@ let inline_export_opt : W.t list -> string option * W.t list = function let elemexpr : W.t -> expr = function | (List (Atom "item" :: v) : W.t) -> expr v | Atom _ as w -> - let index = index w in + let index = funcidx w in [ Ref_func index ] | w -> foldedinstr w @@ -876,8 +993,9 @@ let importdesc : W.t -> importdesc = | (List (Atom "memory" :: v) : W.t) -> let id, v = binder v in let limits, v = limits v in + let shared, v = shared v in assert_list_empty v fail; - Memory (id, { limits }) + Memory (id, { limits; shared }) | (List (Atom "global" :: v) : W.t) -> let id, v = binder v in let w = assert_list_singleton v fail in @@ -894,14 +1012,14 @@ let exportdesc : W.t -> Ast.exportdesc = fun w -> let fail () = raise (Parse_failure { input = w; syntax = "exportdesc" }) in match w with - | (List [ Atom "func"; w ] : W.t) -> Func (index w) - | (List [ Atom "table"; w ] : W.t) -> Table (index w) - | (List [ Atom "memory"; w ] : W.t) -> Memory (index w) - | (List [ Atom "global"; w ] : W.t) -> Global (index w) + | (List [ Atom "func"; w ] : W.t) -> Func (funcidx w) + | (List [ Atom "table"; w ] : W.t) -> Table (tableidx w) + | (List [ Atom "memory"; w ] : W.t) -> Memory (memidx w) + | (List [ Atom "global"; w ] : W.t) -> Global (globalidx w) | _ -> fail () let modulefield : W.t -> modulefield list = function - | (List (Atom "rec" :: v) : W.t) -> [ Rectype (List.map typedef v) ] + | (List (Atom "rec" :: v) : W.t) -> [ Rectype (Lst.map v typedef) ] | (List (Atom "type" :: _) : W.t) as w -> [ Rectype [ typedef w ] ] | (List [ Atom "import"; mod_; name; desc ] : W.t) -> let desc = importdesc desc in @@ -934,12 +1052,11 @@ let modulefield : W.t -> modulefield list = function | _ -> fail () in match inline_export with - | Some name -> - r - @ [ - Export - { name; desc = Func { var_name = id.id; index = id.index } }; - ] + | Some name -> ( + match[@warning "-fragile-match"] id.id with + | Some var_name -> + r @ [ Export { name; desc = Func { var = Unresolve var_name } } ] + | _ -> assert false) | _ -> r) | (List (Atom "table" :: v) : W.t) as w -> ( let fail () = raise (Parse_failure { input = w; syntax = "table" }) in @@ -951,22 +1068,24 @@ let modulefield : W.t -> modulefield list = function | Some limits, v -> let init = expr v in [ Table { id; type_ = { limits; element_type }; init } ] - | None, (List (Atom "elem" :: v) : W.t) :: [] -> + | None, (List (Atom "elem" :: v) : W.t) :: [] -> ( let n = Int32.of_int (List.length v) in let limits : limits = { min = n; max = Some n } in - let list = List.map elemexpr v in - [ - Table { id; type_ = { limits; element_type }; init = [] }; - Elem - { - id = { id = None; index = -1 }; - type_ = element_type; - mode = - Ast.EMActive - ({ var_name = id.id; index = id.index }, [ I32_const 0l ]); - list; - }; - ] + let list = Lst.map v elemexpr in + match[@warning "-fragile-match"] id.id with + | Some name -> + [ + Table { id; type_ = { limits; element_type }; init = [] }; + Elem + { + id = { id = None; index = -1 }; + type_ = element_type; + mode = + Ast.EMActive ({ var = Unresolve name }, [ I32_const 0l ]); + list; + }; + ] + | _ -> assert false) | _ -> fail ()) | (List (Atom "memory" :: v) : W.t) as w -> let fail () = raise (Parse_failure { input = w; syntax = "memory" }) in @@ -974,20 +1093,22 @@ let modulefield : W.t -> modulefield list = function let inline_export, v = inline_export_opt v in let inline_import, v = inline_import_opt v in let limits, v = limits v in + let shared, v = shared v in assert_list_empty v fail; let import : Ast.modulefield = match inline_import with - | None -> Mem { id; type_ = { limits } } + | None -> Mem { id; type_ = { limits; shared } } | Some (mod_, name) -> - Import { module_ = mod_; name; desc = Memory (id, { limits }) } + Import + { module_ = mod_; name; desc = Memory (id, { limits; shared }) } in let export : Ast.modulefield list = match inline_export with - | Some name -> - [ - Export - { name; desc = Memory { var_name = id.id; index = id.index } }; - ] + | Some name -> ( + match[@warning "-fragile-match"] id.id with + | Some var_name -> + [ Export { name; desc = Memory { var = Unresolve var_name } } ] + | _ -> assert false) | _ -> [] in import :: export @@ -1000,11 +1121,11 @@ let modulefield : W.t -> modulefield list = function let mut, type_ = mut valtype w in let export : Ast.modulefield list = match inline_export with - | Some name -> - [ - Export - { name; desc = Global { var_name = id.id; index = id.index } }; - ] + | Some name -> ( + match[@warning "-fragile-match"] id.id with + | Some var_name -> + [ Export { name; desc = Global { var = Unresolve var_name } } ] + | _ -> assert false) | _ -> [] in let import : Ast.modulefield = @@ -1018,20 +1139,24 @@ let modulefield : W.t -> modulefield list = function let name = string name in let desc = exportdesc desc in [ Export { name; desc } ] - | (List [ Atom "start"; w ] : W.t) -> [ Start (index w) ] + | (List [ Atom "start"; w ] : W.t) -> [ Start (funcidx w) ] | (List (Atom "elem" :: v) : W.t) as w -> let fail () = raise (Parse_failure { input = w; syntax = "elem" }) in let id, v = binder v in let mode, v = match v with | (List [ Atom "table"; w ] : W.t) :: (w2 : W.t) :: v -> - (Ast.EMActive (index w, offset w2), v) + (Ast.EMActive (tableidx w, offset w2), v) | (Atom "declare" : W.t) :: v -> (Ast.EMDeclarative, v) | v -> (Ast.EMPassive, v) in let w, v = assert_list_nonempty v fail in - let type_ = reftype w in - let list = List.map elemexpr v in + let type_ = + match w with + | (Atom "func" : W.t) -> Ast.Ref (NonNull, Absheaptype Func) + | w -> reftype w + in + let list = Lst.map v elemexpr in [ Elem { id; mode; type_; list } ] | (List (Atom "data" :: v) : W.t) as w -> let fail () = raise (Parse_failure { input = w; syntax = "data" }) in @@ -1039,9 +1164,10 @@ let modulefield : W.t -> modulefield list = function let mode, v = match v with | (List [ Atom "memory"; w ] : W.t) :: (w2 : W.t) :: v -> - (Ast.DMActive (index w, offset w2), v) + (Ast.DMActive (memidx w, offset w2), v) | (List (Atom "offset" :: v2) : W.t) :: v -> - (Ast.DMActive ({ var_name = None; index = 0 }, expr v2), v) + ( Ast.DMActive ({ var = Unresolve Ast.default_memory_name }, expr v2), + v ) | v -> (Ast.DMPassive, v) in let w = assert_list_singleton v fail in @@ -1061,143 +1187,3 @@ let module_ : W.t list -> module_ = function { id; fields = List.concat_map modulefield v } | v -> { id = { id = None; index = -1 }; fields = List.concat_map modulefield v } - -let modulefield_new : W.t -> modulefield_new list = function - | (List (Atom "rec" :: v) : W.t) -> [ Rectype (List.map typedef v) ] - | (List (Atom "type" :: _) : W.t) as w -> [ Rectype [ typedef w ] ] - | (List [ Atom "import"; mod_; name; desc ] : W.t) -> - let desc : importdesc = - match desc with - | (List (Atom "func" :: v) : W.t) -> - let id, v = binder v in - let type_, [] = typeuse v in - Func (id, type_) - | (List (Atom "table" :: v) : W.t) -> - let id, v = binder v in - let limits, w :: [] = limits v in - let element_type = reftype w in - let type_ : tabletype = { limits; element_type } in - Table (id, type_) - | (List (Atom "memory" :: v) : W.t) -> - let id, v = binder v in - let limits, [] = limits v in - Memory (id, { limits }) - | (List (Atom "global" :: v) : W.t) -> - let id, w :: [] = binder v in - let mut, type_ = mut valtype w in - Global (id, { mut; type_ }) - | (List (Atom "tag" :: v) : W.t) -> - let id, v = binder v in - let type_, [] = typeuse v in - Tag (id, type_) - in - [ Import { module_ = string mod_; name = string name; desc } ] - | (List (Atom "func" :: _) : W.t) as func -> [ (Func func : modulefield_new) ] - | (List (Atom "table" :: v) : W.t) -> ( - let id, v = binder v in - let limits, w :: v = vopt limits v in - let element_type = reftype w in - match (limits, v) with - | Some limits, v -> - let init = expr v in - [ Table { id; type_ = { limits; element_type }; init } ] - | None, (List (Atom "elem" :: v) : W.t) :: [] -> - let n = Int32.of_int (List.length v) in - let limits : limits = { min = n; max = Some n } in - let list = List.map elemexpr v in - [ - Table { id; type_ = { limits; element_type }; init = [] }; - Elem - { - id = { id = None; index = -1 }; - type_ = element_type; - mode = - Ast.EMActive - ({ var_name = id.id; index = id.index }, [ I32_const 0l ]); - list; - }; - ]) - | (List (Atom "memory" :: v) : W.t) -> - let id, v = binder v in - let inline_export, v = inline_export_opt v in - let inline_import, v = inline_import_opt v in - let limits, [] = limits v in - let import : modulefield_new = - match inline_import with - | None -> Mem { id; type_ = { limits } } - | Some (mod_, name) -> - Import { module_ = mod_; name; desc = Memory (id, { limits }) } - in - let export : modulefield_new list = - match inline_export with - | Some name -> - [ - Export - { name; desc = Memory { var_name = id.id; index = id.index } }; - ] - | _ -> [] - in - import :: export - | (List (Atom "global" :: v) : W.t) -> ( - let id, v = binder v in - let inline_export, w :: v = inline_export_opt v in - let mut, type_ = mut valtype w in - match inline_export with - | Some name -> - [ - Global { id; type_ = { mut; type_ }; init = expr v }; - Export - { name; desc = Global { var_name = id.id; index = id.index } }; - ] - | _ -> [ Global { id; type_ = { mut; type_ }; init = expr v } ]) - | (List [ Atom "export"; name; desc ] : W.t) -> - let name = string name in - let desc : Ast.exportdesc = - match desc with - | (List [ Atom "func"; w ] : W.t) -> Func (index w) - | (List [ Atom "table"; w ] : W.t) -> Table (index w) - | (List [ Atom "memory"; w ] : W.t) -> Memory (index w) - | (List [ Atom "global"; w ] : W.t) -> Global (index w) - in - [ Export { name; desc } ] - | (List [ Atom "start"; w ] : W.t) -> [ Start (index w) ] - | (List (Atom "elem" :: v) : W.t) -> - let id, v = binder v in - let mode, w :: v = - match v with - | (List [ Atom "table"; w ] : W.t) :: (w2 : W.t) :: v -> - (Ast.EMActive (index w, offset w2), v) - | (Atom "declare" : W.t) :: v -> (Ast.EMDeclarative, v) - | v -> (Ast.EMPassive, v) - in - let type_ = reftype w in - let list = List.map elemexpr v in - [ Elem { id; mode; type_; list } ] - | (List (Atom "data" :: v) : W.t) -> - let id, v = binder v in - let mode, w :: [] = - match v with - | (List [ Atom "memory"; w ] : W.t) :: (w2 : W.t) :: v -> - (Ast.DMActive (index w, offset w2), v) - | (List (Atom "offset" :: v2) : W.t) :: v -> - (Ast.DMActive ({ var_name = None; index = 0 }, expr v2), v) - | v -> (Ast.DMPassive, v) - in - let data_str = string w in - [ Data { id; mode; data_str } ] - | (List (Atom "tag" :: w :: v) : W.t) -> - let type_, [] = typeuse v in - let id, _ = binder [ w ] in - [ Tag { id; type_ } ] -[@@warning "-partial-match"] [@@dead "+modulefield_new"] - -let module_new : W.t list -> module_new = function - | (List (Atom "module" :: v) : W.t) :: [] -> - let id, v = binder v in - { id; fields = List.concat_map modulefield_new v } - | v -> - { - id = { id = None; index = -1 }; - fields = List.concat_map modulefield_new v; - } -[@@dead "+module_new"] diff --git a/src/dwarfsm_sexp_parse.ml b/src/dwarfsm_sexp_parse.ml index 5a81d03..740900c 100644 --- a/src/dwarfsm_sexp_parse.ml +++ b/src/dwarfsm_sexp_parse.ml @@ -14,10 +14,21 @@ module Sexp_parser = Dwarfsm_sexp_parser module Parse_error = Dwarfsm_sexp_parse_error +let convert_ocaml_lexer (ocaml_lexer : Stdlib.Lexing.lexbuf -> 'token) + (ocaml_buf : Stdlib.Lexing.lexbuf) : Lexing.lexbuf -> 'token = + fun buf -> + let token = ocaml_lexer ocaml_buf in + buf.lex_start_p <- Lexing.of_stdlib_position ocaml_buf.lex_start_p; + buf.lex_curr_p <- Lexing.of_stdlib_position ocaml_buf.lex_curr_p; + token + let parse s = - let lexbuf = Lexing.from_string s in - try Sexp_parser.sexps Wasm_lex.token lexbuf + let lexer = + convert_ocaml_lexer Wasm_lex.token (Stdlib.Lexing.from_string s) + in + let lexbuf = Lexing.from_string "" in + try Sexp_parser.sexps lexer lexbuf with Sexp_parser.Error -> (* must be unmatched right parenthesis *) - let pos = (Lexing.lexeme_start_p lexbuf, Lexing.lexeme_end_p lexbuf) in + let pos = (lexbuf.Lexing.lex_start_p, lexbuf.Lexing.lex_curr_p) in raise (Parse_error.Unmatched_parenthesis pos) diff --git a/src/dwarfsm_sexp_parser.ml b/src/dwarfsm_sexp_parser.ml index a661eb7..ae19569 100755 --- a/src/dwarfsm_sexp_parser.ml +++ b/src/dwarfsm_sexp_parser.ml @@ -13,26 +13,26 @@ *) module MenhirBasics = struct - + exception Error - + let _eRR = fun _s -> raise Error - + type token = Sexp_token.token - + end include MenhirBasics # 1 "lib/dwarfsm/sexp/dwarfsm_sexp_parser.mly" - + [@@@ocamlformat "disable"] # 21 "lib/dwarfsm/sexp/dwarfsm_sexp_parser.ml" -type ('s, 'r) _menhir_state = +type ('s, 'r) _menhir_state = | MenhirState00 : ('s, _menhir_box_main) _menhir_state (** State 00. Stack shape : . @@ -64,19 +64,19 @@ type ('s, 'r) _menhir_state = Start symbol: sexps. *) -and ('s, 'r) _menhir_cell1_sexp = +and ('s, 'r) _menhir_cell1_sexp = | MenhirCell1_sexp of 's * ('s, 'r) _menhir_state * (W.t) -and ('s, 'r) _menhir_cell1_sexp_list = +and ('s, 'r) _menhir_cell1_sexp_list = | MenhirCell1_sexp_list of 's * ('s, 'r) _menhir_state * (W.t list) -and ('s, 'r) _menhir_cell1_LPAREN = +and ('s, 'r) _menhir_cell1_LPAREN = | MenhirCell1_LPAREN of 's * ('s, 'r) _menhir_state * Lexing.position -and _menhir_box_sexps = +and _menhir_box_sexps = | MenhirBox_sexps of (W.t list) [@@unboxed] -and _menhir_box_main = +and _menhir_box_main = | MenhirBox_main of (W.t) [@@unboxed] let _menhir_action_2 = @@ -97,7 +97,7 @@ let _menhir_action_3 = let _menhir_action_4 = fun _1 -> - let a = + let a = # 22 "lib/dwarfsm/sexp/dwarfsm_sexp_parser.mly" ( _1) # 91 "lib/dwarfsm/sexp/dwarfsm_sexp_parser.ml" @@ -167,9 +167,9 @@ let _menhir_fail : unit -> 'a = assert false include struct - + [@@@ocaml.warning "-4-37-39"] - + let rec _menhir_run_18 : type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_sexps = fun _menhir_stack _v _tok -> match (_tok : MenhirBasics.token) with @@ -179,19 +179,19 @@ include struct MenhirBox_sexps _v | _ -> _eRR () - + let rec _menhir_error_run_20 : type ttv_stack. ttv_stack -> _menhir_box_sexps = fun _menhir_stack -> _eRR () - + let rec _menhir_error_run_13 : type ttv_stack. ttv_stack -> _menhir_box_main = fun _menhir_stack -> _eRR () - + let rec _menhir_error_run_18 : type ttv_stack. ttv_stack -> _menhir_box_sexps = fun _menhir_stack -> _eRR () - + let rec _menhir_error_run_10 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_sexp_list -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf -> let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in @@ -200,7 +200,7 @@ include struct let _endpos__3_ = _endpos in let _v = _menhir_action_5 _endpos__3_ _startpos__1_ in _menhir_error_goto_sexp _menhir_stack _menhir_lexbuf _v _menhir_s - + and _menhir_error_goto_sexp : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _v _menhir_s -> match _menhir_s with @@ -216,20 +216,20 @@ include struct _menhir_error_run_07 _menhir_stack _menhir_lexbuf _v _menhir_s | MenhirState02 -> _menhir_error_run_07 _menhir_stack _menhir_lexbuf _v _menhir_s - + and _menhir_error_run_07 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _v _menhir_s -> let _menhir_stack = MenhirCell1_sexp (_menhir_stack, _menhir_s, _v) in let _v_0 = _menhir_action_6 () in _menhir_error_run_08 _menhir_stack _menhir_lexbuf _v_0 - + and _menhir_error_run_08 : type ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_sexp -> _ -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _v -> let MenhirCell1_sexp (_menhir_stack, _menhir_s, s) = _menhir_stack in let l = _v in let _v = _menhir_action_7 l s in _menhir_error_goto_sexp_list _menhir_stack _menhir_lexbuf _v _menhir_s - + and _menhir_error_goto_sexp_list : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _v _menhir_s -> match _menhir_s with @@ -245,24 +245,24 @@ include struct _menhir_error_run_04 _menhir_stack _menhir_lexbuf _v _menhir_s | _ -> _menhir_fail () - + and _menhir_error_run_21 : type ttv_stack. (ttv_stack, _menhir_box_sexps) _menhir_cell1_sexp -> _ -> _ -> _menhir_box_sexps = fun _menhir_stack _menhir_lexbuf _v -> let MenhirCell1_sexp (_menhir_stack, _menhir_s, s) = _menhir_stack in let l = _v in let _v = _menhir_action_7 l s in _menhir_error_goto_sexp_list _menhir_stack _menhir_lexbuf _v _menhir_s - + and _menhir_error_run_09 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _v _menhir_s -> let _menhir_stack = MenhirCell1_sexp_list (_menhir_stack, _menhir_s, _v) in _menhir_error_run_10 _menhir_stack _menhir_lexbuf - + and _menhir_error_run_04 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _v _menhir_s -> let _menhir_stack = MenhirCell1_sexp_list (_menhir_stack, _menhir_s, _v) in _menhir_error_run_05 _menhir_stack _menhir_lexbuf - + and _menhir_error_run_05 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_sexp_list -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf -> let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in @@ -271,7 +271,7 @@ include struct let _endpos__3_ = _endpos in let _v = _menhir_action_5 _endpos__3_ _startpos__1_ in _menhir_error_goto_sexp _menhir_stack _menhir_lexbuf _v _menhir_s - + let rec _menhir_run_13 : type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main = fun _menhir_stack _v _tok -> match (_tok : MenhirBasics.token) with @@ -281,7 +281,7 @@ include struct MenhirBox_main _v | _ -> _eRR () - + let rec _menhir_run_01 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in @@ -298,7 +298,7 @@ include struct | _ -> let _v = _menhir_action_6 () in _menhir_error_run_09 _menhir_stack _menhir_lexbuf _v MenhirState01 - + and _menhir_run_02 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in @@ -315,14 +315,14 @@ include struct | _ -> let _v = _menhir_action_6 () in _menhir_error_run_04 _menhir_stack _menhir_lexbuf _v MenhirState02 - + and _menhir_run_03 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s -> let _tok = _menhir_lexer _menhir_lexbuf in let _1 = _v in let _v = _menhir_action_4 _1 in _menhir_goto_sexp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - + and _menhir_goto_sexp : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> match _menhir_s with @@ -338,7 +338,7 @@ include struct _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok | MenhirState02 -> _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - + and _menhir_run_20 : type ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sexps) _menhir_state -> _ -> _menhir_box_sexps = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> let _menhir_stack = MenhirCell1_sexp (_menhir_stack, _menhir_s, _v) in @@ -352,21 +352,21 @@ include struct _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 _tok | _ -> _eRR () - + and _menhir_run_12 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s -> let _tok = _menhir_lexer _menhir_lexbuf in let _1 = _v in let _v = _menhir_action_4 _1 in _menhir_goto_sexp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - + and _menhir_run_21 : type ttv_stack. (ttv_stack, _menhir_box_sexps) _menhir_cell1_sexp -> _ -> _ -> _ -> _ -> _menhir_box_sexps = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok -> let MenhirCell1_sexp (_menhir_stack, _menhir_s, s) = _menhir_stack in let l = _v in let _v = _menhir_action_7 l s in _menhir_goto_sexp_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - + and _menhir_goto_sexp_list : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> match _menhir_s with @@ -382,7 +382,7 @@ include struct _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok | _ -> _menhir_fail () - + and _menhir_run_09 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> match (_tok : MenhirBasics.token) with @@ -395,14 +395,14 @@ include struct | _ -> let _menhir_stack = MenhirCell1_sexp_list (_menhir_stack, _menhir_s, _v) in _menhir_error_run_10 _menhir_stack _menhir_lexbuf - + and _menhir_run_08 : type ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_sexp -> _ -> _ -> _ -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok -> let MenhirCell1_sexp (_menhir_stack, _menhir_s, s) = _menhir_stack in let l = _v in let _v = _menhir_action_7 l s in _menhir_goto_sexp_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - + and _menhir_run_04 : type ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> match (_tok : MenhirBasics.token) with @@ -415,7 +415,7 @@ include struct | _ -> let _menhir_stack = MenhirCell1_sexp_list (_menhir_stack, _menhir_s, _v) in _menhir_error_run_05 _menhir_stack _menhir_lexbuf - + and _menhir_run_07 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result = fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok -> let _menhir_stack = MenhirCell1_sexp (_menhir_stack, _menhir_s, _v) in @@ -430,7 +430,7 @@ include struct | _ -> let _v_2 = _menhir_action_6 () in _menhir_error_run_08 _menhir_stack _menhir_lexbuf _v_2 - + let rec _menhir_run_00 : type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main = fun _menhir_stack _menhir_lexbuf _menhir_lexer -> let _menhir_s = MenhirState00 in @@ -442,7 +442,7 @@ include struct _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s | _ -> _eRR () - + let rec _menhir_run_16 : type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_sexps = fun _menhir_stack _menhir_lexbuf _menhir_lexer -> let _tok = _menhir_lexer _menhir_lexbuf in @@ -456,7 +456,7 @@ include struct _menhir_run_18 _menhir_stack _v _tok | _ -> _eRR () - + end let sexps = diff --git a/src/eliminate_async.ml b/src/eliminate_async.ml new file mode 100644 index 0000000..7c61059 --- /dev/null +++ b/src/eliminate_async.ml @@ -0,0 +1,1032 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ident = Basic_core_ident +module Qual_ident = Basic_qual_ident +module Type_path = Basic_type_path +module Constr_info = Basic_constr_info +module Lst = Basic_lst +module Vec = Basic_vec + +exception Need_cps + +let need_cps_visitor = + object (self) + inherit [_] Core.Iter.iter as super + + method! visit_apply_kind _ kind = + match kind with + | Async _ -> raise_notrace Need_cps + | Normal _ | Join -> () + + method! visit_Cexpr_prim ctx prim args ty loc = + (match prim with + | Pget_current_continuation -> raise_notrace Need_cps + | _ -> ()); + super#visit_Cexpr_prim ctx prim args ty loc + + method! visit_Cexpr_letfn ctx name fn body ty kind loc = + match kind with + | Tail_join | Nontail_join -> + super#visit_Cexpr_letfn ctx name fn body ty kind loc + | Nonrec | Rec -> self#visit_expr ctx body + + method! visit_Cexpr_letrec ctx _bindings body _ty _loc = + self#visit_expr ctx body + + method! visit_Cexpr_function _ _func _ty _is_raw _loc = () + end + +let need_cps expr = + try + need_cps_visitor#visit_expr () expr; + false + with Need_cps -> true + +type continuation = + | Identity + | Return of { cont : Ident.t; cont_ty : Stype.t } + | Simple of { state_id : int } + | Complex of (Core.expr -> Core.expr) + +type loop_info = { loop_state : int; break_cont : continuation } + +type state = { + state_id : int; + state_name : string; + params : Core.param list; + captures : (Ident.t * Stype.t) list; + body : Core.expr; +} + +type ctx = { + join_to_state : int Ident.Hash.t; + loop_info : loop_info Label.Hash.t; + return_cont : continuation; + return_err_cont : continuation; + driver_id : Ident.t; + driver_ty : Stype.t; + cont_params : Core.param list; + state_ty : Stype.t; + states : state Vec.t; + ty_params : Tvar_env.t; + toplevel_id : Type_path.toplevel_id; + global_env : Global_env.t; +} + +let make_state ctx state_id args = + let state = Vec.get ctx.states state_id in + let state_name = state.state_name in + Core.constr ~ty:ctx.state_ty + (Constr_tag_regular + { + total = Constr_info.Index_set.empty; + index = state_id; + repr_ = Non_constant; + name_ = state_name; + }) + (args @ Lst.map state.captures (fun (id, ty) -> Core.var ~ty id)) + +let rename_visitor = + object + inherit [_] Core.Map.map + method! visit_var subst var = Ident.Hash.find_default subst var var + end + +let resume ctx ?(loc = Rloc.no_location) (k : continuation) (v : Core.expr) = + match k with + | Identity -> v + | Return { cont; cont_ty } -> + Core.apply ~loc cont [ v ] ~ty:Stype.unit + ~kind:(Normal { func_ty = cont_ty }) + | Simple { state_id } -> + Core.apply ~loc + ~kind:(Normal { func_ty = ctx.driver_ty }) + ~ty:Stype.unit ctx.driver_id + [ make_state ctx state_id [ v ] ] + | Complex f -> f v + +let ( let* ) wanting_continuation callback = + wanting_continuation (Complex callback) +[@@dead "+let*"] + +let id_cont ty = + let param = Ident.fresh "*param" in + Core.function_ + ~ty:(Builtin.type_arrow [ ty ] Stype.unit ~err_ty:None ~is_async:false) + ~is_async:false + [ { binder = param; ty = Stype.unit; loc_ = Rloc.no_location } ] + (Core.unit ()) + +let add_captures_of_cont ctx captures k = + match k with + | Identity -> captures + | Return { cont; cont_ty } -> Ident.Map.add captures cont cont_ty + | Simple { state_id } -> + let { captures = state_captures; _ } = Vec.get ctx.states state_id in + Lst.fold_left state_captures captures (fun captures -> + fun (id, ty) -> Ident.Map.add captures id ty) + | Complex _ -> assert false + +let add_recursive_state ctx ~state_name ~captures (params : Core.param list) + body = + let state_id = Vec.length ctx.states in + let state_name = state_name ~state_id in + let captures = + Lst.map_append ctx.cont_params captures (fun p -> (p.binder, p.ty)) + in + let state = { state_id; state_name; params; captures; body = Core.unit () } in + Vec.push ctx.states state; + let body = body state_id in + Vec.set ctx.states state_id { state with body }; + state + +let add_new_state ctx ~state_name params body = + let state_id = Vec.length ctx.states in + let state_name = state_name ~state_id in + let captures = + let exclude = Ident.Set.singleton ctx.driver_id in + Ident.Map.bindings + (Core_util.free_vars ~exclude { params; body; is_async = false }) + in + let state = { state_id; state_name; params; captures; body } in + Vec.push ctx.states state; + state + +let cont_is_simple cont = + match cont with Identity | Return _ | Simple _ -> true | Complex _ -> false + +let make_cont_simple ctx ~ty k = + match k with + | Identity | Return _ | Simple _ -> k + | Complex f -> + let param = Ident.fresh "*cont_param" in + let state_name ~state_id = + (("State_" ^ Int.to_string state_id : Stdlib.String.t) [@merlin.hide]) + in + let state = + match Stype.type_repr ty with + | T_constr + { type_constructor = T_error_value_result; tys = [ ok_ty; err_ty ] } + -> + let result_ty = Stype.make_result_ty ~ok_ty ~err_ty in + let handle_error = + let ok_var = Ident.fresh "*ok" in + let err_var = Ident.fresh "*err" in + let branch tag branch_ty var = + ( tag, + Some var, + Core.prim ~ty + (Pmake_value_or_error { tag }) + [ + Core.prim ~ty:branch_ty + (Penum_field { index = 0; tag }) + [ + Core.var + ~ty:(Type.make_constr_type result_ty ~tag) + var; + ]; + ] ) + in + Core.switch_constr + (Core.var ~ty:result_ty param) + [ + branch Builtin.constr_ok.cs_tag ok_ty ok_var; + branch Builtin.constr_err.cs_tag err_ty err_var; + ] + ~default:None + in + add_new_state ctx ~state_name + [ { binder = param; ty = result_ty; loc_ = Rloc.no_location } ] + (f handle_error) + | ty -> + add_new_state ctx ~state_name + [ { binder = param; ty; loc_ = Rloc.no_location } ] + (f (Core.var ~ty param)) + in + Simple { state_id = state.state_id } + +let cont_to_expr ctx ~ty k = + let ty = Stype.type_repr ty in + let cont_ty arg_ty = + Builtin.type_arrow [ arg_ty ] Stype.unit ~err_ty:None ~is_async:false + [@@inline] + in + match make_cont_simple ctx ~ty k with + | Identity -> id_cont ty + | Return { cont; cont_ty } -> Core.var ~ty:cont_ty cont + | Simple { state_id } as k -> ( + let param = Ident.fresh "*cont_param" in + match[@warning "-fragile-match"] (Vec.get ctx.states state_id).params with + | { ty = param_ty; _ } :: [] -> + Core.function_ ~ty:(cont_ty param_ty) ~is_async:false + [ { binder = param; ty = param_ty; loc_ = Rloc.no_location } ] + (resume ctx k (Core.var ~ty:param_ty param)) + | _ -> assert false) + | Complex _ -> assert false + +let rec transform_expr ctx (expr : Core.expr) ~error_cont k = + let go expr k = transform_expr ctx expr ~error_cont k [@@inline] in + let go_list exprs k = + transform_expr_list ctx exprs ~error_cont k + [@@inline] + in + let go_no_cps expr = transform_expr_no_cps ctx ~error_cont expr [@@inline] in + match expr with + | Cexpr_apply { kind = Async _ as kind; func; args; ty; ty_args_; prim; loc_ } + -> + let cont_args = + match Stype.type_repr ty with + | T_constr + { type_constructor = T_error_value_result; tys = [ ok_ty; err_ty ] } + -> + [ + cont_to_expr ctx ~ty:ok_ty k; + cont_to_expr ctx ~ty:err_ty error_cont; + ] + | ty -> [ cont_to_expr ctx ~ty k ] + in + go_list args (fun args -> + Core.apply ~loc:loc_ ~kind ~ty:Stype.unit ~ty_args_ ~prim func + (args @ cont_args)) + | Cexpr_prim { prim = Pget_current_continuation; args; ty; loc_ } -> ( + match[@warning "-fragile-match"] args with + | cc_callback :: [] -> ( + let* cc_callback = go cc_callback in + let conts = + match Stype.type_repr ty with + | T_constr + { + type_constructor = T_error_value_result; + tys = [ ok_ty; err_ty ]; + } -> + [ + cont_to_expr ctx ~ty:ok_ty k; + cont_to_expr ctx ~ty:err_ty error_cont; + ] + | ty -> [ cont_to_expr ctx ~ty k ] + in + match cc_callback with + | Cexpr_function { func = { params; body; is_async = _ }; ty = _ } -> + Lst.fold_right2 params conts body (fun p -> + fun cont -> fun body -> Core.let_ p.binder cont body) + | _ -> + let func_ty = Core.type_of_expr cc_callback in + Core.bind cc_callback (fun cc_callback -> + Core.apply ~loc:loc_ + ~kind:(Normal { func_ty }) + ~ty:Stype.unit cc_callback conts)) + | _ -> assert false) + | Cexpr_prim { prim = Prun_async; args; ty; loc_ } -> ( + match[@warning "-fragile-match"] args with + | async_fn :: [] -> ( + let* async_fn = go async_fn in + let id_cont = cont_to_expr ctx ~ty Identity in + match async_fn with + | Cexpr_function + { func = { params = param :: []; body; is_async = _ }; ty = _ } -> + resume ctx k (Core.let_ param.binder id_cont body) + | _ -> + let func_ty = Core.type_of_expr async_fn in + Core.bind async_fn (fun async_fn -> + resume ctx k + (Core.apply ~loc:loc_ + ~kind:(Normal { func_ty }) + ~ty:Stype.unit async_fn [ id_cont ]))) + | _ -> assert false) + | Cexpr_letfn + { name; fn; body; ty; kind = (Tail_join | Nontail_join) as kind; loc_ } -> + if need_cps fn.body || need_cps body then ( + let k = make_cont_simple ctx ~ty k in + let join_body = go fn.body k in + let state = + add_new_state ctx + ~state_name:(fun ~state_id:_ -> Ident.to_string name) + fn.params join_body + in + Ident.Hash.add ctx.join_to_state name state.state_id; + go body k) + else + let join_body = go_no_cps fn.body in + let body = go_no_cps body in + resume ctx k + (Core.letfn ~loc:loc_ ~kind name { fn with body = join_body } body) + | Cexpr_apply { kind = Join; func; args; ty = _; ty_args_; prim; loc_ } -> + go_list args (fun args -> + match Ident.Hash.find_opt ctx.join_to_state func with + | Some state_id -> + Core.return ~ty:Stype.unit ~return_kind:Single_value + (Core.apply ~loc:loc_ + ~kind:(Normal { func_ty = ctx.driver_ty }) + ~ty:Stype.unit ~ty_args_ ~prim ctx.driver_id + [ make_state ctx state_id args ]) + | None -> + Core.apply ~loc:loc_ ~kind:Join ~ty:Stype.unit ~ty_args_ ~prim + func args) + | Cexpr_loop { params; body; args; label; ty; loc_ } -> + go_list args (fun args -> + if need_cps body then + let k = make_cont_simple ctx ~ty k in + let state_name ~state_id = + ((Label.basename label ^ "_" ^ Int.to_string state_id + : Stdlib.String.t) + [@merlin.hide]) + in + let state = + let captures = + Ident.Map.bindings (get_captures_of_loop ctx params body k) + in + add_recursive_state ctx ~state_name params ~captures + (fun loop_state -> + Label.Hash.add ctx.loop_info label + { loop_state; break_cont = k }; + go body k) + in + Core.apply + ~kind:(Normal { func_ty = ctx.driver_ty }) + ~ty:Stype.unit ctx.driver_id + [ make_state ctx state.state_id args ] + else + resume ctx k + (Core.loop ~loc:loc_ params (go_no_cps body) args label)) + | Cexpr_break { arg; label; ty; loc_ } -> ( + match Label.Hash.find_opt ctx.loop_info label with + | None -> Core.break ~loc_ (Option.map go_no_cps arg) label ty + | Some { break_cont; _ } -> + let arg = match arg with None -> Core.unit () | Some arg -> arg in + Core.return ~ty:Stype.unit ~return_kind:Single_value + (resume ctx ~loc:loc_ break_cont arg)) + | Cexpr_continue { args; label; ty; loc_ } -> ( + match Label.Hash.find_opt ctx.loop_info label with + | None -> + let args = Lst.map args go_no_cps in + Core.continue ~loc:loc_ args label ty + | Some { loop_state; break_cont = _ } -> + go_list args (fun args -> + Core.return ~ty:Stype.unit ~return_kind:Single_value + (Core.apply ~loc:loc_ + ~kind:(Normal { func_ty = ctx.driver_ty }) + ~ty:Stype.unit ctx.driver_id + [ make_state ctx loop_state args ]))) + | Cexpr_return { expr; return_kind; ty = _; loc_ } -> + let* expr = go expr in + let return_cont = + match return_kind with + | Single_value | Error_result { is_error = false; _ } -> ctx.return_cont + | Error_result { is_error = true; _ } -> ctx.return_err_cont + in + Core.return ~ty:Stype.unit ~return_kind:Single_value + (resume ctx ~loc:loc_ return_cont expr) + | Cexpr_if { cond; ifso; ifnot; ty; loc_ } -> + let* cond = go cond in + if + cont_is_simple k || need_cps ifso + || match ifnot with None -> false | Some ifnot -> need_cps ifnot + then + let k = make_cont_simple ctx ~ty k in + let ifso = go ifso k in + let ifnot = + match ifnot with + | None -> resume ctx k (Core.unit ()) + | Some ifnot -> go ifnot k + in + Core.if_ ~loc:loc_ cond ~ifso ~ifnot + else + let ifso = go_no_cps ifso in + let ifnot = Option.map go_no_cps ifnot in + resume ctx k (Core.if_ ~loc:loc_ cond ~ifso ?ifnot) + | Cexpr_switch_constr { obj; cases; default; ty; loc_ } -> + let* obj = go obj in + let need_cps = + cont_is_simple k + || Lst.exists cases (fun (_, _, action) -> need_cps action) + || match default with None -> false | Some default -> need_cps default + in + if need_cps then + let k = make_cont_simple ctx ~ty k in + let cases = + Lst.map cases (fun (tag, binder, action) -> + (tag, binder, go action k)) + in + let default = + match default with + | None -> None + | Some default -> Some (go default k) + in + Core.switch_constr ~loc:loc_ obj cases ~default + else + let cases = + Lst.map cases (fun (tag, binder, action) -> + (tag, binder, go_no_cps action)) + in + let default = Option.map go_no_cps default in + resume ctx k (Core.switch_constr ~loc:loc_ obj cases ~default) + | Cexpr_switch_constant { obj; cases; default; ty; loc_ } -> + let* obj = go obj in + let need_cps = + cont_is_simple k + || Lst.exists cases (fun (_, action) -> need_cps action) + || need_cps default + in + if need_cps then + let k = make_cont_simple ctx ~ty k in + let cases = Lst.map cases (fun (c, action) -> (c, go action k)) in + let default = go default k in + Core.switch_constant ~loc:loc_ obj cases ~default + else + let cases = Lst.map cases (fun (c, action) -> (c, go_no_cps action)) in + let default = go_no_cps default in + resume ctx k (Core.switch_constant ~loc:loc_ obj cases ~default) + | Cexpr_prim { prim = Pmake_value_or_error { tag }; args; ty = _ } -> ( + match[@warning "-fragile-match"] args with + | arg :: [] -> + if Basic_constr_info.equal tag Builtin.constr_ok.cs_tag then go arg k + else go arg error_cont + | _ -> assert false) + | Cexpr_handle_error + { + obj = + Cexpr_apply + { + func; + args; + kind = Normal _ as kind; + ty_args_; + prim; + ty = apply_ty; + loc_ = apply_loc_; + } as obj; + handle_kind; + ty; + loc_; + } -> ( + let no_need_to_transform () = + go_list args (fun args -> + let apply = + Core.apply ~loc:apply_loc_ ~ty:apply_ty ~ty_args_ ~prim ~kind func + args + in + resume ctx k (Core.handle_error ~loc:loc_ ~ty apply handle_kind)) + [@@local] + in + match handle_kind with + | To_result -> no_need_to_transform () + | Return_err _ -> transform_expr ctx obj ~error_cont:ctx.return_err_cont k + | Joinapply join -> ( + match Ident.Hash.find_opt ctx.join_to_state join with + | None -> no_need_to_transform () + | Some state_id -> + transform_expr ctx obj ~error_cont:(Simple { state_id }) k)) + | Cexpr_handle_error { obj; handle_kind; ty } -> + let k, error_cont = + match handle_kind with + | To_result -> + let k = make_cont_simple ctx ~ty k in + let make_cont (ok_or_err : Typedecl_info.constructor) = + Complex + (fun payload -> + resume ctx k (Core.constr ~ty ok_or_err.cs_tag [ payload ])) + in + (make_cont Builtin.constr_ok, make_cont Builtin.constr_err) + | Return_err _ -> (k, ctx.return_err_cont) + | Joinapply join -> ( + match Ident.Hash.find_opt ctx.join_to_state join with + | Some state_id -> (k, Simple { state_id }) + | None -> (k, Complex (fun v -> Core.join_apply ~ty join [ v ]))) + in + transform_expr ctx ~error_cont obj k + | Cexpr_let { name; rhs; body; ty = _; loc_ } -> + let* rhs = go rhs in + Core.let_ ~loc:loc_ name rhs (go body k) + | Cexpr_letfn { name; kind = (Rec | Nonrec) as kind; fn; body; ty = _; loc_ } + -> + let toplevel_id = + Type_path.map_toplevel_id ctx.toplevel_id (fun id -> + ((id ^ "." ^ Ident.to_string name : Stdlib.String.t) [@merlin.hide])) + in + Core.letfn ~loc:loc_ ~kind name + (transform_fn ~global_env:ctx.global_env ~toplevel_id ctx.ty_params fn) + (go body k) + | Cexpr_letrec { bindings; body; ty = _; loc_ } -> + let bindings = + Lst.map bindings (fun (name, fn) -> + let toplevel_id = + Type_path.map_toplevel_id ctx.toplevel_id (fun id -> + ((id ^ "." ^ Ident.to_string name + : Stdlib.String.t) + [@merlin.hide])) + in + ( name, + transform_fn ~global_env:ctx.global_env ~toplevel_id ctx.ty_params + fn )) + in + Core.letrec ~loc:loc_ bindings (go body k) + | Cexpr_sequence { exprs; last_expr; ty = _; loc_ } -> + let rec loop exprs = + match exprs with + | [] -> go last_expr k + | expr :: exprs -> + let* expr = go expr in + Core.sequence2 ~loc:loc_ expr (loop exprs) + in + loop exprs + | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ -> resume ctx k expr + | Cexpr_function { func; ty; loc_ } -> + let toplevel_id = + Type_path.map_toplevel_id ctx.toplevel_id (fun id -> + ((id ^ ".lambda/" ^ Int.to_string (Basic_uuid.next ()) + : Stdlib.String.t) + [@merlin.hide])) + in + let ({ params; body; is_async } : Core.fn) = + transform_fn ~global_env:ctx.global_env ~toplevel_id ctx.ty_params func + in + resume ctx k (Core.function_ ~loc:loc_ ~ty ~is_async params body) + | Cexpr_as { expr; trait; obj_type; loc_ } -> + let* expr = go expr in + resume ctx k (Core.as_ ~loc:loc_ ~trait ~obj_type expr) + | Cexpr_assign { var; expr; ty = _; loc_ } -> + let* expr = go expr in + resume ctx k (Core.assign ~loc:loc_ var expr) + | Cexpr_field { record; accessor; pos; ty; loc_ } -> + let* record = go record in + resume ctx k (Core.field ~loc:loc_ ~ty record accessor ~pos) + | Cexpr_mutate { record; label; field; pos; ty = _; loc_ } -> + let* record = go record in + let* field = go field in + resume ctx k (Core.mutate ~loc:loc_ record label field ~pos) + | Cexpr_prim { prim; args; ty; loc_ } -> + go_list args (fun args -> + handle_error_if_necessary ctx k ~error_cont + (Core.prim ~loc:loc_ ~ty prim args)) + | Cexpr_and { lhs; rhs; loc_ } -> + let* lhs = go lhs in + let* rhs = go rhs in + resume ctx k (Core.and_ ~loc:loc_ lhs rhs) + | Cexpr_or { lhs; rhs; loc_ } -> + let* lhs = go lhs in + let* rhs = go rhs in + resume ctx k (Core.or_ ~loc:loc_ lhs rhs) + | Cexpr_apply + { kind = Normal _ as kind; func; args; ty; ty_args_; prim; loc_ } -> + go_list args (fun args -> + handle_error_if_necessary ctx k ~error_cont + (Core.apply ~loc:loc_ ~kind ~ty ~ty_args_ ~prim func args)) + | Cexpr_constr { tag; args; ty; loc_ } -> + go_list args (fun args -> + resume ctx k (Core.constr ~loc:loc_ ~ty tag args)) + | Cexpr_tuple { exprs; ty; loc_ } -> + go_list exprs (fun exprs -> resume ctx k (Core.tuple ~loc:loc_ ~ty exprs)) + | Cexpr_record { fields; ty; loc_ } -> + go_list + (Lst.map fields (fun field -> field.expr)) + (fun field_exprs -> + let fields = + Lst.map2 fields field_exprs (fun field -> + fun expr -> { field with expr }) + in + resume ctx k (Core.record ~loc:loc_ ~ty fields)) + | Cexpr_record_update { record; fields; fields_num; ty = _; loc_ } -> + let* record = go record in + go_list + (Lst.map fields (fun field -> field.expr)) + (fun field_exprs -> + let fields = + Lst.map2 fields field_exprs (fun field -> + fun expr -> { field with expr }) + in + resume ctx k (Core.record_update ~loc:loc_ record fields fields_num)) + | Cexpr_array { exprs; ty; loc_ } -> + go_list exprs (fun exprs -> resume ctx k (Core.array ~loc:loc_ ~ty exprs)) + +and transform_expr_list ctx (exprs : Core.expr list) ~error_cont k = + let rec go processed_rev exprs k = + match exprs with + | [] -> k (List.rev processed_rev) + | expr :: exprs when need_cps expr -> + let name_for_processed = + Lst.map processed_rev (fun (processed : Core.expr) -> + match processed with + | Cexpr_var { id = Pident _ | Pdot _ | Plocal_method _; _ } + | Cexpr_unit _ | Cexpr_const _ -> + None + | _ -> Some (Ident.fresh "*arg")) + in + let new_processed = + Lst.map2 name_for_processed processed_rev (fun name_opt -> + fun expr -> + match name_opt with + | Some id -> Core.var ~ty:(Core.type_of_expr expr) id + | None -> expr) + in + let rest = + let* expr = transform_expr ctx ~error_cont expr in + go (expr :: new_processed) exprs k + in + Lst.fold_left2 name_for_processed processed_rev rest (fun name_opt -> + fun expr -> + fun rest -> + match name_opt with + | None -> rest + | Some id -> Core.let_ id expr rest) + | expr :: exprs -> + let expr = transform_expr_no_cps ctx ~error_cont expr in + go (expr :: processed_rev) exprs k + in + go [] exprs k + +and transform_expr_no_cps ctx ~error_cont expr = + transform_expr ctx expr ~error_cont Identity + +and handle_error_if_necessary ctx k ~error_cont expr = + match Stype.type_repr (Core.type_of_expr expr) with + | T_constr + { type_constructor = T_error_value_result; tys = [ ok_ty; err_ty ] } -> + let err_join = Ident.fresh "*handle_err" in + let join_param = Ident.fresh "*err" in + Core.letfn ~kind:Nontail_join err_join + { + params = + [ { binder = join_param; ty = err_ty; loc_ = Rloc.no_location } ]; + body = + Core.return ~ty:Stype.unit ~return_kind:Single_value + (resume ctx error_cont (Core.var join_param ~ty:err_ty)); + is_async = false; + } + (resume ctx k (Core.handle_error ~ty:ok_ty expr (Joinapply err_join))) + | _ -> resume ctx k expr + +and transform_nested_functions_in_expr ~global_env ~toplevel_id ty_params expr = + let visitor = + object (self) + inherit [_] Core.Map.map as super + + method! visit_Cexpr_prim ctx prim args ty loc = + match prim with + | Prun_async -> ( + match[@warning "-fragile-match"] args with + | async_fn :: [] -> ( + let async_fn = self#visit_expr ctx async_fn in + let cont = id_cont Stype.unit in + match async_fn with + | Cexpr_function + { + func = { params = param :: []; body; is_async = _ }; + ty = _; + } -> + Core.let_ param.binder cont body + | _ -> + let func_ty = Core.type_of_expr async_fn in + Core.bind async_fn (fun async_fn -> + Core.apply ~loc + ~kind:(Normal { func_ty }) + ~ty:Stype.unit async_fn [ cont ])) + | _ -> assert false) + | _ -> super#visit_Cexpr_prim ctx prim args ty loc + + method! visit_Cexpr_letfn (ty_params, toplevel_id) name fn body ty kind + loc = + let toplevel_id = + Type_path.map_toplevel_id toplevel_id (fun id -> + (id ^ "." ^ Ident.to_string name : Stdlib.String.t)) + in + super#visit_Cexpr_letfn (ty_params, toplevel_id) name fn body ty kind + loc + + method! visit_Cexpr_letrec (ty_params, toplevel_id) bindings body _ty loc + = + let bindings = + Lst.map bindings (fun (name, fn) -> + let toplevel_id = + Type_path.map_toplevel_id toplevel_id (fun id -> + (id ^ "." ^ Ident.to_string name : Stdlib.String.t)) + in + (name, self#visit_fn (ty_params, toplevel_id) fn)) + in + let body = self#visit_expr (ty_params, toplevel_id) body in + Core.letrec ~loc bindings body + + method! visit_Cexpr_function (ty_params, toplevel_id) func ty loc = + let toplevel_id = + Type_path.map_toplevel_id toplevel_id (fun id -> + let suffix = + if func.is_async then + ("/" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) + else "" + in + (id ^ ".lambda" ^ suffix : Stdlib.String.t)) + in + super#visit_Cexpr_function (ty_params, toplevel_id) func ty loc + + method! visit_fn (ty_params, toplevel_id) fn = + transform_fn ~global_env ~toplevel_id ty_params fn + end + in + visitor#visit_expr (ty_params, toplevel_id) expr + +and get_captures_of_loop ctx params body k = + let captures = + ref + (Core_util.free_vars + ~exclude:(Ident.Set.singleton ctx.driver_id) + { params; body; is_async = false }) + in + captures := add_captures_of_cont ctx !captures k; + let visitor = + object (self) + inherit [_] Core.Iter.iter as super + + method! visit_Cexpr_return ((ctx, captures) as env) arg _kind _ty _loc_ = + captures := add_captures_of_cont ctx !captures ctx.return_cont; + self#visit_expr env arg + + method! visit_Cexpr_break ((ctx, captures) as env) arg label _ty _loc = + (match arg with Some x -> self#visit_expr env x | _ -> ()); + match Label.Hash.find_opt ctx.loop_info label with + | Some { break_cont; loop_state = _ } -> + captures := add_captures_of_cont ctx !captures break_cont + | _ -> () + + method! visit_Cexpr_continue ((ctx, captures) as env) args label _ty _loc + = + Lst.iter args ~f:(self#visit_expr env); + match Label.Hash.find_opt ctx.loop_info label with + | Some { loop_state; break_cont = _ } -> + captures := + add_captures_of_cont ctx !captures + (Simple { state_id = loop_state }) + | _ -> () + + method! visit_Cexpr_apply ((ctx, captures) as env) fn args kind ty + ty_args_ prim loc = + match kind with + | Join -> ( + Lst.iter args ~f:(self#visit_expr env); + match Ident.Hash.find_opt ctx.join_to_state fn with + | Some state_id -> + captures := + add_captures_of_cont ctx !captures (Simple { state_id }) + | _ -> ()) + | Normal _ | Async _ -> + super#visit_Cexpr_apply env fn args kind ty ty_args_ prim loc + + method! visit_Cexpr_handle_error ((ctx, captures) as env) obj kind _ty + _loc = + self#visit_expr env obj; + match kind with + | To_result -> () + | Return_err _ -> + captures := add_captures_of_cont ctx !captures ctx.return_err_cont + | Joinapply join -> ( + match Ident.Hash.find_opt ctx.join_to_state join with + | Some state_id -> + captures := + add_captures_of_cont ctx !captures (Simple { state_id }) + | _ -> ()) + + method! visit_fn _ _fn = () + end + in + visitor#visit_expr (ctx, captures) body; + !captures + +and transform_fn ~global_env ~toplevel_id ty_params (fn : Core.fn) = + if fn.is_async then ( + let return_cont, return_err_cont, (cont_params : Core.param list) = + let cont_param = Ident.fresh "*cont" in + match Stype.type_repr (Core.type_of_expr fn.body) with + | T_constr + { type_constructor = T_error_value_result; tys = [ ok_ty; err_ty ] } + -> + let cont_ty = + Builtin.type_arrow [ ok_ty ] Stype.unit ~err_ty:None ~is_async:false + in + let err_cont_param = Ident.fresh "*err_cont" in + let err_cont_ty = + Builtin.type_arrow [ err_ty ] Stype.unit ~err_ty:None + ~is_async:false + in + ( Return { cont = cont_param; cont_ty }, + Return { cont = err_cont_param; cont_ty = err_cont_ty }, + [ + { binder = cont_param; ty = cont_ty; loc_ = Rloc.no_location }; + { + binder = err_cont_param; + ty = err_cont_ty; + loc_ = Rloc.no_location; + }; + ] ) + | ty -> + let cont_ty = + Builtin.type_arrow [ ty ] Stype.unit ~err_ty:None ~is_async:false + in + ( Return { cont = cont_param; cont_ty }, + Complex (fun _ -> assert false), + [ { binder = cont_param; ty = cont_ty; loc_ = Rloc.no_location } ] + ) + in + let state_ty_name = "State" in + let state_ty_path = Type_path.local_type toplevel_id state_ty_name in + let tys = Tvar_env.get_types ty_params in + let state_ty : Stype.t = + T_constr + { + type_constructor = state_ty_path; + tys; + generic_ = not (Tvar_env.is_empty ty_params); + is_suberror_ = false; + } + in + let driver_id = Ident.fresh "*async_driver" in + let ctx = + { + join_to_state = Ident.Hash.create 7; + loop_info = Label.Hash.create 7; + return_cont; + return_err_cont; + state_ty; + states = Vec.empty (); + ty_params; + driver_id; + driver_ty = + Builtin.type_arrow [ state_ty ] Stype.unit ~err_ty:None + ~is_async:false; + cont_params; + toplevel_id; + global_env; + } + in + let body = + transform_expr ctx fn.body ~error_cont:return_err_cont ctx.return_cont + in + let params = fn.params @ cont_params in + let state_param = Ident.fresh "*state" in + let state_constrs = + Vec.map_into_list ctx.states ~unorder:(fun state -> + (let { state_id; state_name; params; captures; body = _ } = state in + let args = + Lst.map_append params (Lst.map captures snd) (fun p -> p.ty) + in + { + constr_name = state_name; + cs_args = args; + cs_res = state_ty; + cs_tag = + Constr_tag_regular + { + total = + Constr_info.Index_set.singleton 0 + (Vec.length ctx.states - 1); + index = state_id; + name_ = state_name; + repr_ = Non_constant; + }; + cs_vis = Read_write; + cs_ty_params_ = ty_params; + cs_arity_ = Fn_arity.simple (List.length args); + cs_constr_loc_ = Loc.no_location; + cs_loc_ = Loc.no_location; + } + : Typedecl_info.constructor)) + in + Typing_info.add_type + (Global_env.get_toplevel_types global_env) + (Local_type.mangle_name toplevel_id state_ty_name) + (Local_type.to_generic_typedecl_info Loc.no_location + { + name = state_ty_name; + toplevel_id; + kind = Enum state_constrs; + loc_ = Rloc.no_location; + is_only_tag_enum = false; + ty_params_ = ty_params; + }); + let body = + let branches = + Vec.map_into_list ctx.states + ~unorder:(fun { state_id; state_name; params; captures; body } -> + let tag : Basic_constr_info.constr_tag = + Constr_tag_regular + { + total = + Constr_info.Index_set.singleton 0 (Vec.length ctx.states - 1); + index = state_id; + repr_ = Non_constant; + name_ = state_name; + } + in + let renaming = Ident.Hash.create 17 in + let capture_params = + Lst.map captures (fun (capture, ty) -> + let capture' = Ident.rename capture in + Ident.Hash.add renaming capture capture'; + (capture', ty)) + in + match + Lst.map_append params capture_params (fun p -> (p.binder, p.ty)) + with + | [] -> (tag, None, body) + | params -> + let binder = + Ident.fresh + (("*" ^ state_name : Stdlib.String.t) [@merlin.hide]) + in + let state_obj = + Core.var ~ty:(Type.make_constr_type state_ty ~tag) binder + in + let body = rename_visitor#visit_expr renaming body in + let body = + Lst.fold_left_with_offset params body 0 (fun (param, ty) -> + fun body -> + fun index -> + Core.let_ param + (Core.prim ~ty + (Penum_field { index; tag }) + [ state_obj ]) + body) + in + (tag, Some binder, body)) + in + match branches with + | [] -> body + | branches -> + Core.letfn ~kind:Rec driver_id + { + is_async = false; + params = + [ + { + binder = state_param; + ty = state_ty; + loc_ = Rloc.no_location; + }; + ]; + body = + Core.switch_constr + (Core.var state_param ~ty:state_ty) + branches ~default:None; + } + body + in + { is_async = false; params; body }) + else + { + fn with + body = + transform_nested_functions_in_expr ~global_env ~toplevel_id ty_params + fn.body; + } + +let eliminate_async ~global_env (prog : Core.program) = + Lst.map prog (fun top -> + (match top with + | Ctop_expr top_expr -> + Ctop_expr + { + top_expr with + expr = + transform_nested_functions_in_expr ~global_env + ~toplevel_id: + (T_regular + { pkg = !Basic_config.current_package; name = "*init" }) + Tvar_env.empty top_expr.expr; + } + | Ctop_let top_let -> ( + match[@warning "-fragile-match"] top_let.binder with + | Pdot qual_name -> + Ctop_let + { + top_let with + expr = + transform_nested_functions_in_expr ~global_env + ~toplevel_id:(Qual_ident.to_toplevel_id qual_name) + Tvar_env.empty top_let.expr; + } + | _ -> assert false) + | Ctop_fn ({ func; subtops; ty_params_; binder; _ } as top_fn) -> ( + assert (subtops = []); + match[@warning "-fragile-match"] binder with + | Pdot qual_name -> + Ctop_fn + { + top_fn with + func = + transform_fn ~global_env + ~toplevel_id:(Qual_ident.to_toplevel_id qual_name) + ty_params_ func; + } + | _ -> assert false) + | Ctop_stub _ -> top + : Core.top_item)) diff --git a/src/error_code.ml b/src/error_code.ml index d5b737a..4c421e8 100644 --- a/src/error_code.ml +++ b/src/error_code.ml @@ -21,22 +21,20 @@ include struct let _ = sexp_of_t let compare = - (fun a__001_ b__002_ -> Stdlib.compare (a__001_ : int) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.compare (a__001_ : int) b__002_ : t -> t -> int) let _ = compare let equal = - (fun a__003_ b__004_ -> Stdlib.( = ) (a__003_ : int) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.( = ) (a__003_ : int) b__004_ : t -> t -> bool) let _ = equal end -let t_to_json t : Json.t = `Int t let swallow_error = 0 let internal = 1 -let warning warning_id = 1000 + warning_id let alert = 2000 let lexing_error = 3001 let parse_error = 3002 @@ -50,17 +48,13 @@ let record_pattern_only_dotdot = 3009 let positional_argument_no_default = 3010 let invalid_left_value = 3011 let cannot_mix_record_and_map_pat = 3012 -let map_pattern_always_open = 3013 let inline_wasm_syntax_error = 3014 let no_default_for_question_optional = 3015 let invalid_tilde_argument = 3016 let json_parse_error = 3017 let bad_range_pattern_operand = 3018 let inclusive_range_pattern_no_upper_bound = 3019 - -let is_non_fatal_parse_error error_code = - error_code >= 3800 && error_code < 4000 - +let invalid_equal_in_struct_expr = 3020 let invalid_extra_delimiter = 3800 let duplicate_tvar = 4000 let field_visibility = 4001 @@ -84,11 +78,10 @@ let cannot_resolve_trait = 4018 let duplicated_label_in_decl = 4019 let pkg_not_loaded = 4020 let unbound_value = 4021 -let unbound_type = 4022 let unbound_trait = 4023 let unbound_type_or_trait = 4024 -let ambiguous_method = 4025 let unbound_field = 4026 +let unused_tvar = 4027 let not_a_record = 4028 let not_a_variant = 4029 let field_not_found = 4030 @@ -118,7 +111,6 @@ let cannot_determine_self_type = 4054 let field_duplicate = 4055 let method_duplicate = 4056 let constructor_duplicate = 4057 -let method_func_duplicate = 4058 let method_on_foreign_type = 4059 let ext_method_type_mismatch = 4060 let ext_method_foreign_trait_foreign_type = 4061 @@ -155,7 +147,8 @@ let record_type_missing = 4092 let not_a_record_type = 4093 let mutate_readonly_field = 4094 let overflow = 4095 -let invalid_newtype_index = 4096 +let overloaded_string_interpolation_for_bytes = 4096 +let not_a_type = 4099 let not_a_trait = 4100 let unsupported_pipe_expr = 4101 let outside_loop = 4102 @@ -202,11 +195,11 @@ let constant_pat_with_args = 4144 let cannot_implement_abstract_trait = 4145 let range_pattern_unsupported_type = 4146 let range_pattern_invalid_range = 4147 - -let to_string code = - let padding len x = - let m = string_of_int x in - String.make (Int.max 0 (len - String.length m)) '0' ^ m - in - let s = padding 4 code in - ("E" ^ s : Stdlib.String.t) +let use_undeclared_loop_label = 4148 +let async_not_allowed_in_context = 4149 +let async_call_attr_mismatch = 4150 +let func_ref_no_capture = 4151 +let constant_not_found = 4152 +let enum_tag_duplicate = 4153 +let non_constant_enum_no_custom_tag = 4154 +let cycle_in_const_decl = 4155 diff --git a/src/error_code_utils.ml b/src/error_code_utils.ml new file mode 100644 index 0000000..751a326 --- /dev/null +++ b/src/error_code_utils.ml @@ -0,0 +1,29 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +let to_json t = (`Int t : Json.t) + +let to_string code = + let padding len x = + let m = string_of_int x in + String.make (Int.max 0 (len - String.length m)) '0' ^ m + in + let s = padding 4 code in + ("E" ^ s : Stdlib.String.t) + +let is_non_fatal_parse_error error_code = + error_code >= 3800 && error_code < 4000 + +let warning warning_id = 1000 + warning_id diff --git a/src/errors.ml b/src/errors.ml index 090e703..78db827 100644 --- a/src/errors.ml +++ b/src/errors.ml @@ -18,351 +18,390 @@ module Type_path = Basic_type_path module Ident = Basic_ident module Lst = Basic_lst -type report = Local_diagnostics.report +type local_error = Local_diagnostics.error type loc = Rloc.t let type_path_name p = Type_path.short_name ~cur_pkg_name:(Some !Basic_config.current_package) p -let swallow_error : report = Local_diagnostics.swallow_error - -let internal message : Diagnostics.report = - { - message = "Compiler Internal Error: " ^ message; - loc = Loc.no_location; - error_code = Error_code.internal; - } - -let lexing_error ~loc_start ~loc_end message : Diagnostics.report = - { - loc = Loc.of_menhir (loc_start, loc_end); - message = "Lexing error: " ^ message; - error_code = Error_code.lexing_error; - } - -let parse_error ~loc_start ~loc_end message : Diagnostics.report = - { - loc = Loc.of_menhir (loc_start, loc_end); - message; - error_code = Error_code.parse_error; - } - -let json_parse_error ~loc_start ~loc_end message : Diagnostics.report = - { - loc = Loc.of_menhir (loc_start, loc_end); - message; - error_code = Error_code.json_parse_error; - } - -let invalid_init_or_main ~(kind : [ `Init | `Main ]) ~loc : Diagnostics.report = - let message = match kind with `Init -> "Init" | `Main -> "Main" in - { - loc; - message = - (message ^ " function must have no arguments and no return value." - : Stdlib.String.t); - error_code = Error_code.invalid_init_or_main; - } - -let missing_parameter_list ~name ~loc : report = - let message = - ("Missing parameters list. Add `()` if function `" ^ name - ^ "` has 0 parameter." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.missing_parameter_list } - -let unexpected_token ~found ~expected ~loc : Diagnostics.report = - let message = - Stdlib.String.concat "" - [ - "Parse error, unexpected token "; - found; - ", you may expect "; - expected; - "."; - ] - in - { message; loc; error_code = Error_code.parse_error } - -let unexpected_line_break ~expected ~loc : Diagnostics.report = - let message = - ("Unexpected line break here, missing " ^ expected - ^ " at the end of this line." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.parse_error } - -let unexpected_token_maybe_forget_indent ~expected ~next ~loc : - Diagnostics.report = - let message = - Stdlib.String.concat "" - [ - "Parse error, expect "; - expected; - ". Did you forget to indent the local "; - next; - "?"; - ] - in - { message; loc; error_code = Error_code.parse_error } - -let invalid_visibility ~entity ~vis ~loc : report = - let message = - Stdlib.String.concat "" [ "No '"; vis; "' visibility for "; entity; "." ] - in - { message; loc; error_code = Error_code.invalid_visibility } - -let enum_no_individual_visibility loc : report = - { - message = "No individual visibility for enum constructor."; - loc; - error_code = Error_code.enum_no_individual_visibility; - } - -let dotdot_in_middle_of_pattern ~(kind : [ `Record | `Constr ]) ~loc : report = - let component, kind = - match kind with - | `Record -> ("field", "record") - | `Constr -> ("argument", "constructor arguments") - in - let message = - Stdlib.String.concat "" - [ - "Unexpected `..` here, add `, ..` behind the last "; - component; - " to ignore the rest of "; - kind; - "."; - ] - in - { message; loc; error_code = Error_code.dotdot_in_middle_of_pattern } - -let array_pat_multiple_dotdot loc : report = - { - message = "At most one `..` is allowed in array pattern."; - loc; - error_code = Error_code.array_pat_multiple_dotdot; - } - -let record_pattern_only_dotdot loc : report = - { - message = - "Record pattern cannot contain only `..`, use wildcard pattern `_` \ - instead."; - loc; - error_code = Error_code.record_pattern_only_dotdot; - } - -let positional_argument_no_default loc : report = - { - message = "Only labelled arguments can have default value."; - loc; - error_code = Error_code.positional_argument_no_default; - } - -let invalid_left_value loc : report = - { - message = "Invalid left value for assignment."; - loc; - error_code = Error_code.invalid_left_value; - } - -let bad_range_pattern_operand loc : report = - { - message = - "Bounds of range pattern must be constant, named constant or wildcard."; - loc; - error_code = Error_code.bad_range_pattern_operand; - } - -let inclusive_range_pattern_no_upper_bound loc : report = - { - message = "Inclusive range pattern `a..=b` cannot have `_` as upper bound"; - loc; - error_code = Error_code.inclusive_range_pattern_no_upper_bound; - } - -let cannot_mix_record_and_map_pat loc : report = - { - message = "Record pattern and map pattern cannot be mixed."; - loc; - error_code = Error_code.cannot_mix_record_and_map_pat; - } - -let map_pattern_always_open loc : report = - { - message = "Map patterns are always open, the `..` is useless."; - loc; - error_code = Error_code.map_pattern_always_open; - } - -let inline_wasm_syntax_error ~message ~loc_inside_wasm ~loc : Diagnostics.report - = - { - message = - Stdlib.String.concat "" - [ - "Inline wasm syntax error: "; - message; - " at "; - Loc.loc_range_string_no_filename loc_inside_wasm; - ]; - loc; - error_code = Error_code.inline_wasm_syntax_error; - } - -let duplicate_tvar ~name ~loc : report = - { - loc; - message = - ("Generic type variable name '" ^ name ^ "' is already used." - : Stdlib.String.t); - error_code = Error_code.duplicate_tvar; - } - -let field_visibility ~field_vis ~type_vis ~loc : report = - { - loc; - message = - Stdlib.String.concat "" - [ - "A "; - field_vis; - " field cannot be declared within a "; - type_vis; - " struct."; - ]; - error_code = Error_code.field_visibility; - } - -let unsupported_modifier ~modifier ~loc : report = - let message = - ("The " ^ modifier ^ " modifier is not supported here" : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unsupported_modifier } - -let reserved_type_name ~(decl_kind : [ `Tvar | `Type | `Trait ]) ~name ~loc : - report = - let name_decl_kind = - match decl_kind with - | `Tvar -> "type variable" - | `Type -> "type" - | `Trait -> "trait" - in - let message = - Stdlib.String.concat "" - [ - "\""; - name; - "\" is a reserved type name. Cannot declare it as "; - name_decl_kind; - ] - in - { message; loc; error_code = Error_code.reserved_type_name } - -let trait_method_cannot_poly loc : report = - let message = "polymorphic trait method is not supported" in - { message; loc; error_code = Error_code.trait_method_cannot_poly } - -let trait_duplicate_method ~trait ~name ~first ~second : report = - let message = - Stdlib.String.concat "" - [ - "method "; - name; - " of trait "; - trait; - " is declared multiple times (first at "; - Loc.to_string first; - ")"; - ] - in - { message; loc = second; error_code = Error_code.trait_duplicate_method } - -let duplicate_local_fns ~name ~loc ~prev_loc : report = - let message = - Stdlib.String.concat "" - [ - "local function '"; - name; - "' is already defined at "; - Int.to_string (Loc.line_number prev_loc); - ":"; - Int.to_string (Loc.column_number prev_loc); - ] - in - { message; loc; error_code = Error_code.duplicate_local_fns } - -let illform_constr_arg loc : report = - let message = ("constructor can't take unit as argument" : Stdlib.String.t) in - { message; loc; error_code = Error_code.illform_constr_arg } - -let ffi_cannot_poly loc : Diagnostics.report = - let message = "FFI function cannot have type parameters." in - { message; loc; error_code = Error_code.ffi_cannot_poly } - -let matchfn_arity_mismatch ~loc ~expected ~actual : report = - let message = - Stdlib.String.concat "" - [ - "Match function expects "; - Int.to_string expected; - " arguments, but "; - Int.to_string actual; - " arguments are provided."; - ] - in - { message; loc; error_code = Error_code.matchfn_arity_mismatch } - -let no_vis_on_default_impl loc : report = - let message = - ("`pub` is not allowed on default implementation for traits." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.no_vis_on_default_impl } - -let no_quantifiers_on_default_impl loc : report = - let message = - ("Type parameters are not allowed on default implementation for traits." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.no_quantifiers_on_default_impl } - -let constr_no_mut_positional_field loc : report = - let message = - ("Mutable constructor fields are only allowed on labelled arguments." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.constr_no_mut_positional_field } - -let func_param_num_mismatch ~expected ~actual ~ty ~loc : report = - let message = - Stdlib.String.concat "" - [ - "This function has type "; - ty; - ", which expects "; - Int.to_string expected; - " argument(s), but is given "; - Int.to_string actual; - " argument(s)."; - ] - in - { message; loc; error_code = Error_code.func_param_num_mismatch } - -let generic_type_mismatch ~header ~expected ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - header; - "\n has type : "; - actual; - "\n wanted : "; - expected; - ] - in - { message; loc; error_code = Error_code.type_mismatch } +let swallow_error : local_error = Local_diagnostics.swallow_error + +let internal message = + ({ + message = ("Compiler Internal Error: " ^ message : Stdlib.String.t); + loc = Loc.no_location; + error_code = Error_code.internal; + } + : Diagnostics.report) + +let lexing_error ~loc_start ~loc_end message = + ({ + loc = Loc.of_menhir (loc_start, loc_end); + message = "Lexing error: " ^ message; + error_code = Error_code.lexing_error; + } + : Diagnostics.report) + +let parse_error ~loc_start ~loc_end message = + ({ + loc = Loc.of_menhir (loc_start, loc_end); + message; + error_code = Error_code.parse_error; + } + : Diagnostics.report) + +let attribute_parse_error ~loc message = + ({ loc; message; error_code = Error_code.parse_error } : local_error) + +let json_parse_error ~loc_start ~loc_end message = + ({ + loc = Loc.of_menhir (loc_start, loc_end); + message; + error_code = Error_code.json_parse_error; + } + : Diagnostics.report) + +let invalid_init_or_main ~(kind : [ `Init | `Main ]) ~loc = + (let message = match kind with `Init -> "Init" | `Main -> "Main" in + { + loc; + message = + (message ^ " function must have no arguments and no return value." + : Stdlib.String.t); + error_code = Error_code.invalid_init_or_main; + } + : Diagnostics.report) + +let missing_parameter_list ~name ~loc = + (let message = + ("Missing parameters list. Add `()` if function `" ^ name + ^ "` has 0 parameter." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.missing_parameter_list } + : local_error) + +let unexpected_token ~found ~expected ~loc = + (let message = + Stdlib.String.concat "" + [ + "Parse error, unexpected token "; + found; + ", you may expect "; + expected; + "."; + ] + in + { message; loc; error_code = Error_code.parse_error } + : Diagnostics.report) + +let unexpected_line_break ~expected ~loc = + (let message = + ("Unexpected line break here, missing " ^ expected + ^ " at the end of this line." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.parse_error } + : Diagnostics.report) + +let unexpected_token_maybe_forget_indent ~expected ~next ~loc = + (let message = + Stdlib.String.concat "" + [ + "Parse error, expect "; + expected; + ". Did you forget to indent the local "; + next; + "?"; + ] + in + { message; loc; error_code = Error_code.parse_error } + : Diagnostics.report) + +let invalid_visibility ~entity ~vis ~loc = + (let message = + Stdlib.String.concat "" [ "No '"; vis; "' visibility for "; entity; "." ] + in + { message; loc; error_code = Error_code.invalid_visibility } + : local_error) + +let enum_no_individual_visibility loc = + ({ + message = "No individual visibility for enum constructor."; + loc; + error_code = Error_code.enum_no_individual_visibility; + } + : local_error) + +let dotdot_in_middle_of_pattern ~(kind : [ `Record | `Constr | `Map ]) ~loc = + (let component, kind = + match kind with + | `Record -> ("field", "record") + | `Constr -> ("argument", "constructor arguments") + | `Map -> ("element", "map") + in + let message = + Stdlib.String.concat "" + [ + "Unexpected `..` here, add `, ..` behind the last "; + component; + " to ignore the rest of "; + kind; + "."; + ] + in + { message; loc; error_code = Error_code.dotdot_in_middle_of_pattern } + : local_error) + +let array_pat_multiple_dotdot loc = + ({ + message = "At most one `..` is allowed in array pattern."; + loc; + error_code = Error_code.array_pat_multiple_dotdot; + } + : local_error) + +let record_pattern_only_dotdot loc = + ({ + message = + "Record pattern cannot contain only `..`, use wildcard pattern `_` \ + instead."; + loc; + error_code = Error_code.record_pattern_only_dotdot; + } + : local_error) + +let positional_argument_no_default loc = + ({ + message = "Only labelled arguments can have default value."; + loc; + error_code = Error_code.positional_argument_no_default; + } + : local_error) + +let invalid_left_value loc = + ({ + message = "Invalid left value for assignment."; + loc; + error_code = Error_code.invalid_left_value; + } + : local_error) + +let bad_range_pattern_operand loc = + ({ + message = + "Bounds of range pattern must be constant, named constant or wildcard."; + loc; + error_code = Error_code.bad_range_pattern_operand; + } + : local_error) + +let inclusive_range_pattern_no_upper_bound loc = + ({ + message = "Inclusive range pattern `a..=b` cannot have `_` as upper bound"; + loc; + error_code = Error_code.inclusive_range_pattern_no_upper_bound; + } + : local_error) + +let invalid_equal_in_struct_expr ~loc = + (let message = + "Unexpected `=` in struct expression. The correct syntax for struct \ + expression is `{ field: expression }`." + in + { message; loc; error_code = Error_code.invalid_equal_in_struct_expr } + : local_error) + +let cannot_mix_record_and_map_pat loc = + ({ + message = "Record pattern and map pattern cannot be mixed."; + loc; + error_code = Error_code.cannot_mix_record_and_map_pat; + } + : local_error) + +let inline_wasm_syntax_error ~message ~loc_inside_wasm ~loc = + ({ + message = + Stdlib.String.concat "" + [ + "Inline wasm syntax error: "; + message; + " at "; + Loc.loc_range_string_no_filename loc_inside_wasm; + ]; + loc; + error_code = Error_code.inline_wasm_syntax_error; + } + : Diagnostics.report) + +let duplicate_tvar ~name ~loc = + ({ + loc; + message = + ("Generic type variable name '" ^ name ^ "' is already used." + : Stdlib.String.t); + error_code = Error_code.duplicate_tvar; + } + : local_error) + +let field_visibility ~field_vis ~type_vis ~loc = + ({ + loc; + message = + Stdlib.String.concat "" + [ + "A "; + field_vis; + " field cannot be declared within a "; + type_vis; + " struct."; + ]; + error_code = Error_code.field_visibility; + } + : local_error) + +let unsupported_modifier ~modifier ~loc = + (let message = + ("The " ^ modifier ^ " modifier is not supported here" : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unsupported_modifier } + : local_error) + +let reserved_type_name ~(decl_kind : [ `Tvar | `Type | `Trait ]) ~name ~loc = + (let name_decl_kind = + match decl_kind with + | `Tvar -> "type variable" + | `Type -> "type" + | `Trait -> "trait" + in + let message = + Stdlib.String.concat "" + [ + "\""; + name; + "\" is a reserved type name. Cannot declare it as "; + name_decl_kind; + ] + in + { message; loc; error_code = Error_code.reserved_type_name } + : local_error) + +let trait_method_cannot_poly loc = + (let message = "polymorphic trait method is not supported" in + { message; loc; error_code = Error_code.trait_method_cannot_poly } + : local_error) + +let trait_duplicate_method ~trait ~name ~first ~second = + (let message = + Stdlib.String.concat "" + [ + "method "; + name; + " of trait "; + trait; + " is declared multiple times (first at "; + Loc.to_string first; + ")"; + ] + in + { message; loc = second; error_code = Error_code.trait_duplicate_method } + : local_error) + +let duplicate_local_fns ~name ~loc ~prev_loc = + (let message = + Stdlib.String.concat "" + [ + "local function '"; + name; + "' is already defined at "; + Int.to_string (Loc.line_number prev_loc); + ":"; + Int.to_string (Loc.column_number prev_loc); + ] + in + { message; loc; error_code = Error_code.duplicate_local_fns } + : local_error) + +let illform_constr_arg loc = + (let message = + ("constructor without payload cannot be called with ()" : Stdlib.String.t) + in + { message; loc; error_code = Error_code.illform_constr_arg } + : local_error) + +let ffi_cannot_poly loc = + (let message = "FFI function cannot have type parameters." in + { message; loc; error_code = Error_code.ffi_cannot_poly } + : Diagnostics.report) + +let matchfn_arity_mismatch ~loc ~expected ~actual = + (let message = + Stdlib.String.concat "" + [ + "Match function expects "; + Int.to_string expected; + " arguments, but "; + Int.to_string actual; + " arguments are provided."; + ] + in + { message; loc; error_code = Error_code.matchfn_arity_mismatch } + : local_error) + +let no_vis_on_default_impl loc = + (let message = + ("`pub` is not allowed on default implementation for traits." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.no_vis_on_default_impl } + : local_error) + +let no_quantifiers_on_default_impl loc = + (let message = + ("Type parameters are not allowed on default implementation for traits." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.no_quantifiers_on_default_impl } + : local_error) + +let constr_no_mut_positional_field loc = + (let message = + ("Mutable constructor fields are only allowed on labelled arguments." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.constr_no_mut_positional_field } + : local_error) + +let func_param_num_mismatch ~expected ~actual ~ty ~loc = + (let message = + Stdlib.String.concat "" + [ + "This function has type "; + ty; + ", which expects "; + Int.to_string expected; + " argument(s), but is given "; + Int.to_string actual; + " argument(s)."; + ] + in + { message; loc; error_code = Error_code.func_param_num_mismatch } + : local_error) + +let generic_type_mismatch ~header ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + header; + "\n has type : "; + actual; + "\n wanted : "; + expected; + ] + in + { message; loc; error_code = Error_code.type_mismatch } + : local_error) let type_mismatch ~expected ~actual ~loc = generic_type_mismatch ~header:"Type Mismatch" ~expected ~actual ~loc @@ -384,426 +423,447 @@ let constr_unify ~name ~expected ~actual ~loc = ~header:("Constr Type Mismatch(constructor " ^ name ^ ")" : Stdlib.String.t) ~expected ~actual ~loc -let cascade_type_mismatch ~actual ~loc : report = - let message = - ("This method returns " ^ actual - ^ ", but only methods that return Unit can be used with `..`." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.type_mismatch } - -let cannot_resolve_method ~ty ~name ~loc ~hint : report = - let message = - match hint with - | `Record -> - Stdlib.String.concat "" - [ - "Type "; - ty; - " has no method "; - name; - ".\n (hint: to apply record field as function, write `(x."; - name; - ")(...)` instead)"; - ] - | `Trait -> - Stdlib.String.concat "" [ "Trait "; ty; " has no method "; name; "." ] - | `No_hint -> - Stdlib.String.concat "" [ "Type "; ty; " has no method "; name; "." ] - in - { message; loc; error_code = Error_code.cannot_resolve_method } - -let cannot_resolve_infix_op ~method_name ~op_name ~ty ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Please implement the method "; - method_name; - " for the type "; - ty; - " to use the infix operator \""; - op_name; - "\"."; - ] - in - { message; loc; error_code = Error_code.cannot_resolve_infix_op } - -let ambiguous_trait_method ~label ~ty ~first ~second ~loc : report = - let message = - Stdlib.String.concat "" - [ - label; - " of type "; - ty; - " is ambiguious, it may come from trait "; - first; - " or "; - second; - ] - in - { message; loc; error_code = Error_code.ambiguous_trait_method } - -let cannot_resolve_trait ~loc ~message : report = - { message; loc; error_code = Error_code.cannot_resolve_trait } - -let interp_to_string_incorrect_type ~self_ty ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Method `to_string` of type "; - self_ty; - " has type "; - actual; - ", but is expected to have type ("; - self_ty; - ") -> String."; - ] - in - { message; loc; error_code = Error_code.type_mismatch } - -let duplicated_label_in_decl ~label ~first_loc ~second_loc : report = - let message = - Stdlib.String.concat "" - [ - "The label "; - label; - "~ is declared twice in this function, first in "; - Loc.to_string first_loc; - ] - in - { - message; - loc = second_loc; - error_code = Error_code.duplicated_label_in_decl; - } - -let pkg_not_loaded ~pkg ~loc : report = - let message = - ("Package \"" ^ pkg ^ "\" not found in the loaded packages." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.pkg_not_loaded } - -let unbound_value ~name ~loc : report = - let message = - match (name : Longident.t) with - | Lident id -> - ("The value identifier " ^ id ^ " is unbound." : Stdlib.String.t) - | Ldot { pkg; id } -> - Printf.sprintf "Value %s not found in package %S." id pkg - in - { message; loc; error_code = Error_code.unbound_value } - -let unbound_type ~name ~loc : report = - let message = - match (name : Longident.t) with - | Lident id -> - ("The type constructor " ^ id ^ " is not found." : Stdlib.String.t) - | Ldot { pkg; id } -> - Printf.sprintf "Type %s not found in package %S." id pkg - in - { message; loc; error_code = Error_code.unbound_type } - -let unbound_trait ~name ~loc : report = - let message = - match (name : Longident.t) with - | Lident id -> ("The trait " ^ id ^ " is not found." : Stdlib.String.t) - | Ldot { pkg; id } -> - Printf.sprintf "Trait %s not found in package %S." id pkg - in - { message; loc; error_code = Error_code.unbound_trait } - -let unbound_type_or_trait ~name ~loc : report = - let message = - ("The type/trait " ^ Longident.to_string name ^ " is not found." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unbound_type_or_trait } - -let ambiguous_method ~name ~type_locs ~loc : report = - let info = - type_locs - |> List.map (fun (s, loc) : Stdlib.String.t -> - Loc.to_string loc ^ " " ^ type_path_name s) - |> String.concat "\n" - in - let message = - Stdlib.String.concat "" - [ - "Method "; - name; - " has been defined for the following types:\n"; - info; - "."; - ] - in - { message; loc; error_code = Error_code.ambiguous_method } - -let unbound_field ~name ~loc : report = - let message = ("The field " ^ name ^ " is not found." : Stdlib.String.t) in - { message; loc; error_code = Error_code.unbound_field } - -let not_a_record ~may_be_method ~ty ~kind ~loc : report = - let base_message = - Stdlib.String.concat "" - [ - "This expression has type "; - ty; - ", which is a "; - kind; - " type and not a record."; - ] - in - let message = - match may_be_method with - | Some field -> - Stdlib.String.concat "" - [ - base_message; - "\n (hint: to pass method as function, write `fn (...) { x."; - field; - "(...) }` instead)"; - ] - | None -> base_message - in - { message; loc; error_code = Error_code.not_a_record } - -let not_a_variant ~ty ~kind ~loc : report = - let message = - Stdlib.String.concat "" - [ - "This expression has type "; - ty; - ", which is a "; - kind; - " type and not a variant."; - ] - in - { message; loc; error_code = Error_code.not_a_variant } - -let field_not_found ~ty ~label ~loc : report = - let message = - Stdlib.String.concat "" - [ "The record type "; ty; " does not have the field "; label; "." ] - in - { message; loc; error_code = Error_code.field_not_found } - -let constr_not_found ~ty ~constr ~loc : report = - let message = - match ty with - | None -> ("The value " ^ constr ^ " is undefined." : Stdlib.String.t) - | Some ty -> - Stdlib.String.concat "" - [ - "The variant type "; - ty; - " does not have the constructor "; - constr; - "."; - ] - in - { message; loc; error_code = Error_code.constr_not_found } - -let type_not_found ~tycon ~loc : report = - let message = ("The type " ^ tycon ^ " is undefined." : Stdlib.String.t) in - { message; loc; error_code = Error_code.type_not_found } - -let cannot_resolve_record ~labels ~loc : report = - let labels = String.concat ", " labels in - let message = - ("There is no record definition with the fields: " ^ labels ^ "." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.cannot_resolve_record } - -let ambiguous_record ~names ~loc : report = - let names = String.concat ", " names in - let message = - ("Mutiple possible record types detected: " ^ names - ^ ", please add more annotation." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.ambiguous_record } - -let readonly_type ~name ~loc : report = - let message = - ("Cannot create values of the read-only type: " ^ name ^ "." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.readonly_type } - -let cannot_create_struct_with_priv_field ~name ~loc : report = - let message = - ("Cannot create values of struct type " ^ name - ^ " because it contains private field(s)." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.readonly_type } - -let pkg_not_imported ~name ~action ~loc : report = - let message = - Stdlib.String.concat "" - [ "Cannot "; action; ": package "; name; " is not imported." ] - in - { message; loc; error_code = Error_code.pkg_not_imported } - -let type_not_object_safe ~name ~reasons ~loc : report = - let header = - ("Trait object for " ^ name ^ " is not allowed:" : Stdlib.String.t) - in - let message = - match reasons with - | [] -> assert false - | reason :: [] -> header ^ " " ^ reason - | reasons -> header ^ "\n " ^ String.concat "\n " reasons - in - { message; loc; error_code = Error_code.type_not_object_safe } - -let method_not_found_in_trait ~trait ~method_name ~loc : report = - let message = - Stdlib.String.concat "" - [ "There is no method "; method_name; " in trait "; type_path_name trait ] - in - { message; loc; error_code = Error_code.method_not_found_in_trait } - -let cannot_use_method_of_abstract_trait ~trait ~method_name ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Cannot use method "; - method_name; - " of abstract trait "; - type_path_name trait; - ] - in - { message; loc; error_code = Error_code.method_not_found_in_trait } - -let type_constr_arity_mismatch ~kind ~id ~expected ~actual ~loc : report = - let message = - Printf.sprintf - "The %s %s expects %d argument(s), but is here given %d argument(s)." kind - (Longident.to_string id) expected actual - in - { message; loc; error_code = Error_code.type_constr_arity_mismatch } - -let unexpected_partial_type loc : report = - let message = "Partial type is not allowed in toplevel declarations." in - { message; loc; error_code = Error_code.unexpected_partial_type } - -let invalid_stub_type loc : report = - { - message = "Invalid stub type."; - loc; - error_code = Error_code.invalid_stub_type; - } - -let duplicate_record_field ~label ~context ~loc : report = - let message = - match context with - | `Pattern -> - ("The record field " ^ label - ^ " is matched several times in this pattern." - : Stdlib.String.t) - | `Creation -> - ("The record field " ^ label ^ " is defined several times." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.duplicate_record_field } - -let missing_fields_in_record ~labels ~ty ~context ~loc : report = - let message = - let labels_str = String.concat ", " labels in - match context with - | `Pattern -> - ("Record fields " ^ labels_str - ^ " are unmatched, use `..` to ignore them." - : Stdlib.String.t) - | `Creation -> - Stdlib.String.concat "" - [ "Record fields "; labels_str; " are undefined for type "; ty ] - in - { message; loc; error_code = Error_code.missing_fields_in_record } - -let superfluous_field ~label ~ty ~loc : report = - let message = - Stdlib.String.concat "" - [ "The fields "; label; " is not defined in the record type "; ty; "." ] - in - { message; loc; error_code = Error_code.superfluous_field } - -let cannot_depend_private ~entity ~loc : report = - let message = - ("A public definition cannot depend on private " ^ entity : Stdlib.String.t) - in - { message; loc; error_code = Error_code.cannot_depend_private } - -let alias_with_priv_target_in_pub_sig ~alias ~priv_type ~loc : report = - let message = - Stdlib.String.concat "" - [ - "The alias "; - alias; - " cannot be used in public signature, becasu it mentions private type "; - priv_type; - ] - in - { message; loc; error_code = Error_code.cannot_depend_private } - -let pkg_not_found ~pkg : Diagnostics.report = - let message = - ("Package " ^ pkg ^ " not found when loading packages." : Stdlib.String.t) - in - { message; loc = Loc.no_location; error_code = Error_code.pkg_not_found } - -let pkg_wrong_format ~pkg : Diagnostics.report = - let message = - ("The package file of " ^ pkg ^ " is in wrong format" : Stdlib.String.t) - in - { message; loc = Loc.no_location; error_code = Error_code.pkg_wrong_format } - -let pkg_magic_mismatch ~pkg : Diagnostics.report = - let message = - ("Magic number mismatch for the package file of " ^ pkg : Stdlib.String.t) - in - { message; loc = Loc.no_location; error_code = Error_code.pkg_magic_mismatch } - -let cycle_definitions ~cycle ~locs : Diagnostics.report list = - let rec make_string (idents : Ident.t list) head = - match idents with - | [] -> "" - | i :: [] -> Ident.base_name i ^ " -> " ^ Ident.base_name head - | i :: rest -> Ident.base_name i ^ " -> " ^ make_string rest head - in - let make_report loc = - let message = - Printf.sprintf "Definition cycle detected : %s" - (make_string cycle (List.hd cycle)) - in - ({ message; loc; error_code = Error_code.cycle_definitions } - : Diagnostics.report) - in - Lst.map locs make_report +let cascade_type_mismatch ~actual ~loc = + (let message = + ("This method returns " ^ actual + ^ ", but only methods that return Unit can be used with `..`." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.type_mismatch } + : local_error) + +let cannot_resolve_method ~ty ~name ~loc ~hint = + (let message = + match hint with + | `Record -> + Stdlib.String.concat "" + [ + "Type "; + ty; + " has no method "; + name; + ".\n (hint: to apply record field as function, write `(x."; + name; + ")(...)` instead)"; + ] [@merlin.hide] + | `Trait -> + Stdlib.String.concat "" + [ "Trait "; ty; " has no method "; name; "." ] [@merlin.hide] + | `No_hint -> + Stdlib.String.concat "" + [ "Type "; ty; " has no method "; name; "." ] [@merlin.hide] + in + { message; loc; error_code = Error_code.cannot_resolve_method } + : local_error) + +let cannot_resolve_infix_op ~method_name ~op_name ~ty ~loc = + (let message = + Stdlib.String.concat "" + [ + "Please implement the method "; + method_name; + " for the type "; + ty; + " to use the infix operator \""; + op_name; + "\"."; + ] + in + { message; loc; error_code = Error_code.cannot_resolve_infix_op } + : local_error) + +let ambiguous_trait_method ~label ~ty ~first ~second ~loc = + (let message = + Stdlib.String.concat "" + [ + label; + " of type "; + ty; + " is ambiguious, it may come from trait "; + first; + " or "; + second; + ] + in + { message; loc; error_code = Error_code.ambiguous_trait_method } + : local_error) + +let cannot_resolve_trait ~loc ~message = + ({ message; loc; error_code = Error_code.cannot_resolve_trait } : local_error) + +let duplicated_label_in_decl ~label ~first_loc ~second_loc = + (let message = + Stdlib.String.concat "" + [ + "The label "; + label; + "~ is declared twice in this function, first in "; + Loc.to_string first_loc; + ] + in + { + message; + loc = second_loc; + error_code = Error_code.duplicated_label_in_decl; + } + : local_error) + +let pkg_not_loaded ~pkg ~loc = + (let message = + ("Package \"" ^ pkg ^ "\" not found in the loaded packages." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.pkg_not_loaded } + : local_error) + +let unbound_value ~name ~loc = + (let message = + match (name : Longident.t) with + | Lident id -> + ("The value identifier " ^ id ^ " is unbound." + : Stdlib.String.t) + [@merlin.hide] + | Ldot { pkg; id } -> + Stdlib.String.concat "" + [ "Value "; id; " not found in package `"; pkg; "`." ] [@merlin.hide] + in + { message; loc; error_code = Error_code.unbound_value } + : local_error) + +let unbound_trait ~name ~loc = + (let message = + match (name : Longident.t) with + | Lident id -> + ("The trait " ^ id ^ " is not found." : Stdlib.String.t) [@merlin.hide] + | Ldot { pkg; id } -> + Stdlib.String.concat "" + [ "Trait "; id; " not found in package `"; pkg; "`." ] [@merlin.hide] + in + { message; loc; error_code = Error_code.unbound_trait } + : local_error) + +let unbound_type_or_trait ~name ~loc = + (let message = + ("The type/trait " ^ Longident.to_string name ^ " is not found." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unbound_type_or_trait } + : local_error) + +let unbound_field ~name ~loc = + (let message = ("The field " ^ name ^ " is not found." : Stdlib.String.t) in + { message; loc; error_code = Error_code.unbound_field } + : local_error) + +let not_a_record ~may_be_method ~ty ~kind ~loc = + (let base_message = + Stdlib.String.concat "" + [ + "This expression has type "; + ty; + ", which is a "; + kind; + " type and not a record."; + ] + in + let message = + match may_be_method with + | Some field -> + Stdlib.String.concat "" + [ + base_message; + "\n (hint: to pass method as function, write `fn (...) { x."; + field; + "(...) }` instead)"; + ] [@merlin.hide] + | None -> base_message + in + { message; loc; error_code = Error_code.not_a_record } + : local_error) + +let not_a_variant ~ty ~kind ~loc = + (let message = + Stdlib.String.concat "" + [ + "The type "; + ty; + " is a "; + kind; + " type and not a variant, so it does not have any constructor."; + ] + in + { message; loc; error_code = Error_code.not_a_variant } + : local_error) + +let field_not_found ~ty ~label ~loc = + (let message = + Stdlib.String.concat "" + [ "The record type "; ty; " does not have the field "; label; "." ] + in + { message; loc; error_code = Error_code.field_not_found } + : local_error) + +let constr_not_found ~ty ~constr ~loc = + (let message = + match ty with + | None -> + ("The value " ^ constr ^ " is undefined." + : Stdlib.String.t) + [@merlin.hide] + | Some ty -> + Stdlib.String.concat "" + [ + "The variant type "; + ty; + " does not have the constructor "; + constr; + "."; + ] [@merlin.hide] + in + { message; loc; error_code = Error_code.constr_not_found } + : local_error) + +let type_not_found ~tycon ~loc = + (let message = ("The type " ^ tycon ^ " is undefined." : Stdlib.String.t) in + { message; loc; error_code = Error_code.type_not_found } + : local_error) + +let cannot_resolve_record ~labels ~loc = + (let labels = String.concat ", " labels in + let message = + ("There is no record definition with the fields: " ^ labels ^ "." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.cannot_resolve_record } + : local_error) + +let ambiguous_record ~names ~loc = + (let names = String.concat ", " names in + let message = + ("Mutiple possible record types detected: " ^ names + ^ ", please add more annotation." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.ambiguous_record } + : local_error) + +let readonly_type ~name ~loc = + (let message = + ("Cannot create values of the read-only type: " ^ name ^ "." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.readonly_type } + : local_error) + +let cannot_create_struct_with_priv_field ~name ~loc = + (let message = + ("Cannot create values of struct type " ^ name + ^ " because it contains private field(s)." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.readonly_type } + : local_error) + +let pkg_not_imported ~name ~action ~loc = + (let message = + Stdlib.String.concat "" + [ "Cannot "; action; ": package "; name; " is not imported." ] + in + { message; loc; error_code = Error_code.pkg_not_imported } + : local_error) + +let type_not_object_safe ~name ~reasons ~loc = + (let header = + ("Trait object for " ^ name ^ " is not allowed:" : Stdlib.String.t) + in + let message = + match reasons with + | [] -> assert false + | reason :: [] -> header ^ " " ^ reason + | reasons -> header ^ "\n " ^ String.concat "\n " reasons + in + { message; loc; error_code = Error_code.type_not_object_safe } + : local_error) + +let method_not_found_in_trait ~trait ~method_name ~loc = + (let message = + Stdlib.String.concat "" + [ + "There is no method "; method_name; " in trait "; type_path_name trait; + ] + in + { message; loc; error_code = Error_code.method_not_found_in_trait } + : local_error) + +let cannot_use_method_of_abstract_trait ~trait ~method_name ~loc = + (let message = + Stdlib.String.concat "" + [ + "Cannot use method "; + method_name; + " of abstract trait "; + type_path_name trait; + ] + in + { message; loc; error_code = Error_code.method_not_found_in_trait } + : local_error) + +let type_constr_arity_mismatch ~kind ~id ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + "The "; + kind; + " "; + Longident.to_string id; + " expects "; + Int.to_string expected; + " argument(s), but is here given "; + Int.to_string actual; + " argument(s)."; + ] + in + { message; loc; error_code = Error_code.type_constr_arity_mismatch } + : local_error) + +let unexpected_partial_type loc = + (let message = + ("Partial type is not allowed in toplevel declarations." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unexpected_partial_type } + : local_error) + +let invalid_stub_type loc = + (let message = ("Invalid stub type." : Stdlib.String.t) in + { message; loc; error_code = Error_code.invalid_stub_type } + : local_error) + +let duplicate_record_field ~label ~context ~loc = + (let message = + match context with + | `Pattern -> + ("The record field " ^ label + ^ " is matched several times in this pattern." + : Stdlib.String.t) + [@merlin.hide] + | `Creation -> + ("The record field " ^ label ^ " is defined several times." + : Stdlib.String.t) + [@merlin.hide] + in + { message; loc; error_code = Error_code.duplicate_record_field } + : local_error) + +let missing_fields_in_record ~labels ~ty ~context ~loc = + (let message = + let labels_str = String.concat ", " labels in + match context with + | `Pattern -> + ("Record fields " ^ labels_str + ^ " are unmatched, use `..` to ignore them." + : Stdlib.String.t) + [@merlin.hide] + | `Creation -> + Stdlib.String.concat "" + [ "Record fields "; labels_str; " are undefined for type "; ty ] + [@merlin.hide] + in + { message; loc; error_code = Error_code.missing_fields_in_record } + : local_error) + +let superfluous_field ~label ~ty ~loc = + (let message = + Stdlib.String.concat "" + [ "The fields "; label; " is not defined in the record type "; ty; "." ] + in + { message; loc; error_code = Error_code.superfluous_field } + : local_error) + +let cannot_depend_private ~entity ~loc = + (let message = + ("A public definition cannot depend on private " ^ entity + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.cannot_depend_private } + : local_error) + +let alias_with_priv_target_in_pub_sig ~alias ~priv_type ~loc = + (let message = + Stdlib.String.concat "" + [ + "The alias "; + alias; + " cannot be used in public signature, becasu it mentions private type "; + priv_type; + ] + in + { message; loc; error_code = Error_code.cannot_depend_private } + : local_error) + +let pkg_not_found ~pkg = + (let message = + ("Package " ^ pkg ^ " not found when loading packages." : Stdlib.String.t) + in + { message; loc = Loc.no_location; error_code = Error_code.pkg_not_found } + : Diagnostics.report) + +let pkg_wrong_format ~pkg = + (let message = + ("The package file of " ^ pkg ^ " is in wrong format" : Stdlib.String.t) + in + { message; loc = Loc.no_location; error_code = Error_code.pkg_wrong_format } + : Diagnostics.report) + +let pkg_magic_mismatch ~pkg = + (let message = + ("Magic number mismatch for the package file of " ^ pkg : Stdlib.String.t) + in + { + message; + loc = Loc.no_location; + error_code = Error_code.pkg_magic_mismatch; + } + : Diagnostics.report) + +let cycle_definitions ~cycle ~locs = + (let rec make_string (idents : Ident.t list) head = + match idents with + | [] -> "" + | i :: [] -> Ident.base_name i ^ " -> " ^ Ident.base_name head + | i :: rest -> Ident.base_name i ^ " -> " ^ make_string rest head + in + let make_report loc = + let message = + ("Definition cycle detected : " ^ make_string cycle (List.hd cycle) + : Stdlib.String.t) + in + ({ message; loc; error_code = Error_code.cycle_definitions } + : Diagnostics.report) + in + Lst.map locs make_report + : Diagnostics.report list) let redeclare ~kind ~name ~first_loc ~second_loc - ~(extra_message : string option) : Diagnostics.report = - let message = - Stdlib.String.concat "" - [ - "The "; - kind; - " "; - name; - " is declared twice: it was previously defined at "; - Loc.to_string first_loc; - "."; - ] - in - let message = - match extra_message with - | None -> message - | Some extra_message -> message ^ "\n " ^ extra_message - in - { message; loc = second_loc; error_code = Error_code.redeclare } + ~(extra_message : string option) = + (let message = + Stdlib.String.concat "" + [ + "The "; + kind; + " "; + name; + " is declared twice: it was previously defined at "; + Loc.to_string first_loc; + "."; + ] + in + let message = + match extra_message with + | None -> message + | Some extra_message -> message ^ "\n " ^ extra_message + in + { message; loc = second_loc; error_code = Error_code.redeclare } + : Diagnostics.report) let value_redeclare ~name ~first_loc ~second_loc ~extra_message = redeclare ~kind:"toplevel identifier" ~name ~first_loc ~second_loc @@ -812,6 +872,20 @@ let value_redeclare ~name ~first_loc ~second_loc ~extra_message = let type_redeclare ~name ~first_loc ~second_loc ~extra_message = redeclare ~kind:"type" ~name ~first_loc ~second_loc ~extra_message +let local_type_redeclare ~name ~first_loc ~second_loc = + (let message = + Stdlib.String.concat "" + [ + "The local type "; + name; + " is declared twice: it was previously defined at "; + Loc.to_string first_loc; + "."; + ] + in + { message; loc = second_loc; error_code = Error_code.redeclare } + : local_error) + let trait_redeclare ~name ~first_loc ~second_loc = redeclare ~kind:"trait" ~name ~first_loc ~second_loc ~extra_message:None @@ -819,987 +893,1137 @@ let direct_use_redeclare ~name ~first_loc ~second_loc = redeclare ~kind:"import item" ~name ~first_loc ~second_loc ~extra_message:None let type_trait_duplicate ~name ~first_kind ~first_loc ~second_kind ~second_loc - ~extra_message : Diagnostics.report = - let message = - Stdlib.String.concat "" - [ - "The "; - second_kind; - " "; - name; - " duplicates with "; - first_kind; - " "; - name; - " previously defined at "; - Loc.to_string first_loc; - "."; - ] - in - let message = - match extra_message with - | None -> message - | Some extra_message -> message ^ "\n " ^ extra_message - in - { message; loc = second_loc; error_code = Error_code.type_trait_duplicate } - -let invalid_self_type loc : report = - let message = "Invalid type for \"self\": must be a type constructor" in - { message; loc; error_code = Error_code.invalid_self_type } - -let cannot_determine_self_type loc : report = - let message = - ("Cannot determine self type of extension method. [Self] does not occur in \ - the signature of the method" - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.cannot_determine_self_type } - -let field_duplicate ~name ~loc : report = - let message = ("field " ^ name ^ " is already declared." : Stdlib.String.t) in - { message; loc; error_code = Error_code.field_duplicate } - -let method_duplicate ~method_name ~type_name ~first_loc ~second_loc : report = - let message = - Stdlib.String.concat "" - [ - "The method "; - method_name; - " for type "; - type_path_name type_name; - " has been defined at "; - Loc.to_string first_loc; - "."; - ] - in - { message; loc = second_loc; error_code = Error_code.method_duplicate } - -let constructor_duplicate ~name ~loc : report = - let message = - ("The constructor " ^ name ^ " is duplicate." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.constructor_duplicate } - -let method_func_duplicate ~name ~first_loc ~second_loc ~extra_message : report = - let message = - Stdlib.String.concat "" - [ - "The method "; - name; - " conflicts with the toplevel function defined at "; - Loc.to_string first_loc; - "."; - ] - in - let message = - match extra_message with - | None -> message - | Some extra_message -> message ^ "\n " ^ extra_message - in - { message; loc = second_loc; error_code = Error_code.method_func_duplicate } - -let method_on_foreign_type ~method_name ~type_name ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Cannot define method "; - method_name; - " for foreign type "; - type_path_name type_name; - ] - in - { message; loc; error_code = Error_code.method_on_foreign_type } - -let ext_method_type_mismatch ~trait ~method_name ~expected ~actual ~loc : report - = - let trait = - Type_path.short_name ~cur_pkg_name:(Some !Basic_config.current_package) - trait - in - let message = - Stdlib.String.concat "" - [ - "Method "; - method_name; - " of trait "; - trait; - " is expected to have type "; - expected; - ", it cannot be implemened with type "; - actual; - ] - in - { message; loc; error_code = Error_code.ext_method_type_mismatch } - -let ext_method_foreign_trait_foreign_type ~trait ~type_name ~method_name ~loc : - report = - let trait = type_path_name trait in - let type_name = type_path_name type_name in - let message = - Stdlib.String.concat "" - [ - "Cannot define method "; - method_name; - " of foreign trait "; - trait; - " for foreign type "; - type_name; - ] - in - { - message; - loc; - error_code = Error_code.ext_method_foreign_trait_foreign_type; - } - -let priv_ext_shadows_pub_method ~method_name ~trait ~type_name ~prev_loc ~loc : - Diagnostics.report = - let message = - Stdlib.String.concat "" - [ - "This `impl` shadows method "; - method_name; - " of "; - type_path_name type_name; - " previously defined at "; - Loc.to_string prev_loc; - ". This will result in different implementations for "; - type_path_name trait; - " inside and outside current package."; - ] - in - { message; loc; error_code = Error_code.priv_ext_shadows_pub_method } - -let trait_not_implemented ~trait ~type_name ~failure_reasons ~loc : - Diagnostics.report = - let reasons = String.concat "\n " failure_reasons in - let message = - Stdlib.String.concat "" - [ - "Type "; - type_path_name type_name; - " does not implement trait "; - type_path_name trait; - ", although an `impl` is defined. hint:\n "; - reasons; - "."; - ] - in - { message; loc; error_code = Error_code.trait_not_implemented } - -let bad_operator_arity ~method_name ~expected ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - "overloaded operator \""; - method_name; - "\" should accept "; - Int.to_string expected; - " arguments, but it accepts "; - Int.to_string actual; - " arguments"; - ] - in - { message; loc; error_code = Error_code.bad_operator_arity } - -let bad_operator_type ~method_name ~first ~second ~loc : report = - let message = - Stdlib.String.concat "" - [ - "overloaded operator \""; - method_name; - "\" has inconsistent parameter type: first parameter has type "; - first; - " while second parameter has type "; - second; - ] - in - { message; loc; error_code = Error_code.bad_operator_type } - -let missing_main ~loc : Diagnostics.report = - { - message = "Missing main function in the main package."; - loc; - error_code = Error_code.missing_main; - } - -let multiple_main ~first_loc ~second_loc : Diagnostics.report = - let message = - ("Main function is already defined at " ^ Loc.to_string first_loc ^ "." - : Stdlib.String.t) - in - { message; loc = second_loc; error_code = Error_code.multiple_main } - -let unexpected_main loc : Diagnostics.report = - { - loc; - message = "Unexpected main function in the non-main package."; - error_code = Error_code.unexpected_main; - } - -let unknown_intrinsic ~name ~loc : Diagnostics.report = - let message = ("Unknown intrinsic " ^ name ^ "." : Stdlib.String.t) in - { message; loc; error_code = Error_code.unknown_intrinsic } - -let multiple_intrinsic loc : Diagnostics.report = - let message = "Multiple intrinsic is not unsupported." in - { message; loc; error_code = Error_code.multiple_intrinsic } - -let default_method_duplicate ~trait ~method_name ~first_loc ~second_loc : report - = - let message = - Stdlib.String.concat "" - [ - "Method "; - method_name; - " of trait "; - type_path_name trait; - " already has a default implementation at "; - Loc.to_string first_loc; - ] - in - { - message; - loc = second_loc; - error_code = Error_code.default_method_duplicate; - } - -let default_method_on_foreign ~trait ~loc : report = - let message = - ("Cannot provide default implementation for foreign trait " - ^ type_path_name trait - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.default_method_on_foreign } - -let let_missing_annot ~name ~loc ~reason : report = - let message = - match reason with - | `Cannot_infer -> - ("Cannot infer the type of variable " ^ name - ^ ", please add more type annotation." - : Stdlib.String.t) - | `Pub_not_literal -> - ("Public definition " ^ name ^ " must be annotated with its type." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.let_missing_annot } - -let missing_param_annot ~name ~loc : report = - let message = - ("Missing type annotation for the parameter " ^ name ^ "." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.missing_param_annot } - -let missing_return_annot loc : report = - let message = - ("Missing type annotation for the return value." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.missing_return_annot } - -let derive_unsupported_trait ~tycon ~trait ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Don't know how to derive trait "; - Longident.to_string trait; - " for type "; - type_path_name tycon; - ] - in - { message; loc; error_code = Error_code.derive_unsupported_trait } - -let cannot_derive ~tycon ~trait ~reason ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Cannot derive trait "; - Longident.to_string trait; - " for type "; - tycon; - ": "; - reason; - ] - in - { message; loc; error_code = Error_code.cannot_derive } - -let derive_method_exists ~trait ~type_name ~method_name ~prev_loc ~loc : report - = - let message = - Stdlib.String.concat "" - [ - "Cannot derive trait "; - type_path_name trait; - " for "; - type_path_name type_name; - ": method "; - method_name; - " is already defined at "; - Loc.to_string prev_loc; - ] - in - { message; loc; error_code = Error_code.derive_method_exists } - -let arity_mismatch ~label ~expected ~actual ~has_label ~loc : report = - let arg_desc = if has_label then "positional arguments" else "arguments" in - let message = - Stdlib.String.concat "" - [ - label; - " requires "; - Int.to_string expected; - " "; - arg_desc; - ", but is given "; - Int.to_string actual; - " "; - arg_desc; - "."; - ] - in - { message; loc; error_code = Error_code.arity_mismatch } + ~extra_message = + (let message = + Stdlib.String.concat "" + [ + "The "; + second_kind; + " "; + name; + " duplicates with "; + first_kind; + " "; + name; + " previously defined at "; + Loc.to_string first_loc; + "."; + ] + in + let message = + match extra_message with + | None -> message + | Some extra_message -> message ^ "\n " ^ extra_message + in + { message; loc = second_loc; error_code = Error_code.type_trait_duplicate } + : Diagnostics.report) + +let invalid_self_type loc = + (let message = "Invalid type for \"self\": must be a type constructor" in + { message; loc; error_code = Error_code.invalid_self_type } + : local_error) + +let cannot_determine_self_type loc = + (let message = + ("Cannot determine self type of extension method. [Self] does not occur \ + in the signature of the method" + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.cannot_determine_self_type } + : local_error) + +let field_duplicate ~name ~loc = + (let message = + ("field " ^ name ^ " is already declared." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.field_duplicate } + : local_error) + +let method_duplicate ~method_name ~type_name ~first_loc ~second_loc = + (let message = + Stdlib.String.concat "" + [ + "The method "; + method_name; + " for type "; + type_path_name type_name; + " has been defined at "; + Loc.to_string first_loc; + "."; + ] + in + { message; loc = second_loc; error_code = Error_code.method_duplicate } + : local_error) + +let constructor_duplicate ~name ~loc = + (let message = + ("The constructor " ^ name ^ " is duplicate." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.constructor_duplicate } + : local_error) + +let method_on_foreign_type ~method_name ~type_name ~loc = + (let message = + Stdlib.String.concat "" + [ + "Cannot define method "; + method_name; + " for foreign type "; + type_path_name type_name; + ] + in + { message; loc; error_code = Error_code.method_on_foreign_type } + : local_error) + +let ext_method_type_mismatch ~trait ~method_name ~expected ~actual ~loc = + (let trait = + Type_path.short_name ~cur_pkg_name:(Some !Basic_config.current_package) + trait + in + let message = + Stdlib.String.concat "" + [ + "Method "; + method_name; + " of trait "; + trait; + " is expected to have type "; + expected; + ", it cannot be implemened with type "; + actual; + ] + in + { message; loc; error_code = Error_code.ext_method_type_mismatch } + : local_error) + +let ext_method_foreign_trait_foreign_type ~trait ~type_name ~method_name ~loc = + (let trait = type_path_name trait in + let type_name = type_path_name type_name in + let message = + Stdlib.String.concat "" + [ + "Cannot define method "; + method_name; + " of foreign trait "; + trait; + " for foreign type "; + type_name; + ] + in + { + message; + loc; + error_code = Error_code.ext_method_foreign_trait_foreign_type; + } + : local_error) + +let priv_ext_shadows_pub_method ~method_name ~trait ~type_name ~prev_loc ~loc = + (let message = + Stdlib.String.concat "" + [ + "This `impl` shadows method "; + method_name; + " of "; + type_path_name type_name; + " previously defined at "; + Loc.to_string prev_loc; + ". This will result in different implementations for "; + type_path_name trait; + " inside and outside current package."; + ] + in + { message; loc; error_code = Error_code.priv_ext_shadows_pub_method } + : Diagnostics.report) + +let trait_not_implemented ~trait ~type_name ~failure_reasons ~loc = + (let reasons = String.concat "\n " failure_reasons in + let message = + Stdlib.String.concat "" + [ + "Type "; + type_path_name type_name; + " does not implement trait "; + type_path_name trait; + ", although an `impl` is defined. hint:\n "; + reasons; + "."; + ] + in + { message; loc; error_code = Error_code.trait_not_implemented } + : Diagnostics.report) + +let bad_operator_arity ~method_name ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + "overloaded operator \""; + method_name; + "\" should accept "; + Int.to_string expected; + " arguments, but it accepts "; + Int.to_string actual; + " arguments"; + ] + in + { message; loc; error_code = Error_code.bad_operator_arity } + : local_error) + +let bad_operator_type ~method_name ~first ~second ~loc = + (let message = + Stdlib.String.concat "" + [ + "overloaded operator \""; + method_name; + "\" has inconsistent parameter type: first parameter has type "; + first; + " while second parameter has type "; + second; + ] + in + { message; loc; error_code = Error_code.bad_operator_type } + : local_error) + +let missing_main ~loc = + ({ + message = "Missing main function in the main package."; + loc; + error_code = Error_code.missing_main; + } + : Diagnostics.report) + +let multiple_main ~first_loc ~second_loc = + (let message = + ("Main function is already defined at " ^ Loc.to_string first_loc ^ "." + : Stdlib.String.t) + in + { message; loc = second_loc; error_code = Error_code.multiple_main } + : Diagnostics.report) + +let unexpected_main loc = + ({ + loc; + message = "Unexpected main function in the non-main package."; + error_code = Error_code.unexpected_main; + } + : Diagnostics.report) + +let unknown_intrinsic ~name ~loc = + (let message = ("Unknown intrinsic " ^ name ^ "." : Stdlib.String.t) in + { message; loc; error_code = Error_code.unknown_intrinsic } + : Diagnostics.report) + +let multiple_intrinsic loc = + (let message = "Multiple intrinsic is not unsupported." in + { message; loc; error_code = Error_code.multiple_intrinsic } + : Diagnostics.report) + +let default_method_duplicate ~trait ~method_name ~first_loc ~second_loc = + (let message = + Stdlib.String.concat "" + [ + "Method "; + method_name; + " of trait "; + type_path_name trait; + " already has a default implementation at "; + Loc.to_string first_loc; + ] + in + { + message; + loc = second_loc; + error_code = Error_code.default_method_duplicate; + } + : local_error) + +let default_method_on_foreign ~trait ~loc = + (let message = + ("Cannot provide default implementation for foreign trait " + ^ type_path_name trait + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.default_method_on_foreign } + : local_error) + +let let_missing_annot ~name ~loc ~reason = + (let message = + match reason with + | `Cannot_infer -> + ("Cannot infer the type of variable " ^ name + ^ ", please add more type annotation." + : Stdlib.String.t) + [@merlin.hide] + | `Pub_not_literal -> + ("Public definition " ^ name ^ " must be annotated with its type." + : Stdlib.String.t) + [@merlin.hide] + in + { message; loc; error_code = Error_code.let_missing_annot } + : local_error) + +let missing_param_annot ~name ~loc = + (let message = + ("Missing type annotation for the parameter " ^ name ^ "." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.missing_param_annot } + : local_error) + +let missing_return_annot loc = + (let message = + ("Missing type annotation for the return value." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.missing_return_annot } + : local_error) + +let derive_unsupported_trait ~tycon ~trait ~loc = + (let message = + Stdlib.String.concat "" + [ + "Don't know how to derive trait "; + Longident.to_string trait; + " for type "; + type_path_name tycon; + ] + in + { message; loc; error_code = Error_code.derive_unsupported_trait } + : local_error) + +let cannot_derive ~tycon ~trait ~reason ~loc = + (let message = + Stdlib.String.concat "" + [ + "Cannot derive trait "; + Longident.to_string trait; + " for type "; + tycon; + ": "; + reason; + ] + in + { message; loc; error_code = Error_code.cannot_derive } + : local_error) + +let derive_method_exists ~trait ~type_name ~method_name ~prev_loc ~loc = + (let message = + Stdlib.String.concat "" + [ + "Cannot derive trait "; + type_path_name trait; + " for "; + type_path_name type_name; + ": method "; + method_name; + " is already defined at "; + Loc.to_string prev_loc; + ] + in + { message; loc; error_code = Error_code.derive_method_exists } + : local_error) + +let arity_mismatch ~label ~expected ~actual ~has_label ~loc = + (let arg_desc = if has_label then "positional arguments" else "arguments" in + let message = + Stdlib.String.concat "" + [ + label; + " requires "; + Int.to_string expected; + " "; + arg_desc; + ", but is given "; + Int.to_string actual; + " "; + arg_desc; + "."; + ] + in + { message; loc; error_code = Error_code.arity_mismatch } + : local_error) let constr_arity_mismatch ~name ~expected ~actual ~has_label ~loc = arity_mismatch ~label:("The constructor " ^ name : Stdlib.String.t) ~expected ~actual ~has_label ~loc +let constant_constr_cannot_have_args ~name ~loc = + (let message = + (name ^ " is a constant constructor, it cannot be applied to arguments." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.arity_mismatch } + : local_error) + let fn_arity_mismatch ~func_ty ~expected ~actual ~has_label ~loc = arity_mismatch ~label:("This function has type " ^ func_ty ^ ", which" : Stdlib.String.t) ~expected ~actual ~has_label ~loc -let non_linear_pattern ~name ~loc : report = - let message = - ("The identifier " ^ name ^ " is bound more than once in the same pattern." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.non_linear_pattern } - -let inconsistent_or_pattern ~name ~loc : report = - let message = - ("Variable " ^ name ^ " is not bound in all patterns." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.inconsistent_or_pattern } - -let no_op_as_view ~ty ~loc : report = - let message = - ("The type " ^ ty ^ " does not implement `op_as_view` method." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.no_op_as_view } - -let duplicated_fn_label ~label ~second_loc : report = - let message = - ("The label " ^ label ^ "~ is supplied twice." : Stdlib.String.t) - in - { message; loc = second_loc; error_code = Error_code.duplicated_fn_label } - -let superfluous_arg_label ~label ~(kind : string) ~loc : report = - let message = - Stdlib.String.concat "" - [ "This "; kind; " has no parameter with label "; label; "~." ] - in - { message; loc; error_code = Error_code.superfluous_fn_label } - -let missing_fn_label ~labels ~loc : report = - let labels_str = String.concat ", " (Lst.map labels (fun l -> l ^ "~")) in - let message = - ("The labels " ^ labels_str - ^ " are required by this function, but not supplied." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.missing_fn_label } - -let not_mutable ~id ~loc : report = - let message = - ("The variable " ^ Longident.to_string id ^ " is not mutable." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.not_mutable } - -let immutable_field ~label ~loc : report = - let message = - ("The record field " ^ label ^ " is immutable." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.immutable_field } - -let no_tuple_index ~required ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - Int.to_string actual; - "-tuple has no field `"; - Int.to_string required; - "`"; - ] - in - { message; loc; error_code = Error_code.no_tuple_index } - -let tuple_not_mutable loc : report = - let message = "tuples are not mutable" in - { message; loc; error_code = Error_code.tuple_not_mutable } - -let no_such_field ~ty ~field ~may_be_method ~loc : report = - let message = - if may_be_method then - Stdlib.String.concat "" - [ - "The type "; - ty; - " has no field "; - field; - ".\n (hint: to pass method as function, write `fn (...) { x."; - field; - "(...) }` instead)"; - ] - else - Stdlib.String.concat "" [ "The type "; ty; " has no field "; field; "." ] - in - { message; loc; error_code = Error_code.no_such_field } - -let record_type_missing loc : report = - let message = "Missing annotation for this empty record." in - { message; loc; error_code = Error_code.record_type_missing } - -let not_a_record_type ~name ~loc : report = - let message = - ("The type " ^ name ^ " is not a record type" : Stdlib.String.t) - in - { message; loc; error_code = Error_code.not_a_record_type } - -let mutate_readonly_field ~label ~loc : report = - let message = - ("Cannot modify a read-only field: " ^ label : Stdlib.String.t) - in - { message; loc; error_code = Error_code.mutate_readonly_field } - -let overflow ~value ~loc : report = - let message = - ("Integer literal " ^ value ^ " is out of range." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.overflow } - -let invalid_newtype_index ~ty ~loc : report = - let message = - ("Field of newtype " ^ ty ^ " can only be accessed via index 0." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_newtype_index } - -let not_a_trait ~name ~loc : report = - let message = ("The type " ^ name ^ " is not a trait" : Stdlib.String.t) in - { message; loc; error_code = Error_code.not_a_trait } - -let unsupported_pipe_expr loc : report = - let message = "Unsupported expression after the pipe operator." in - { message; loc; error_code = Error_code.unsupported_pipe_expr } - -let outside_loop ~msg ~loc : report = - { - loc; - message = ("'" ^ msg ^ "' outside of a loop" : Stdlib.String.t); - error_code = Error_code.outside_loop; - } - -let loop_pat_arity_mismatch ~expected ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - "This loop has "; - Int.to_string expected; - " arguments, but "; - Int.to_string actual; - " patterns are supplied"; - ] - in - { message; loc; error_code = Error_code.loop_pat_arity_mismatch } - -let continue_arity_mismatch ~expected ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Current loop expects "; - Int.to_string expected; - " arguments, but `continue` is supplied with "; - Int.to_string actual; - " arguments"; - ] - in - { message; loc; error_code = Error_code.continue_arity_mismatch } - -let break_type_mismatch ~expected ~actual ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Current loop has result type "; - expected; - ", but `break` is supplied with "; - actual; - "."; - ] - in - { message; loc; error_code = Error_code.break_type_mismatch } - -let unknown_binder_in_for_steps ~name ~loc : report = - let message = - ("Unknown binder " ^ name - ^ " in the for-loop steps. Binders in the steps must be declared in the \ - initialization block of the for-loop." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unknown_binder_in_for_steps } - -let duplicate_for_binder ~name ~loc : report = - let message = - (name ^ " is declared multiple times in this for-loop" : Stdlib.String.t) - in - { message; loc; error_code = Error_code.duplicate_for_binder } - -let need_else_branch ~loop_kind ~ty ~loc : report = - let loop_kind_string = - match loop_kind with `For -> "for" | `While -> "while" - in - let message = - Stdlib.String.concat "" - [ - "The "; - loop_kind_string; - " loop is expected to yield a value of type "; - ty; - ", please add an `else` branch."; - ] - in - { message; loc; error_code = Error_code.need_else_branch } - -let invalid_return loc : report = - { - loc; - message = ("Return must be inside a function." : Stdlib.String.t); - error_code = Error_code.invalid_return; - } - -let invalid_break ~loop_kind ~loc : report = - let loop_kind_string = - match loop_kind with `For -> "for" | `While -> "while" - in - let message = - ("The " ^ loop_kind_string - ^ " loop is not expected to yield a value, please remove the argument of \ - the `break` or add an `else` branch." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_break } - -let ambiguous_break loc : report = - let message = ("The usage break statement is invalid." : Stdlib.String.t) in - { message; loc; error_code = Error_code.ambiguous_break } - -let ambiguous_continue loc : report = - let message = - ("The usage continue statement is invalid." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.ambiguous_continue } - -let constr_no_such_field ~ty ~constr ~field ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Constructor "; - constr; - " of type "; - type_path_name ty; - " has no field "; - field; - "."; - ] - in - { message; loc; error_code = Error_code.constr_no_such_field } - -let no_local_labelled_function loc : report = - let message = "Only toplevel functions can have labelled arguments." in - { message; loc; error_code = Error_code.no_local_labelled_function } - -let unsupported_autofill ~ty ~loc : report = - let message = - ("Cannot auto-fill parameter of type " ^ ty : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unsupported_autofill } - -let found_hole loc : report = - let message = "Found hole _ " in - { message; loc; error_code = Error_code.found_hole } - -let no_first_class_labelled_function loc : report = - let message = - "Function with labelled arguments can only be applied directly." - in - { message; loc; error_code = Error_code.no_first_class_labelled_function } - -let cannot_use_map_pattern_no_method ~ty ~loc : report = - let message = - ("Please implement method `op_get` for type " ^ ty - ^ " to match it with map pattern." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.cannot_use_map_pattern } - -let cannot_use_map_pattern_method_type_mismatch ~ty ~actual_ty ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Cannot match type "; - ty; - " with map pattern: its method `op_get` has incorrect type:\n\ - \ wanted: (Self, K) -> Option[V]\n\ - \ has : "; - actual_ty; - "."; - ] - in - { message; loc; error_code = Error_code.cannot_use_map_pattern } - -let nontoplevel_func_cannot_have_labelled_arg ~loc : report = - let message = - ("This function is not a toplevel function, so it cannot have labelled \ - arguments" - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unknown_func_labelled_arg } - -let error_type_mismatch ~expected_ty ~actual_ty ~loc : report = - let message = - Stdlib.String.concat "" - [ - "The error type is mismatched:\n wanted: "; - expected_ty; - "\n has : "; - actual_ty; - "."; - ] - in - { message; loc; error_code = Error_code.cannot_use_map_pattern } - -let unhandled_error ~err_ty ~loc : report = - let message = - ("The application might raise errors of type " ^ err_ty - ^ ", but it's not handled. Try adding a infix operator `!` or `?` to the \ - application, so that it looks like `...!(...)` or `...?(...)`." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.unhandled_error } +let non_linear_pattern ~name ~loc = + (let message = + ("The identifier " ^ name ^ " is bound more than once in the same pattern." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.non_linear_pattern } + : local_error) + +let inconsistent_or_pattern ~name ~loc = + (let message = + ("Variable " ^ name ^ " is not bound in all patterns." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.inconsistent_or_pattern } + : local_error) + +let no_op_as_view ~ty ~loc = + (let message = + ("The type " ^ ty ^ " does not implement `op_as_view` method." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.no_op_as_view } + : local_error) + +let duplicated_fn_label ~label ~second_loc = + (let message = + ("The label " ^ label ^ "~ is supplied twice." : Stdlib.String.t) + in + { message; loc = second_loc; error_code = Error_code.duplicated_fn_label } + : local_error) + +let superfluous_arg_label ~label ~(kind : string) ~loc = + (let message = + Stdlib.String.concat "" + [ "This "; kind; " has no parameter with label "; label; "~." ] + in + { message; loc; error_code = Error_code.superfluous_fn_label } + : local_error) + +let missing_fn_label ~labels ~loc = + (let labels_str = String.concat ", " (Lst.map labels (fun l -> l ^ "~")) in + let message = + ("The labels " ^ labels_str + ^ " are required by this function, but not supplied." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.missing_fn_label } + : local_error) + +let not_mutable ~id ~loc = + (let message = + ("The variable " ^ Longident.to_string id ^ " is not mutable." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.not_mutable } + : local_error) + +let immutable_field ~label ~loc = + (let message = + ("The record field " ^ label ^ " is immutable." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.immutable_field } + : local_error) + +let no_tuple_index ~required ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + Int.to_string actual; + "-tuple has no field `"; + Int.to_string required; + "`"; + ] + in + { message; loc; error_code = Error_code.no_tuple_index } + : local_error) + +let tuple_not_mutable loc = + (let message = "tuples are not mutable" in + { message; loc; error_code = Error_code.tuple_not_mutable } + : local_error) + +let no_such_field ~ty ~field ~may_be_method ~loc = + (let message = + if may_be_method then + Stdlib.String.concat "" + [ + "The type "; + ty; + " has no field "; + field; + ".\n (hint: to pass method as function, write `fn (...) { x."; + field; + "(...) }` instead)"; + ] + else + Stdlib.String.concat "" [ "The type "; ty; " has no field "; field; "." ] + in + { message; loc; error_code = Error_code.no_such_field } + : local_error) + +let record_type_missing loc = + (let message = "Missing annotation for this empty record." in + { message; loc; error_code = Error_code.record_type_missing } + : local_error) + +let not_a_record_type ~name ~loc = + (let message = + ("The type " ^ name ^ " is not a record type" : Stdlib.String.t) + in + { message; loc; error_code = Error_code.not_a_record_type } + : local_error) + +let mutate_readonly_field ~label ~loc = + (let message = + ("Cannot modify a read-only field: " ^ label : Stdlib.String.t) + in + { message; loc; error_code = Error_code.mutate_readonly_field } + : local_error) + +let overflow ~value ~loc = + (let message = + ("Integer literal " ^ value ^ " is out of range." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.overflow } + : local_error) + +let overloaded_string_interpolation_for_bytes ~loc = + (let message = + ("String literals with interpolation cannot be overloaded for `Bytes` \ + type." + : Stdlib.String.t) + in + { + message; + loc; + error_code = Error_code.overloaded_string_interpolation_for_bytes; + } + : local_error) + +let not_a_type ~name ~loc = + (let message = ("`" ^ name ^ "` is a trait, not a type" : Stdlib.String.t) in + { message; loc; error_code = Error_code.not_a_type } + : local_error) + +let not_a_trait ~name ~loc = + (let message = ("The type " ^ name ^ " is not a trait" : Stdlib.String.t) in + { message; loc; error_code = Error_code.not_a_trait } + : local_error) + +let unsupported_pipe_expr loc = + (let message = "Unsupported expression after the pipe operator." in + { message; loc; error_code = Error_code.unsupported_pipe_expr } + : local_error) + +let outside_loop ~msg ~loc = + ({ + loc; + message = ("'" ^ msg ^ "' outside of a loop" : Stdlib.String.t); + error_code = Error_code.outside_loop; + } + : local_error) + +let loop_pat_arity_mismatch ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + "This loop has "; + Int.to_string expected; + " arguments, but "; + Int.to_string actual; + " patterns are supplied"; + ] + in + { message; loc; error_code = Error_code.loop_pat_arity_mismatch } + : local_error) + +let continue_arity_mismatch ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + "Current loop expects "; + Int.to_string expected; + " arguments, but `continue` is supplied with "; + Int.to_string actual; + " arguments"; + ] + in + { message; loc; error_code = Error_code.continue_arity_mismatch } + : local_error) + +let break_type_mismatch ~expected ~actual ~loc = + (let message = + Stdlib.String.concat "" + [ + "Current loop has result type "; + expected; + ", but `break` is supplied with "; + actual; + "."; + ] + in + { message; loc; error_code = Error_code.break_type_mismatch } + : local_error) + +let unknown_binder_in_for_steps ~name ~loc = + (let message = + ("Unknown binder " ^ name + ^ " in the for-loop steps. Binders in the steps must be declared in the \ + initialization block of the for-loop." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unknown_binder_in_for_steps } + : local_error) + +let duplicate_for_binder ~name ~loc = + (let message = + (name ^ " is declared multiple times in this for-loop" : Stdlib.String.t) + in + { message; loc; error_code = Error_code.duplicate_for_binder } + : local_error) + +let need_else_branch ~loop_kind ~ty ~loc = + (let loop_kind_string = + match loop_kind with `For -> "for" | `While -> "while" + in + let message = + Stdlib.String.concat "" + [ + "The "; + loop_kind_string; + " loop is expected to yield a value of type "; + ty; + ", please add an `else` branch."; + ] + in + { message; loc; error_code = Error_code.need_else_branch } + : local_error) + +let invalid_return loc = + ({ + loc; + message = ("Return must be inside a function." : Stdlib.String.t); + error_code = Error_code.invalid_return; + } + : local_error) + +let invalid_break ~loop_kind ~loc = + (let loop_kind_string = + match loop_kind with `For -> "for" | `While -> "while" + in + let message = + ("The " ^ loop_kind_string + ^ " loop is not expected to yield a value, please remove the argument of \ + the `break` or add an `else` branch." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.invalid_break } + : local_error) + +let ambiguous_break loc = + (let message = ("The usage break statement is invalid." : Stdlib.String.t) in + { message; loc; error_code = Error_code.ambiguous_break } + : local_error) + +let ambiguous_continue loc = + (let message = + ("The usage continue statement is invalid." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.ambiguous_continue } + : local_error) + +let constr_no_such_field ~ty ~constr ~field ~loc = + (let message = + Stdlib.String.concat "" + [ + "Constructor "; + constr; + " of type "; + type_path_name ty; + " has no field "; + field; + "."; + ] + in + { message; loc; error_code = Error_code.constr_no_such_field } + : local_error) + +let no_local_labelled_function loc = + (let message = "Only toplevel functions can have labelled arguments." in + { message; loc; error_code = Error_code.no_local_labelled_function } + : local_error) + +let unsupported_autofill ~ty ~loc = + (let message = + ("Cannot auto-fill parameter of type " ^ ty : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unsupported_autofill } + : local_error) + +let found_hole loc = + (let message = "Found hole _ " in + { message; loc; error_code = Error_code.found_hole } + : local_error) + +let no_first_class_labelled_function loc = + (let message = + "Function with labelled arguments can only be applied directly." + in + { message; loc; error_code = Error_code.no_first_class_labelled_function } + : local_error) + +let cannot_use_map_pattern_no_method ~ty ~loc = + (let message = + ("Please implement method `op_get` for type " ^ ty + ^ " to match it with map pattern." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.cannot_use_map_pattern } + : local_error) + +let cannot_use_map_pattern_method_type_mismatch ~ty ~actual_ty ~loc = + (let message = + Stdlib.String.concat "" + [ + "Cannot match type "; + ty; + " with map pattern: its method `op_get` has incorrect type:\n\ + \ wanted: (Self, K) -> Option[V]\n\ + \ has : "; + actual_ty; + "."; + ] + in + { message; loc; error_code = Error_code.cannot_use_map_pattern } + : local_error) + +let nontoplevel_func_cannot_have_labelled_arg ~loc = + (let message = + ("This function is not a toplevel function, so it cannot have labelled \ + arguments" + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unknown_func_labelled_arg } + : local_error) + +let error_type_mismatch ~expected_ty ~actual_ty ~loc = + (let message = + Stdlib.String.concat "" + [ + "The error type is mismatched:\n wanted: "; + expected_ty; + "\n has : "; + actual_ty; + "."; + ] + in + { message; loc; error_code = Error_code.cannot_use_map_pattern } + : local_error) + +let unhandled_error ~err_ty ~loc = + (let message = + ("The application might raise errors of type " ^ err_ty + ^ ", but it's not handled. Try adding a infix operator `!` or `?` to the \ + application, so that it looks like `...!(...)` or `...?(...)`." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.unhandled_error } + : local_error) let invalid_apply_attr ~(kind : [ `UnknownType | `NoErrorType | `Constructor ]) - ~loc : report = - let message = - match kind with - | `Constructor -> - ("The attribute `!` or `?` cannot be used on constructors." - : Stdlib.String.t) - | `UnknownType -> - ("The type of function is unknown so the attribute `!` or `?` cannot \ - be used." - : Stdlib.String.t) - | `NoErrorType -> - ("The attribute `!` or `?` cannot be used on application that does not \ - raise errors" - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_apply_attr } - -let invalid_raise ~(kind : [ `Catchall | `Rethrow | `Raise ]) ~loc : report = - let reason = - match kind with - | `Catchall -> "catch! will rethrow unhandled error, and" - | `Rethrow -> - "! operator will rethrow the error raised in the function application, \ - and" - | `Raise -> "raise" - in - { - loc; - message = - (reason - ^ " can only be used inside a function with error types in its \ - signature. Please fix the return type of this function. \n\ - For local functions, you could use `fn func_name!()` to declare the \ - function with an error type, and let the compiler infer the error \ - type.\n\ - For anonymous functions, use `fn!` instead of `fn` to declare the \ - function with an error type." - : Stdlib.String.t); - error_code = Error_code.invalid_raise; - } - -let ambiguous_constructor ~name ~first_ty ~second_ty ~loc : report = - let message = - Stdlib.String.concat "" - [ - "The constructor "; - name; - " is ambiguous: it may come from type "; - first_ty; - " or "; - second_ty; - "."; - ] - in - { message; loc; error_code = Error_code.ambiguous_constructor } - -let double_exclamation_with_cascade loc : report = - let message = ("`?` operator cannot be used with `..`." : Stdlib.String.t) in - { message; loc; error_code = Error_code.double_exclamation_with_cascade } - -let not_error_subtype ty loc : report = - let message = ("Type " ^ ty ^ " is not an error type." : Stdlib.String.t) in - { message; loc; error_code = Error_code.not_error_subtype } - -let invalid_type_alias_target loc : report = - let message = - ("Target of type alias must not be a type parameter." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_type_alias_target } - -let cycle_in_type_alias ~cycle ~loc : report = - let cycle = String.concat " -> " cycle in - let message = - ("Found cycle " ^ cycle ^ " in type alias." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.cycle_in_type_alias } - -let type_alias_cannot_derive loc : report = - let message = "`derive` is not allowed for type alias" in - { message; loc; error_code = Error_code.type_alias_cannot_derive } - -let type_alias_not_a_constructor ~alias_name ~loc : report = - let message = - ("The type alias " ^ alias_name - ^ " is a function type, not a type constructor." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.type_alias_not_a_constructor } - -let invalid_test_parameter loc : Diagnostics.report = - let message = - "Invalid test parameter. Only one parameter with type `@test.T` is allowed." - in - { message; loc; error_code = Error_code.invalid_test_parameter } - -let foreach_loop_variable_count_mismatch ~actual ~expected ~loc : report = - let expected = - match expected with - | None -> "at most 2" - | Some expected -> Int.to_string expected - in - let message = - Stdlib.String.concat "" - [ - "This `for .. in` loop has "; - Int.to_string actual; - " loop variables, but "; - expected; - " is expected."; - ] - in - { message; loc; error_code = Error_code.foreach_loop_variable_count_mismatch } - -let anonymous_missing_error_annotation loc : report = - let message = - ("The return type of this anonymous function is expected include an error \ - type. Please add the error type to the return type annotation or use \ - `fn!` instead." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.anonymous_missing_error_annotation } - -let static_assert_failure ~type_ ~trait ~required_by ~loc : report = - let message = - Stdlib.String.concat "" - [ - "Type "; - type_; - " does not implement trait "; - trait; - ".\n note: this constraint is required by "; - required_by; - ] - in - { message; loc; error_code = Error_code.cannot_resolve_trait } - -let inconsistent_impl ~trait ~type_name ~reason ~loc1 ~loc2 : Diagnostics.report - = - let reason = - match reason with - | `Self_type_mismatch (ty1, ty2) -> - Stdlib.String.concat "" - [ - "implementations have different self type:\n\ - \ self type of first impl : "; - ty1; - "\n self type of second impl: "; - ty2; - ] - | `Type_parameter_bound -> - ("type parameters of implementations have different constraints" - : Stdlib.String.t) - in - let message = - Stdlib.String.concat "" - [ - "Inconsistent `impl` of trait "; - trait; - " for "; - type_name; - " at "; - Loc.to_string loc1; - " and "; - Loc.to_string loc2; - ": "; - reason; - ] - in - { message; loc = loc2; error_code = Error_code.inconsistent_impl } - -let no_default_for_question_optional ~label ~loc : report = - let message = - ("The parameter " ^ label ^ "? already has default value `None`." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.no_default_for_question_optional } - -let invalid_extra_delimiter ~delimiter ~loc : Diagnostics.report = - let message = - ("Expecting a newline or `;` here, but encountered " ^ delimiter ^ "." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_extra_delimiter } - -let not_a_newtype ~actual_ty ~loc : report = - let message = - ("This expression has type " ^ actual_ty ^ ", which is not a newtype." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.not_a_newtype } - -let range_operator_only_in_for loc : report = - let message = - ("Range operators are currently only supported in `for .. in` loops." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.range_operator_only_in_for } - -let range_operator_unsupported_type ~actual_ty ~loc : report = - let message = - ("Range operators only support builtin integer types, they cannot be used \ - on type " ^ actual_ty ^ "." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.range_operator_unsupported_type } - -let non_unit_cannot_be_ignored ~ty ~loc : report = - let message = - ("This expression has type " ^ ty - ^ ", its value cannot be implicitly ignored (hint: use `ignore(...)` or \ - `let _ = ...` to explicitly ignore it)." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.non_unit_cannot_be_ignored } - -let c_stub_invalid_function_name loc : Diagnostics.report = - let message = "Invalid C function name in extern \"C\" declaration" in - { message; loc; error_code = Error_code.c_stub_invalid_function_name } - -let invalid_question_arg_application ~label ~loc : report = - let message = - Stdlib.String.concat "" - [ - "This form of application is invalid for argument "; - label; - "~, because it is not declared with "; - label; - "? : _."; - ] - in - { message; loc; error_code = Error_code.invalid_question_arg_application } - -let direct_use_not_found ~pkg ~id ~loc : Diagnostics.report = - let message = Printf.sprintf "Value %s not found in package %S." id pkg in - { message; loc; error_code = Error_code.unbound_value } - -let direct_use_ambiguous_method ~name ~type_locs ~pkg ~loc : Diagnostics.report - = - let info = - type_locs - |> List.map (fun (s, loc) : Stdlib.String.t -> - Loc.to_string loc ^ " " ^ type_path_name s) - |> String.concat "\n" - in - let message = - Stdlib.String.concat "" - [ - "The method "; - name; - " has been defined for the following types in packae "; - pkg; - ":\n"; - info; - "."; - ] - in - { message; loc; error_code = Error_code.ambiguous_method } - -let constant_not_constant loc : report = - let message = "This 'const' declaration is not constant." in - { message; loc; error_code = Error_code.constant_not_constant } - -let invalid_constant_type ~ty ~loc : report = - let message = - (ty - ^ " is not a valid constant type, only immutable primitive types are \ - allowed." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.invalid_constant_type } - -let constant_constr_duplicate ~name ~const_loc ~constr_loc : Diagnostics.report - = - let message = - Stdlib.String.concat "" - [ - "The constant "; - name; - " duplicates with constructor declared at "; - Loc.to_string constr_loc; - "."; - ] - in - { message; loc = const_loc; error_code = Error_code.redeclare } - -let constant_pat_with_args ~name ~loc : report = - let message = - ("'" ^ name - ^ "' is a constant, not a constructor, it cannot be applied to arguments." - : Stdlib.String.t) - in - { message; loc; error_code = Error_code.constant_pat_with_args } - -let cannot_implement_sealed_trait ~trait ~trait_vis ~loc : report = - let message = - Stdlib.String.concat "" - [ "Cannot implement trait '"; trait; "' because it is "; trait_vis; "." ] - in - { message; loc; error_code = Error_code.cannot_implement_abstract_trait } - -let range_pattern_unsupported_type ~ty ~loc : report = - let message = - ("Type " ^ ty ^ " is not supported by range pattern." : Stdlib.String.t) - in - { message; loc; error_code = Error_code.range_pattern_unsupported_type } - -let range_pattern_invalid_range ~inclusive ~loc : report = - let message = - if inclusive then "Range pattern `a..=b` must satisfy `a <= b`." - else "Range pattern `a.. + ("The attribute `" ^ attr ^ "` cannot be used on constructors." + : Stdlib.String.t) + [@merlin.hide] + | `UnknownType -> + ("The type of function is unknown so the attribute `" ^ attr + ^ "` cannot be used." + : Stdlib.String.t) + [@merlin.hide] + | `NoErrorType -> + ("The attribute `" ^ attr + ^ "` cannot be used on application that does not raise errors" + : Stdlib.String.t) + [@merlin.hide] + in + { message; loc; error_code = Error_code.invalid_apply_attr } + : local_error) + +let invalid_raise ~(kind : [ `Catchall | `Rethrow of string | `Raise ]) ~loc = + (let reason = + match kind with + | `Catchall -> "catch! will rethrow unhandled error, and" + | `Rethrow attr -> + ("`" ^ attr + ^ "` operator will rethrow the error raised in the function \ + application, and" + : Stdlib.String.t) + [@merlin.hide] + | `Raise -> "raise" + in + { + loc; + message = + (reason + ^ " can only be used inside a function with error types in its \ + signature. Please fix the return type of this function. \n\ + For local functions, you could use `fn func_name!()` to declare the \ + function with an error type, and let the compiler infer the error \ + type.\n\ + For anonymous functions, use `fn!` instead of `fn` to declare the \ + function with an error type." + : Stdlib.String.t); + error_code = Error_code.invalid_raise; + } + : local_error) + +let ambiguous_constructor ~name ~first_ty ~second_ty ~loc = + (let message = + Stdlib.String.concat "" + [ + "The constructor "; + name; + " is ambiguous: it may come from type "; + first_ty; + " or "; + second_ty; + "."; + ] + in + { message; loc; error_code = Error_code.ambiguous_constructor } + : local_error) + +let double_exclamation_with_cascade loc = + (let message = ("`?` operator cannot be used with `..`." : Stdlib.String.t) in + { message; loc; error_code = Error_code.double_exclamation_with_cascade } + : local_error) + +let not_error_subtype ty loc = + (let message = ("Type " ^ ty ^ " is not an error type." : Stdlib.String.t) in + { message; loc; error_code = Error_code.not_error_subtype } + : local_error) + +let invalid_type_alias_target loc = + (let message = + ("Target of type alias must not be a type parameter." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.invalid_type_alias_target } + : local_error) + +let cycle_in_type_alias ~cycle ~kind ~loc = + (let cycle = String.concat " -> " cycle in + let type_or_trait = match kind with `Type -> "type" | `Trait -> "trait" in + let message = + Stdlib.String.concat "" + [ "Found cycle "; cycle; " in "; type_or_trait; " alias." ] + in + { message; loc; error_code = Error_code.cycle_in_type_alias } + : local_error) + +let type_alias_cannot_derive loc = + (let message = "`derive` is not allowed for type alias" in + { message; loc; error_code = Error_code.type_alias_cannot_derive } + : local_error) + +let type_alias_not_a_constructor ~alias_name ~loc = + (let message = + ("The type alias " ^ alias_name + ^ " is a function type, not a type constructor." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.type_alias_not_a_constructor } + : local_error) + +let invalid_test_parameter loc = + (let message = + "Invalid test parameter. Only one parameter with type `@test.T` is \ + allowed." + in + { message; loc; error_code = Error_code.invalid_test_parameter } + : Diagnostics.report) + +let foreach_loop_variable_count_mismatch ~actual ~expected ~loc = + (let expected = + match expected with + | None -> "at most 2" + | Some expected -> Int.to_string expected + in + let message = + Stdlib.String.concat "" + [ + "This `for .. in` loop has "; + Int.to_string actual; + " loop variables, but "; + expected; + " is expected."; + ] + in + { + message; + loc; + error_code = Error_code.foreach_loop_variable_count_mismatch; + } + : local_error) + +let anonymous_missing_error_annotation loc = + (let message = + ("The return type of this anonymous function is expected include an error \ + type. Please add the error type to the return type annotation or use \ + `fn!` instead." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.anonymous_missing_error_annotation } + : local_error) + +let inconsistent_impl ~trait ~type_name ~reason ~loc1 ~loc2 = + (let reason = + match reason with + | `Self_type_mismatch (ty1, ty2) -> + Stdlib.String.concat "" + [ + "implementations have different self type:\n\ + \ self type of first impl : "; + ty1; + "\n self type of second impl: "; + ty2; + ] [@merlin.hide] + | `Type_parameter_bound -> + ("type parameters of implementations have different constraints" + : Stdlib.String.t) + [@merlin.hide] + in + let message = + Stdlib.String.concat "" + [ + "Inconsistent `impl` of trait "; + trait; + " for "; + type_name; + " at "; + Loc.to_string loc1; + " and "; + Loc.to_string loc2; + ": "; + reason; + ] + in + { message; loc = loc2; error_code = Error_code.inconsistent_impl } + : Diagnostics.report) + +let no_default_for_question_optional ~label ~loc = + (let message = + ("The parameter " ^ label ^ "? already has default value `None`." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.no_default_for_question_optional } + : local_error) + +let invalid_extra_delimiter ~delimiter ~loc = + (let message = + ("Expecting a newline or `;` here, but encountered " ^ delimiter ^ "." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.invalid_extra_delimiter } + : Diagnostics.report) + +let not_a_newtype ~actual_ty ~loc = + (let message = + ("This expression has type " ^ actual_ty ^ ", which is not a newtype." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.not_a_newtype } + : local_error) + +let range_operator_only_in_for loc = + (let message = + ("Range operators are currently only supported in `for .. in` loops." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.range_operator_only_in_for } + : local_error) + +let range_operator_unsupported_type ~actual_ty ~loc = + (let message = + ("Range operators only support builtin integer types, they cannot be used \ + on type " ^ actual_ty ^ "." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.range_operator_unsupported_type } + : local_error) + +let non_unit_cannot_be_ignored ~ty ~loc = + (let message = + ("This expression has type " ^ ty + ^ ", its value cannot be implicitly ignored (hint: use `ignore(...)` or \ + `let _ = ...` to explicitly ignore it)." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.non_unit_cannot_be_ignored } + : local_error) + +let c_stub_invalid_function_name loc = + (let message = "Invalid C function name in extern \"C\" declaration" in + { message; loc; error_code = Error_code.c_stub_invalid_function_name } + : Diagnostics.report) + +let invalid_question_arg_application ~label ~loc = + (let message = + Stdlib.String.concat "" + [ + "This form of application is invalid for argument "; + label; + "~, because it is not declared with "; + label; + "? : _."; + ] + in + { message; loc; error_code = Error_code.invalid_question_arg_application } + : local_error) + +let direct_use_not_found ~pkg ~id ~loc = + (let message = + Stdlib.String.concat "" + [ "Value "; id; " not found in package `"; pkg; "`." ] + in + { message; loc; error_code = Error_code.unbound_value } + : Diagnostics.report) + +let constant_not_constant ~reason ~loc = + (let message = + match reason with + | `Not_const -> "This 'const' declaration is not constant." + | `Unsupported -> + "This kind of computation is currently not supported in `const` \ + declaration." + | `Arith_error -> + "Arithmetic error detected when evaluating `const` declaration." + in + { message; loc; error_code = Error_code.constant_not_constant } + : local_error) + +let invalid_constant_type ~ty ~loc = + (let message = + (ty + ^ " is not a valid constant type, only immutable primitive types are \ + allowed." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.invalid_constant_type } + : local_error) + +let constant_constr_duplicate ~name ~const_loc ~constr_loc = + (let message = + Stdlib.String.concat "" + [ + "The constant "; + name; + " duplicates with constructor declared at "; + Loc.to_string constr_loc; + "."; + ] + in + { message; loc = const_loc; error_code = Error_code.redeclare } + : Diagnostics.report) + +let constant_pat_with_args ~name ~loc = + (let message = + ("'" ^ name + ^ "' is a constant, not a constructor, it cannot be applied to arguments." + : Stdlib.String.t) + in + { message; loc; error_code = Error_code.constant_pat_with_args } + : local_error) + +let cannot_implement_sealed_trait ~trait ~trait_vis ~loc = + (let message = + Stdlib.String.concat "" + [ "Cannot implement trait '"; trait; "' because it is "; trait_vis; "." ] + in + { message; loc; error_code = Error_code.cannot_implement_abstract_trait } + : local_error) + +let range_pattern_unsupported_type ~ty ~loc = + (let message = + ("Type " ^ ty ^ " is not supported by range pattern." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.range_pattern_unsupported_type } + : local_error) + +let range_pattern_invalid_range ~inclusive ~loc = + (let message = + if inclusive then "Range pattern `a..=b` must satisfy `a <= b`." + else "Range pattern `a.. " cycle in + let message = + ("Found cycle " ^ cycle ^ " in `const` declaration." : Stdlib.String.t) + in + { message; loc; error_code = Error_code.cycle_in_const_decl } + : Diagnostics.report) diff --git a/src/exported_functions.ml b/src/exported_functions.ml index 36e7f80..793a6b5 100644 --- a/src/exported_functions.ml +++ b/src/exported_functions.ml @@ -21,32 +21,35 @@ type t = No_export | Export_all_pubs | Export_selected of string Hash_string.t let parse_exported_functions (str : string) (exported_functions : string Hash_string.t) = - Lst.iter (String.split_on_char ',' str) (fun s -> + Lst.iter (String.split_on_char ',' str) ~f:(fun s -> let parts = Basic_strutil.split_on_first ':' s in match parts with | name, "" -> Hash_string.add exported_functions name name | name, export_name -> Hash_string.add exported_functions name export_name) -let is_exported_ident (exported : t) (id : Ident.t) : bool = - match exported with - | No_export -> false - | Export_all_pubs -> not (Ident.is_foreign id) - | Export_selected id_map -> ( - match id with - | Pdot qual_name -> - Hash_string.mem id_map (Basic_qual_ident.base_name qual_name) - && not (Ident.is_foreign id) - | Plocal_method _ | Pident _ | Pmutable_ident _ -> false) +let is_exported_ident (exported : t) (id : Ident.t) = + (match exported with + | No_export -> false + | Export_all_pubs -> not (Ident.is_foreign id) + | Export_selected id_map -> ( + match id with + | Pdot qual_name -> + Hash_string.mem id_map (Basic_qual_ident.base_name qual_name) + && not (Ident.is_foreign id) + | Plocal_method _ | Pident _ | Pmutable_ident _ -> false) + : bool) -let get_exported_name (exported : t) (id : Ident.t) : string option = - match exported with - | No_export -> None - | Export_all_pubs -> - if not (Ident.is_foreign id) then Some (Ident.as_export_name id) else None - | Export_selected id_map -> ( - match id with - | Pdot qual_name -> - if not (Ident.is_foreign id) then - Hash_string.find_opt id_map (Basic_qual_ident.base_name qual_name) - else None - | Plocal_method _ | Pident _ | Pmutable_ident _ -> None) +let get_exported_name (exported : t) (id : Ident.t) = + (match exported with + | No_export -> None + | Export_all_pubs -> + if not (Ident.is_foreign id) then Some (Ident.as_export_name id) + else None + | Export_selected id_map -> ( + match id with + | Pdot qual_name -> + if not (Ident.is_foreign id) then + Hash_string.find_opt id_map (Basic_qual_ident.base_name qual_name) + else None + | Plocal_method _ | Pident _ | Pmutable_ident _ -> None) + : string option) diff --git a/src/ext_method_env.ml b/src/ext_method_env.ml index e32619a..ef9cd9a 100644 --- a/src/ext_method_env.ml +++ b/src/ext_method_env.ml @@ -50,28 +50,30 @@ include struct let _ = fun (_ : key) -> () let equal_key = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then true - else - Stdlib.( && ) - (Type_path.equal a__001_.trait b__002_.trait) - (Stdlib.( && ) - (Type_path.equal a__001_.self_type b__002_.self_type) - (Stdlib.( = ) (a__001_.method_name : string) b__002_.method_name)) + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then true + else + Stdlib.( && ) + (Type_path.equal a__001_.trait b__002_.trait) + (Stdlib.( && ) + (Type_path.equal a__001_.self_type b__002_.self_type) + (Stdlib.( = ) (a__001_.method_name : string) b__002_.method_name)) : key -> key -> bool) let _ = equal_key let (hash_fold_key : Ppx_base.state -> key -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = - let hsv = hsv in - Type_path.hash_fold_t hsv arg.trait - in - Type_path.hash_fold_t hsv arg.self_type - in - Ppx_base.hash_fold_string hsv arg.method_name + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = hsv in + Type_path.hash_fold_t hsv arg.trait + in + Type_path.hash_fold_t hsv arg.self_type + in + Ppx_base.hash_fold_string hsv arg.method_name let _ = hash_fold_key @@ -90,7 +92,8 @@ include struct trait = trait__004_; self_type = self_type__006_; method_name = method_name__008_; - } -> + } + -> let bnds__003_ = ([] : _ Stdlib.List.t) in let bnds__003_ = let arg__009_ = Moon_sexp_conv.sexp_of_string method_name__008_ in @@ -112,18 +115,19 @@ include struct let _ = sexp_of_key let compare_key = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then 0 - else - match Type_path.compare a__010_.trait b__011_.trait with - | 0 -> ( - match Type_path.compare a__010_.self_type b__011_.self_type with - | 0 -> - Stdlib.compare - (a__010_.method_name : string) - b__011_.method_name - | n -> n) - | n -> n + (fun a__010_ -> + fun b__011_ -> + if Stdlib.( == ) a__010_ b__011_ then 0 + else + match Type_path.compare a__010_.trait b__011_.trait with + | 0 -> ( + match Type_path.compare a__010_.self_type b__011_.self_type with + | 0 -> + Stdlib.compare + (a__010_.method_name : string) + b__011_.method_name + | n -> n) + | n -> n : key -> key -> int) let _ = compare_key @@ -178,8 +182,8 @@ end let empty () = H.create 17 let find_method (env : t) ~(trait : trait) ~(self_type : type_name) - ~(method_name : method_name) : method_info option = - H.find_opt env { trait; self_type; method_name } + ~(method_name : method_name) = + (H.find_opt env { trait; self_type; method_name } : method_info option) let add_method (env : t) ~(trait : Type_path.t) ~(self_type : Type_path.t) ~(method_name : string) (meth : method_info) = diff --git a/src/fn_arity.ml b/src/fn_arity.ml index 13b4625..8df593a 100644 --- a/src/fn_arity.ml +++ b/src/fn_arity.ml @@ -143,34 +143,37 @@ include struct let _ = sexp_of_param_kind let equal_param_kind = - (fun a__039_ b__040_ -> - if Stdlib.( == ) a__039_ b__040_ then true - else - match (a__039_, b__040_) with - | Positional _a__041_, Positional _b__042_ -> - Stdlib.( = ) (_a__041_ : int) _b__042_ - | Positional _, _ -> false - | _, Positional _ -> false - | Labelled _a__043_, Labelled _b__044_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__043_.label : string) _b__044_.label) - (Stdlib.( = ) (_a__043_.is_mut : bool) _b__044_.is_mut) - | Labelled _, _ -> false - | _, Labelled _ -> false - | Optional _a__045_, Optional _b__046_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__045_.label : string) _b__046_.label) - (Ppx_base.equal_list - (fun a__047_ b__048_ -> Stdlib.( = ) (a__047_ : int) b__048_) - _a__045_.depends_on _b__046_.depends_on) - | Optional _, _ -> false - | _, Optional _ -> false - | Autofill _a__049_, Autofill _b__050_ -> - Stdlib.( = ) (_a__049_.label : string) _b__050_.label - | Autofill _, _ -> false - | _, Autofill _ -> false - | Question_optional _a__051_, Question_optional _b__052_ -> - Stdlib.( = ) (_a__051_.label : string) _b__052_.label + (fun a__039_ -> + fun b__040_ -> + if Stdlib.( == ) a__039_ b__040_ then true + else + match (a__039_, b__040_) with + | Positional _a__041_, Positional _b__042_ -> + Stdlib.( = ) (_a__041_ : int) _b__042_ + | Positional _, _ -> false + | _, Positional _ -> false + | Labelled _a__043_, Labelled _b__044_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__043_.label : string) _b__044_.label) + (Stdlib.( = ) (_a__043_.is_mut : bool) _b__044_.is_mut) + | Labelled _, _ -> false + | _, Labelled _ -> false + | Optional _a__045_, Optional _b__046_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__045_.label : string) _b__046_.label) + (Ppx_base.equal_list + (fun a__047_ -> + fun (b__048_ [@merlin.hide]) -> + (Stdlib.( = ) (a__047_ : int) b__048_ [@merlin.hide])) + _a__045_.depends_on _b__046_.depends_on) + | Optional _, _ -> false + | _, Optional _ -> false + | Autofill _a__049_, Autofill _b__050_ -> + Stdlib.( = ) (_a__049_.label : string) _b__050_.label + | Autofill _, _ -> false + | _, Autofill _ -> false + | Question_optional _a__051_, Question_optional _b__052_ -> + Stdlib.( = ) (_a__051_.label : string) _b__052_.label : param_kind -> param_kind -> bool) let _ = equal_param_kind @@ -182,18 +185,21 @@ include struct let _ = fun (_ : t) -> () let equal = - (fun a__053_ b__054_ -> - if Stdlib.( == ) a__053_ b__054_ then true - else - match (a__053_, b__054_) with - | Simple _a__055_, Simple _b__056_ -> - Stdlib.( = ) (_a__055_ : int) _b__056_ - | Simple _, _ -> false - | _, Simple _ -> false - | Complex _a__057_, Complex _b__058_ -> - Ppx_base.equal_list - (fun a__059_ b__060_ -> equal_param_kind a__059_ b__060_) - _a__057_ _b__058_ + (fun a__053_ -> + fun b__054_ -> + if Stdlib.( == ) a__053_ b__054_ then true + else + match (a__053_, b__054_) with + | Simple _a__055_, Simple _b__056_ -> + Stdlib.( = ) (_a__055_ : int) _b__056_ + | Simple _, _ -> false + | _, Simple _ -> false + | Complex _a__057_, Complex _b__058_ -> + Ppx_base.equal_list + (fun a__059_ -> + fun (b__060_ [@merlin.hide]) -> + (equal_param_kind a__059_ b__060_ [@merlin.hide])) + _a__057_ _b__058_ : t -> t -> bool) let _ = equal @@ -225,10 +231,11 @@ let is_simple = function Simple _ -> true | Complex _ -> false let count_positional = function | Simple n -> n | Complex kinds -> - Lst.fold_left kinds 0 (fun count kind -> - match kind with - | Positional _ -> count + 1 - | Labelled _ | Optional _ | Autofill _ | Question_optional _ -> count) + Lst.fold_left kinds 0 (fun count -> + fun kind -> + match kind with + | Positional _ -> count + 1 + | Labelled _ | Optional _ | Autofill _ | Question_optional _ -> count) let analyze_default_expr_deps_visitor = let module H = Basic_hashset_string in @@ -244,127 +251,145 @@ let analyze_default_expr_deps_visitor = let analyze_default_expr_deps (params : string list) (expr : Syntax.expr) = let module H = Basic_hashset_string in let unseen = H.create 17 in - Lst.iter params (H.add unseen); + Lst.iter params ~f:(H.add unseen); analyze_default_expr_deps_visitor#visit_expr unseen expr; - Lst.filter_mapi params (fun name index -> - if H.mem unseen name then None else Some index) - -let from_params ~(base : Loc.t) (params : Syntax.parameter list) : - t Local_diagnostics.partial_info = - let module H = Basic_hash_string in - let seen_labels = H.create 17 in - let positional_index = ref 0 in - let errors = ref [] in - let prev_params = Vec.empty () in - let kinds = - Lst.map params (fun p -> - let label = p.param_binder.binder_name in - let loc = p.param_binder.loc_ in - let check_duplicate () = - match H.find_opt seen_labels label with - | None -> H.add seen_labels label loc - | Some first_loc -> - errors := - Errors.duplicated_label_in_decl ~label - ~first_loc:(Rloc.to_loc ~base first_loc) - ~second_loc:loc - :: !errors - [@@inline] - in - let kind = - match p.param_kind with - | Positional -> - let i = !positional_index in - incr positional_index; - Positional i - | Labelled -> - check_duplicate (); - Labelled { label; is_mut = false; loc_ = Rloc.to_loc ~base loc } - | Optional { default } -> ( - check_duplicate (); - match default with - | Pexpr_hole { kind = Incomplete } -> - Autofill { label; loc_ = Rloc.to_loc ~base loc } - | _ -> - Optional - { - label; - depends_on = - analyze_default_expr_deps (Vec.to_list prev_params) - default; - loc_ = Rloc.to_loc ~base loc; - }) - | Question_optional -> - check_duplicate (); - Question_optional { label; loc_ = Rloc.to_loc ~base loc } - in - Vec.push prev_params p.param_binder.binder_name; - kind) - in - let t = - if H.length seen_labels = 0 then Simple !positional_index else Complex kinds - in - match !errors with [] -> Ok t | errs -> Partial (t, errs) - -let from_constr_params ~(base : Loc.t) (params : Syntax.constr_param list) : - t Local_diagnostics.partial_info = - let module H = Basic_hash_string in - let seen_labels = H.create 17 in - let positional_index = ref 0 in - let errors = ref [] in - let kinds = - Lst.map params (fun p -> - match p.cparam_label with - | None -> - let i = !positional_index in - incr positional_index; - Positional i - | Some { label_name = label; loc_ } -> - (match H.find_opt seen_labels label with - | None -> H.add seen_labels label loc_ - | Some first_loc -> - errors := - Errors.duplicated_label_in_decl ~label - ~first_loc:(Rloc.to_loc ~base first_loc) - ~second_loc:loc_ - :: !errors); - Labelled - { label; is_mut = p.cparam_mut; loc_ = Rloc.to_loc ~base loc_ }) - in - let t = - if H.length seen_labels = 0 then Simple !positional_index else Complex kinds - in - match !errors with [] -> Ok t | errs -> Partial (t, errs) + Lst.filter_mapi params (fun name -> + fun index -> if H.mem unseen name then None else Some index) + +let from_params ~(base : Loc.t) (params : Syntax.parameter list) = + (let module H = Basic_hash_string in + let seen_labels = H.create 17 in + let positional_index = ref 0 in + let errors = ref [] in + let prev_params = Vec.empty () in + let kinds = + Lst.map params (fun p -> + match p with + | Discard_positional _ -> + let i = !positional_index in + incr positional_index; + Positional i + | Positional { binder; _ } + | Labelled { binder; _ } + | Optional { binder; _ } + | Question_optional { binder; _ } -> + let ({ binder_name = label; loc_ = loc } : Syntax.binder) = + binder + in + let check_duplicate () = + match H.find_opt seen_labels label with + | None -> H.add seen_labels label loc + | Some first_loc -> + errors := + Errors.duplicated_label_in_decl ~label + ~first_loc:(Rloc.to_loc ~base first_loc) + ~second_loc:loc + :: !errors + [@@inline] + in + let kind = + match p with + | Positional _ -> + let i = !positional_index in + incr positional_index; + Positional i + | Labelled _ -> + check_duplicate (); + Labelled + { label; is_mut = false; loc_ = Rloc.to_loc ~base loc } + | Optional { default; _ } -> ( + check_duplicate (); + match default with + | Pexpr_hole { kind = Incomplete } -> + Autofill { label; loc_ = Rloc.to_loc ~base loc } + | _ -> + Optional + { + label; + depends_on = + analyze_default_expr_deps (Vec.to_list prev_params) + default; + loc_ = Rloc.to_loc ~base loc; + }) + | Question_optional _ -> + check_duplicate (); + Question_optional { label; loc_ = Rloc.to_loc ~base loc } + | Discard_positional _ -> + failwith + "Unreachable: Discard_positional and Positional are \ + handled above" + in + Vec.push prev_params label; + kind) + in + let t = + if H.length seen_labels = 0 then Simple !positional_index + else Complex kinds + in + match !errors with [] -> Ok t | errs -> Partial (t, errs) + : t Local_diagnostics.partial_info) + +let from_constr_params ~(base : Loc.t) (params : Syntax.constr_param list) = + (let module H = Basic_hash_string in + let seen_labels = H.create 17 in + let positional_index = ref 0 in + let errors = ref [] in + let kinds = + Lst.map params (fun p -> + match p.cparam_label with + | None -> + let i = !positional_index in + incr positional_index; + Positional i + | Some { label_name = label; loc_ } -> + (match H.find_opt seen_labels label with + | None -> H.add seen_labels label loc_ + | Some first_loc -> + errors := + Errors.duplicated_label_in_decl ~label + ~first_loc:(Rloc.to_loc ~base first_loc) + ~second_loc:loc_ + :: !errors); + Labelled + { label; is_mut = p.cparam_mut; loc_ = Rloc.to_loc ~base loc_ }) + in + let t = + if H.length seen_labels = 0 then Simple !positional_index + else Complex kinds + in + match !errors with [] -> Ok t | errs -> Partial (t, errs) + : t Local_diagnostics.partial_info) let from_trait_method_params ~(base : Loc.t) - (params : Syntax.trait_method_param list) : t Local_diagnostics.partial_info - = - let module H = Basic_hash_string in - let seen_labels = H.create 17 in - let positional_index = ref 0 in - let errors = ref [] in - let kinds = - Lst.map params (fun p -> - match p.tmparam_label with - | None -> - let i = !positional_index in - incr positional_index; - Positional i - | Some { label_name = label; loc_ } -> - (match H.find_opt seen_labels label with - | None -> H.add seen_labels label loc_ - | Some first_loc -> - errors := - Errors.duplicated_label_in_decl ~label - ~first_loc:(Rloc.to_loc ~base first_loc) - ~second_loc:loc_ - :: !errors); - Labelled { label; is_mut = false; loc_ = Rloc.to_loc ~base loc_ }) - in - let t = - if H.length seen_labels = 0 then Simple !positional_index else Complex kinds - in - match !errors with [] -> Ok t | errs -> Partial (t, errs) + (params : Syntax.trait_method_param list) = + (let module H = Basic_hash_string in + let seen_labels = H.create 17 in + let positional_index = ref 0 in + let errors = ref [] in + let kinds = + Lst.map params (fun p -> + match p.tmparam_label with + | None -> + let i = !positional_index in + incr positional_index; + Positional i + | Some { label_name = label; loc_ } -> + (match H.find_opt seen_labels label with + | None -> H.add seen_labels label loc_ + | Some first_loc -> + errors := + Errors.duplicated_label_in_decl ~label + ~first_loc:(Rloc.to_loc ~base first_loc) + ~second_loc:loc_ + :: !errors); + Labelled { label; is_mut = false; loc_ = Rloc.to_loc ~base loc_ }) + in + let t = + if H.length seen_labels = 0 then Simple !positional_index + else Complex kinds + in + match !errors with [] -> Ok t | errs -> Partial (t, errs) + : t Local_diagnostics.partial_info) let iter arity f = match arity with @@ -372,11 +397,12 @@ let iter arity f = for i = 0 to n - 1 do f (Positional i) done - | Complex params -> Lst.iter params f + | Complex params -> Lst.iter params ~f let iter2 arity items f = match arity with - | Simple _ -> List.iteri (fun index item -> f (Positional index) item) items + | Simple _ -> + List.iteri (fun index -> fun item -> f (Positional index) item) items | Complex params -> Lst.iter2 params items f let to_list_map arity f = @@ -386,7 +412,8 @@ let to_list_map arity f = let to_list_map2 arity items f = match arity with - | Simple _ -> Lst.mapi items (fun index item -> f (Positional index) item) + | Simple _ -> + Lst.mapi items (fun index -> fun item -> f (Positional index) item) | Complex params -> Lst.map2 params items f let find_constr_label arity typs ~label = @@ -423,13 +450,18 @@ let sexp_of_t arity = match kind with | Positional _ -> S.Atom "_" | Labelled { label; is_mut = false } -> - S.Atom ("~" ^ label : Stdlib.String.t) + S.Atom ((label ^ "~" : Stdlib.String.t) [@merlin.hide]) | Labelled { label; is_mut = true } -> - S.List [ Atom "mut"; Atom ("~" ^ label : Stdlib.String.t) ] - | Optional { label; _ } -> S.Atom ("?" ^ label : Stdlib.String.t) + S.List + [ + Atom "mut"; + Atom ((label ^ "~" : Stdlib.String.t) [@merlin.hide]); + ] + | Optional { label; _ } -> + S.Atom ((label ^ "?=" : Stdlib.String.t) [@merlin.hide]) | Autofill { label } -> S.List [ Atom "auto"; Atom label ] | Question_optional { label } -> - Atom ("~" ^ label ^ "?" : Stdlib.String.t))) + Atom ((label ^ "?" : Stdlib.String.t) [@merlin.hide]))) type arg_kind = Positional of int | Labelled of string @@ -449,31 +481,33 @@ include struct let _ = sexp_of_arg_kind let equal_arg_kind = - (fun a__065_ b__066_ -> - if Stdlib.( == ) a__065_ b__066_ then true - else - match (a__065_, b__066_) with - | Positional _a__067_, Positional _b__068_ -> - Stdlib.( = ) (_a__067_ : int) _b__068_ - | Positional _, _ -> false - | _, Positional _ -> false - | Labelled _a__069_, Labelled _b__070_ -> - Stdlib.( = ) (_a__069_ : string) _b__070_ + (fun a__065_ -> + fun b__066_ -> + if Stdlib.( == ) a__065_ b__066_ then true + else + match (a__065_, b__066_) with + | Positional _a__067_, Positional _b__068_ -> + Stdlib.( = ) (_a__067_ : int) _b__068_ + | Positional _, _ -> false + | _, Positional _ -> false + | Labelled _a__069_, Labelled _b__070_ -> + Stdlib.( = ) (_a__069_ : string) _b__070_ : arg_kind -> arg_kind -> bool) let _ = equal_arg_kind let (hash_fold_arg_kind : Ppx_base.state -> arg_kind -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Positional _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = hsv in - Ppx_base.hash_fold_int hsv _a0 - | Labelled _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = hsv in - Ppx_base.hash_fold_string hsv _a0 + (fun hsv -> + fun arg -> + match arg with + | Positional _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + Ppx_base.hash_fold_int hsv _a0 + | Labelled _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + Ppx_base.hash_fold_string hsv _a0 : Ppx_base.state -> arg_kind -> Ppx_base.state) let _ = hash_fold_arg_kind @@ -533,14 +567,23 @@ module Hashset = Basic_hashsetf.Make (struct end end) -let to_hashtbl (type a b) arity (items : a list) (f : param_kind -> a -> b) = +let to_hashtbl (type a) (type b) arity (items : a list) + (f : param_kind -> a -> b) = let tbl : b Hash.t = Hash.create 17 in - iter2 arity items (fun kind item -> - match kind with - | Positional i -> Hash.add tbl (Positional i) (f kind item) - | Labelled { label; _ } - | Optional { label; _ } - | Autofill { label } - | Question_optional { label } -> - Hash.add tbl (Labelled label) (f kind item)); + iter2 arity items (fun kind -> + fun item -> + match kind with + | Positional i -> Hash.add tbl (Positional i) (f kind item) + | Labelled { label; _ } + | Optional { label; _ } + | Autofill { label } + | Question_optional { label } -> + Hash.add tbl (Labelled label) (f kind item)); tbl + +let is_immutable_constr_arity arity = + match arity with + | Simple _ -> true + | Complex params -> + Basic_lst.for_all params (fun p -> + match p with Labelled { is_mut; _ } -> not is_mut | _ -> true) diff --git a/src/foreach_util.ml b/src/foreach_util.ml index 84e2d24..4ae7c43 100644 --- a/src/foreach_util.ml +++ b/src/foreach_util.ml @@ -14,6 +14,8 @@ module Ident = Basic_core_ident +module Vec = Basic_vec +module Lst = Basic_lst let iter_result_end : Core.expr = Core.const (C_int { v = 0l; repr = None }) @@ -21,26 +23,32 @@ let iter_result_continue : Core.expr = Core.const (C_int { v = 1l; repr = None }) let foreach_result_params : Tvar_env.t = - Tvar_env.of_list_mapi [ "B"; "R"; "E" ] (fun index name -> - Tvar_env.tparam_info ~name - ~typ:(Tparam { index; name_ = name }) - ~constraints:[] ~loc:Rloc.no_location) + Tvar_env.of_list_mapi [ "B"; "R"; "E"; "P" ] (fun index -> + fun name -> + Tvar_env.tparam_info ~name + ~typ:(Tparam { index; name_ = name }) + ~constraints:[] ~loc:Rloc.no_location) -let [ foreach_param_break; foreach_param_ret; foreach_param_err ] = +let [ + foreach_param_break; + foreach_param_ret; + foreach_param_err; + foreach_param_payload; + ] = Tvar_env.get_types foreach_result_params [@@warning "-partial-match"] let foreach_result_tpath = Basic_type_path.Builtin.type_path_foreach_result -let type_foreach_result break return error : Stype.t = - T_constr - { - type_constructor = foreach_result_tpath; - tys = [ break; return; error ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let type_foreach_result break return error payload = + (T_constr + { + type_constructor = foreach_result_tpath; + tys = [ break; return; error; payload ]; + generic_ = false; + is_suberror_ = false; + } + : Stype.t) let foreach_result_type_poly : Stype.t = T_constr @@ -48,10 +56,11 @@ let foreach_result_type_poly : Stype.t = type_constructor = foreach_result_tpath; tys = Tvar_env.get_types foreach_result_params; generic_ = true; - only_tag_enum_ = false; is_suberror_ = false; } +let total = Basic_constr_info.Index_set.singleton 0 4 + let continue : Typedecl_info.constructor = { constr_name = "Continue"; @@ -59,7 +68,7 @@ let continue : Typedecl_info.constructor = cs_args = []; cs_tag = Constr_tag_regular - { total = 4; index = 0; name_ = "Continue"; is_constant_ = true }; + { total; index = 0; name_ = "Continue"; repr_ = Constant }; cs_vis = Read_write; cs_ty_params_ = foreach_result_params; cs_arity_ = Fn_arity.simple 0; @@ -74,7 +83,7 @@ let break : Typedecl_info.constructor = cs_args = [ foreach_param_break ]; cs_tag = Constr_tag_regular - { total = 4; index = 1; name_ = "Break"; is_constant_ = false }; + { total; index = 1; name_ = "Break"; repr_ = Non_constant }; cs_vis = Read_write; cs_ty_params_ = foreach_result_params; cs_arity_ = Fn_arity.simple 1; @@ -89,7 +98,7 @@ let return : Typedecl_info.constructor = cs_args = [ foreach_param_ret ]; cs_tag = Constr_tag_regular - { total = 4; index = 2; name_ = "Return"; is_constant_ = false }; + { total; index = 2; name_ = "Return"; repr_ = Non_constant }; cs_vis = Read_write; cs_ty_params_ = foreach_result_params; cs_arity_ = Fn_arity.simple 1; @@ -104,7 +113,22 @@ let error : Typedecl_info.constructor = cs_args = [ foreach_param_err ]; cs_tag = Constr_tag_regular - { total = 4; index = 3; name_ = "Error"; is_constant_ = false }; + { total; index = 3; name_ = "Error"; repr_ = Non_constant }; + cs_vis = Read_write; + cs_ty_params_ = foreach_result_params; + cs_arity_ = Fn_arity.simple 1; + cs_constr_loc_ = Loc.no_location; + cs_loc_ = Loc.no_location; + } + +let jump_outer : Typedecl_info.constructor = + { + constr_name = "JumpOuter"; + cs_res = foreach_result_type_poly; + cs_args = [ foreach_param_payload ]; + cs_tag = + Constr_tag_regular + { total; index = 4; name_ = "JumpOuter"; repr_ = Non_constant }; cs_vis = Read_write; cs_ty_params_ = foreach_result_params; cs_arity_ = Fn_arity.simple 1; @@ -116,17 +140,177 @@ let foreach_result : Typedecl_info.t = { ty_constr = foreach_result_tpath; ty_arity = 3; - ty_desc = Variant_type [ continue; break; return; error ]; + ty_desc = Variant_type [ continue; break; return; error; jump_outer ]; ty_vis = Vis_fully_pub; ty_params_ = foreach_result_params; ty_loc_ = Loc.no_location; ty_doc_ = Docstring.empty; + ty_attrs = []; ty_is_only_tag_enum_ = false; ty_is_suberror_ = false; } -let get_first_enum_field (obj : Ident.t) (constr : Typedecl_info.constructor) - ~ty ~constr_ty = +let get_first_enum_field (obj : Ident.t) tag ~ty ~constr_ty = Core.prim ~ty - (Penum_field { index = 0; tag = constr.cs_tag }) - [ Core.var obj ~ty:(Type.make_constr_type constr_ty ~tag:constr.cs_tag) ] + (Penum_field { index = 0; tag }) + [ Core.var obj ~ty:(Type.make_constr_type constr_ty ~tag) ] + +type labelled_jump_info = { + label : Label.t; + break_type : Stype.t option; + continue_types : Stype.t list; + need_extra_no_payload_continue : bool; +} + +type jump_outer_constr_info = { + break_tag : Basic_constr_info.constr_tag; + break_type : Stype.t option; + continue_tag : Basic_constr_info.constr_tag; + continue_types : Stype.t list; + extra_continue_tag : Basic_constr_info.constr_tag option; +} + +type jump_outer_ctx = { + payload_type : Stype.t; + constrs : jump_outer_constr_info Label.Map.t; +} + +let make_jump_outer_ctx ~(global_env : Global_env.t) ~tvar_env + (info : labelled_jump_info list) = + (if info = [] then { payload_type = Stype.unit; constrs = Label.Map.empty } + else + let constrs = Vec.empty () in + let total = + Lst.fold_right info 0 (fun i -> + fun acc -> + if i.need_extra_no_payload_continue then acc + 3 else acc + 2) + in + let total = Basic_constr_info.Index_set.singleton 0 (total - 1) in + let toplevel_id : Basic_type_path.toplevel_id = + T_regular + { pkg = !Basic_config.current_package; name = "jump_outer_helper" } + in + let type_name = "JumpOuterPayload" ^ Int.to_string (Basic_uuid.next ()) in + let type_constructor = Basic_type_path.local_type toplevel_id type_name in + let result_ty : Stype.t = + T_constr + { + type_constructor; + tys = Tvar_env.get_types tvar_env; + generic_ = false; + is_suberror_ = false; + } + in + let decl_constrs = Vec.empty () in + let tag_index = ref 0 in + Lst.iter info + ~f:(fun + { label; break_type; continue_types; need_extra_no_payload_continue } + -> + let label_name = Label.basename label in + let break_tag : Basic_constr_info.constr_tag = + Constr_tag_regular + { + total; + index = !tag_index; + repr_ = + (match break_type with None -> Constant | _ -> Non_constant); + name_ = label_name ^ "break"; + } + in + incr tag_index; + let continue_tag : Basic_constr_info.constr_tag = + Constr_tag_regular + { + total; + index = !tag_index; + repr_ = + (match continue_types with + | [] -> Constant + | _ -> Non_constant); + name_ = label_name ^ "continue"; + } + in + incr tag_index; + let break_constr_decl : Typedecl_info.constructor = + { + constr_name = label_name ^ "break"; + cs_res = result_ty; + cs_args = (match break_type with None -> [] | Some t -> [ t ]); + cs_tag = break_tag; + cs_vis = Read_write; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple (if break_type = None then 0 else 1); + cs_constr_loc_ = Loc.no_location; + cs_loc_ = Loc.no_location; + } + in + let continue_constr_decl : Typedecl_info.constructor = + { + constr_name = label_name ^ "continue"; + cs_res = result_ty; + cs_args = continue_types; + cs_tag = continue_tag; + cs_vis = Read_write; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple (List.length continue_types); + cs_constr_loc_ = Loc.no_location; + cs_loc_ = Loc.no_location; + } + in + Vec.push decl_constrs break_constr_decl; + Vec.push decl_constrs continue_constr_decl; + let extra_continue_tag = + if need_extra_no_payload_continue then ( + let extra_continue_tag : Basic_constr_info.constr_tag = + Constr_tag_regular + { + total; + index = !tag_index; + repr_ = Constant; + name_ = label_name ^ "extra_continue"; + } + in + incr tag_index; + let extra_continue_constr_decl : Typedecl_info.constructor = + { + constr_name = label_name ^ "extra_continue"; + cs_res = result_ty; + cs_args = []; + cs_tag = extra_continue_tag; + cs_vis = Read_write; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple 0; + cs_constr_loc_ = Loc.no_location; + cs_loc_ = Loc.no_location; + } + in + Vec.push decl_constrs extra_continue_constr_decl; + Some extra_continue_tag) + else None + in + Vec.push constrs + ( label, + { + break_tag; + break_type; + continue_tag; + continue_types; + extra_continue_tag; + } )); + let decl : Local_type.t = + { + name = type_name; + toplevel_id; + kind = Enum (Vec.to_list decl_constrs); + loc_ = Rloc.no_location; + is_only_tag_enum = false; + ty_params_ = tvar_env; + } + in + Global_env.add_local_type_after_typing global_env decl; + { + payload_type = result_ty; + constrs = Label.Map.of_array (Vec.to_array constrs); + } + : jump_outer_ctx) diff --git a/src/gen_test_info.ml b/src/gen_test_info.ml index 334cc1f..3f0efd1 100644 --- a/src/gen_test_info.ml +++ b/src/gen_test_info.ml @@ -25,35 +25,41 @@ type test_info = { let test_info_to_mbt_tuple = function | { func; name = Some name; _ } -> - Stdlib.String.concat "" [ "("; func; ", [\""; name; "\"])" ] - | { func; name = None; _ } -> ("(" ^ func ^ ", [])" : Stdlib.String.t) + Stdlib.String.concat "" + [ "("; func; ", [\""; name; "\"])" ] [@merlin.hide] + | { func; name = None; _ } -> + ("(" ^ func ^ ", [])" : Stdlib.String.t) [@merlin.hide] let test_info_to_mbt_index_pair = function | { index; func; name = Some name; _ } -> let index = Int.to_string index in - Stdlib.String.concat "" [ index; ": ("; func; ", [\""; name; "\"])" ] + (Stdlib.String.concat "" + [ index; ": ("; func; ", [\""; name; "\"])" ] [@merlin.hide]) | { index; func; name = None; _ } -> let index = Int.to_string index in - Stdlib.String.concat "" [ index; ": ("; func; ", [])" ] + (Stdlib.String.concat "" [ index; ": ("; func; ", [])" ] [@merlin.hide]) -let tests_of_file filename impls : test_info list = - let rec aux i acc = function - | [] -> List.rev acc - | impl :: impls -> ( - match impl with - | Syntax.Ptop_test { name; params; _ } -> - let name = - match name with - | Some name -> Some name.v.string_repr - | None -> None - in - let func = Test_util.gen_test_name filename i in - let has_args = match params with None -> false | Some _ -> true in - let info = { index = i; func; has_args; name } in - aux (i + 1) (info :: acc) impls - | _ -> aux i acc impls) - in - aux 0 [] impls +let tests_of_file filename impls = + (let rec aux i acc = function + | [] -> List.rev acc + | impl :: impls -> ( + match impl with + | Syntax.Ptop_test { name; params; _ } -> + let name = + match name with + | Some name -> Some name.v.string_repr + | None -> None + in + let func = Test_util.gen_test_name filename i in + let has_args = + match params with None -> false | Some _ -> true + in + let info = { index = i; func; has_args; name } in + aux (i + 1) (info :: acc) impls + | _ -> aux i acc impls) + in + aux 0 [] impls + : test_info list) let extract_tests (input : (string * Syntax.impls) list) = let tests = @@ -76,30 +82,28 @@ let gen_test_info (input : (string * Syntax.impls) list) = let _, no_args_map, with_args_map = extract_tests input in let file_tests_to_string (filename, tests) = let filename = Basic_strutil.escaped_string filename in - let tests = - Lst.map tests test_info_to_mbt_index_pair |> String.concat "," - in + let tests = String.concat "," (Lst.map tests test_info_to_mbt_index_pair) in Stdlib.String.concat "" [ " \""; filename; "\": {"; tests; "} " ] in let no_args_map_str = - let str = Lst.map no_args_map file_tests_to_string |> String.concat "," in - "let no_args_tests = {" ^ str ^ "}" + let str = String.concat "," (Lst.map no_args_map file_tests_to_string) in + ("let no_args_tests = {" ^ str ^ "}" : Stdlib.String.t) in let with_args_map_str = - let str = Lst.map with_args_map file_tests_to_string |> String.concat "," in - "let with_args_tests = {" ^ str ^ "}" + let str = String.concat "," (Lst.map with_args_map file_tests_to_string) in + ("let with_args_tests = {" ^ str ^ "}" : Stdlib.String.t) in let old_tests_str = let tests = - Lst.map no_args_map (fun (filename, tests) -> - let filename = Basic_strutil.escaped_string filename in - let tests = - Lst.map tests test_info_to_mbt_tuple |> String.concat "," - in - Stdlib.String.concat "" [ " \""; filename; "\": ["; tests; "] " ]) - |> String.concat "," + String.concat "," + (Lst.map no_args_map (fun (filename, tests) -> + let filename = Basic_strutil.escaped_string filename in + let tests = + String.concat "," (Lst.map tests test_info_to_mbt_tuple) + in + Stdlib.String.concat "" [ " \""; filename; "\": ["; tests; "] " ])) in - " let tests = {" ^ tests ^ "} " + (" let tests = {" ^ tests ^ "} " : Stdlib.String.t) in String.concat "\n " [ old_tests_str; no_args_map_str; with_args_map_str ] @@ -117,7 +121,7 @@ let gen_test_info_json (input : (string * Syntax.impls) list) = `Assoc (Lst.map test_map (fun (filename, tests) -> let tests_json = - Lst.map tests json_of_test_info |> fun tl -> `List tl + (fun tl -> `List tl) (Lst.map tests json_of_test_info) in (filename, tests_json))) in diff --git a/src/git_commit.ml b/src/git_commit.ml index 5ec842e..cf10392 100644 --- a/src/git_commit.ml +++ b/src/git_commit.ml @@ -13,5 +13,5 @@ *) -let date = "20241202" -let short_version = "8756d160d" +let date = "20250312" +let short_version = "a7a1e9804" diff --git a/src/global_ctx2.ml b/src/global_ctx2.ml index 9720d2a..4133173 100644 --- a/src/global_ctx2.ml +++ b/src/global_ctx2.ml @@ -20,9 +20,33 @@ module Vec = Basic_vec module Lst = Basic_lst module Fn_addr = Basic_fn_address module Fn_addr_hashset = Fn_addr.Hashset - -let make_string_constant_id index : Stdlib.String.t = - "$moonbit.js_string_constant." ^ Int.to_string index +module Ast = Dwarfsm_ast + +let int_const = Wasmlinear_constr.int_const +and ( @: ) = Wasmlinear_constr.( @: ) +and immut = Wasmlinear_constr.immut +and import = Wasmlinear_constr.import +and esc_then_decode = Wasmlinear_constr.esc_then_decode +and global_get = Wasmlinear_constr.global_get +and call = Wasmlinear_constr.call +and binder = Wasmlinear_constr.binder + +let global = Wasmgc_constr.global +and ref_ = Wasmgc_constr.ref_ +and ref_extern_ = Wasmgc_constr.ref_extern_ +and data = Wasmgc_constr.data +and elem_declare_func = Wasmgc_constr.elem_declare_func +and param = Wasmgc_constr.param +and result = Wasmgc_constr.result +and array_new_default = Wasmgc_constr.array_new_default +and array_new_fixed = Wasmgc_constr.array_new_fixed +and array_new_data = Wasmgc_constr.array_new_data +and struct_new = Wasmgc_constr.struct_new +and import_global = Wasmgc_constr.import_global +and global_get_ = Wasmgc_constr.global_get_ + +let make_string_constant_id index = + ("$moonbit.js_string_constant." ^ Int.to_string index : Stdlib.String.t) type default_info = Arr of Tid.t | Enum | Js_string @@ -47,7 +71,8 @@ module Import = struct func_name = func_name__004_; params_ty = params_ty__006_; return_ty = return_ty__008_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__009_ = @@ -79,18 +104,19 @@ module Import = struct let _ = sexp_of_t let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_string hsv arg.module_name - in - Ppx_base.hash_fold_string hsv arg.func_name - in - Ppx_base.hash_fold_list Ltype.hash_fold_t hsv arg.params_ty - in - Ppx_base.hash_fold_option Ltype.hash_fold_t hsv arg.return_ty + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_string hsv arg.module_name + in + Ppx_base.hash_fold_string hsv arg.func_name + in + Ppx_base.hash_fold_list Ltype.hash_fold_t hsv arg.params_ty + in + Ppx_base.hash_fold_option Ltype.hash_fold_t hsv arg.return_ty let _ = hash_fold_t @@ -105,24 +131,28 @@ module Import = struct let _ = hash let equal = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then true - else - Stdlib.( && ) - (Stdlib.( = ) (a__010_.module_name : string) b__011_.module_name) - (Stdlib.( && ) - (Stdlib.( = ) (a__010_.func_name : string) b__011_.func_name) - (Stdlib.( && ) - (Ppx_base.equal_list - (fun a__012_ b__013_ -> Ltype.equal a__012_ b__013_) - a__010_.params_ty b__011_.params_ty) - (match (a__010_.return_ty, b__011_.return_ty) with - | None, None -> true - | None, Some _ -> false - | Some _, None -> false - | Some __option_x, Some __option_y -> - (fun a__014_ b__015_ -> Ltype.equal a__014_ b__015_) - __option_x __option_y))) + (fun a__010_ -> + fun b__011_ -> + if Stdlib.( == ) a__010_ b__011_ then true + else + Stdlib.( && ) + (Stdlib.( = ) (a__010_.module_name : string) b__011_.module_name) + (Stdlib.( && ) + (Stdlib.( = ) (a__010_.func_name : string) b__011_.func_name) + (Stdlib.( && ) + (Ppx_base.equal_list + (fun a__012_ -> + fun b__013_ -> Ltype.equal a__012_ b__013_) + a__010_.params_ty b__011_.params_ty) + (match (a__010_.return_ty, b__011_.return_ty) with + | None, None -> true + | None, Some _ -> false + | Some _, None -> false + | Some __option_x, Some __option_y -> + (fun a__014_ -> + fun (b__015_ [@merlin.hide]) -> + (Ltype.equal a__014_ b__015_ [@merlin.hide])) + __option_x __option_y))) : t -> t -> bool) let _ = equal @@ -148,7 +178,7 @@ type t = { func_refs : Fn_addr_hashset.t; } -let make_constr_id (tag : int) = W.Atom ("$moonbit.constr/" ^ Int.to_string tag) +let make_constr_id__ (tag : int) = "$moonbit.constr/" ^ Int.to_string tag let create () = { @@ -160,316 +190,150 @@ let create () = func_refs = Fn_addr_hashset.create 17; } -let i32_to_sexp = Wasm_util.i32_to_sexp -let tid_to_string = Tid.to_wasm_name - -let compile_string_literal ~(global_ctx : t) (s : string) : W.t = - if !Basic_config.use_js_builtin_string then - let index = - Const_table.find_js_builtin_str_const global_ctx.const_table s - in - let name = make_string_constant_id index in - (List (List.cons (Atom "global.get" : W.t) ([ Atom name ] : W.t list)) - : W.t) - else if s = "" then ( - let tid = Ltype.tid_string in - if not (Tid.Hash.mem global_ctx.defaults tid) then - Tid.Hash.add global_ctx.defaults tid - (string_default_name, Arr Ltype.tid_string); - (List - (List.cons - (Atom "global.get" : W.t) - ([ Atom string_default_name ] : W.t list)) - : W.t)) - else - let utf16 = Basic_strutil.string_utf16_of_utf8 s in - let offset, index = - Const_table.find_str_const global_ctx.const_table utf16 - in - let len = String.length utf16 asr 1 in - (List - (List.cons - (Atom "call" : W.t) - (List.cons - (Atom "$moonbit.string_literal" : W.t) - (List.cons - (i32_to_sexp index : W.t) - (List.cons - (i32_to_sexp offset : W.t) - ([ i32_to_sexp len ] : W.t list))))) - : W.t) - -let compile_bytes_literal ~(global_ctx : t) (utf8str : string) : W.t = - let offset = Const_table.find_bytes_const global_ctx.const_table utf8str in - let len = String.length utf8str in - (List - (List.cons - (Atom "array.new_data" : W.t) - (List.cons - (Atom "$moonbit.bytes" : W.t) - (List.cons - (Atom "$moonbit.const_data" : W.t) - (List.cons - (i32_to_sexp offset : W.t) - ([ i32_to_sexp len ] : W.t list))))) - : W.t) +let compile_string_literal ~(global_ctx : t) (s : string) = + (if !Basic_config.use_js_builtin_string then + let index = + Const_table.find_js_builtin_str_const global_ctx.const_table s + in + let name = make_string_constant_id index in + [ global_get name ] + else if s = "" then ( + let tid = Ltype.tid_string in + if not (Tid.Hash.mem global_ctx.defaults tid) then + Tid.Hash.add global_ctx.defaults tid + (string_default_name, Arr Ltype.tid_string); + [ global_get string_default_name ]) + else + let utf16 = Basic_strutil.string_utf16_of_utf8 s in + let offset, index = + Const_table.find_str_const global_ctx.const_table utf16 + in + let len = String.length utf16 asr 1 in + int_const index @: int_const offset @: int_const len + @: [ call "$moonbit.string_literal" ] + : Ast.instr list) + +let compile_bytes_literal ~(global_ctx : t) (utf8str : string) = + (if utf8str = "" then ( + let tid = Ltype.tid_bytes in + if not (Tid.Hash.mem global_ctx.defaults tid) then + Tid.Hash.add global_ctx.defaults tid + (bytes_default_name, Arr Ltype.tid_bytes); + [ global_get bytes_default_name ]) + else + let offset = Const_table.find_bytes_const global_ctx.const_table utf8str in + let len = String.length utf8str in + int_const offset @: int_const len + @: [ array_new_data ~id_:"$moonbit.bytes" "$moonbit.const_data" ] + : Ast.instr list) let compile_int32_array_literal ~(global_ctx : t) (xs : int32 list) - (tid : Tid.t) : W.t = - let buf = Buffer.create 16 in - let len = List.length xs in - List.iter (fun x -> Buffer.add_int32_le buf x) xs; - let s = Buffer.contents buf in - let offset = Const_table.find_array_const global_ctx.const_table s in - (List - (List.cons - (Atom "array.new_data" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.cons - (Atom "$moonbit.const_data" : W.t) - (List.cons - (i32_to_sexp offset : W.t) - ([ i32_to_sexp len ] : W.t list))))) - : W.t) + (tid : Tid.t) = + (let buf = Buffer.create 16 in + let len = List.length xs in + Basic_lst.iter xs ~f:(fun x -> Buffer.add_int32_le buf x); + let s = Buffer.contents buf in + let offset = Const_table.find_array_const global_ctx.const_table s in + int_const offset @: int_const len + @: [ array_new_data ~id:tid "$moonbit.const_data" ] + : Ast.instr list) let compile_int64_array_literal ~(global_ctx : t) (xs : int64 list) - (tid : Tid.t) : W.t = - let buf = Buffer.create 16 in - let len = List.length xs in - List.iter (fun x -> Buffer.add_int64_le buf x) xs; - let s = Buffer.contents buf in - let offset = Const_table.find_array_const global_ctx.const_table s in - (List - (List.cons - (Atom "array.new_data" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.cons - (Atom "$moonbit.const_data" : W.t) - (List.cons - (i32_to_sexp offset : W.t) - ([ i32_to_sexp len ] : W.t list))))) - : W.t) - -let compile_constant_constr ~(global_ctx : t) ~(tag : int) : W.t = - Hashset_int.add global_ctx.tags tag; - let id = make_constr_id tag in - (List (List.cons (Atom "global.get" : W.t) ([ id ] : W.t list)) : W.t) + (tid : Tid.t) = + (let buf = Buffer.create 16 in + let len = List.length xs in + Basic_lst.iter xs ~f:(fun x -> Buffer.add_int64_le buf x); + let s = Buffer.contents buf in + let offset = Const_table.find_array_const global_ctx.const_table s in + int_const offset @: int_const len + @: [ array_new_data ~id:tid "$moonbit.const_data" ] + : Ast.instr list) + +let compile_constant_constr ~(global_ctx : t) ~(tag : int) = + (Hashset_int.add global_ctx.tags tag; + let id = make_constr_id__ tag in + global_get_ id + : Ast.instr) let compile_defaults (global_ctx : t) = let default_names = Vec.empty () in - Tid.Hash.iter global_ctx.defaults (fun (_, (name, elem_tid)) -> - Vec.push default_names (name, elem_tid)); - Vec.map_into_list default_names (fun (name, default_info) -> - match default_info with - | Arr tid -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom name : W.t) - (List.cons - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "array.new_fixed" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom "0" ] : W.t list))); - ] - : W.t list)))) - : W.t) - | Js_string -> - let s = "\"\"" in - let const_string_module_name = - Basic_strutil.esc_quote !Basic_config.const_string_module_name - in - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom name : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom const_string_module_name : W.t) - ([ Atom s ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - ([ Atom "extern" ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Enum -> - let tid = Ltype.tid_enum in - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom name : W.t) - (List.cons - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "struct.new" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "-1" ] : W.t list)); - ] - : W.t list))); - ] - : W.t list)))) - : W.t)) + let used_default_js_string = ref false in + Tid.Hash.iter global_ctx.defaults (fun (_, (name, default_info)) -> + if default_info = Js_string then used_default_js_string := true + else Vec.push default_names (name, default_info)); + ( Vec.map_into_list default_names ~unorder:(fun (name, default_info) -> + match default_info with + | Arr tid -> + global ~id_:name + (immut (ref_ ~id:tid ())) + [ array_new_fixed ~id:tid ~size:0 ] + | Js_string -> assert false + | Enum -> + let tid = Ltype.tid_enum in + global ~id_:name + (immut (ref_ ~id:tid ())) + (int_const (-1) @: [ struct_new tid ])), + !used_default_js_string ) let compile_to_globals (global_ctx : t) = let constant_constr = - Hashset_int.fold global_ctx.tags [] (fun i acc -> - let id = make_constr_id i in - let tid_enum = Ltype.tid_enum in - List.cons - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (id : W.t) - (List.cons - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom (tid_to_string tid_enum) ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "struct.new" : W.t) - (List.cons - (Atom (tid_to_string tid_enum) : W.t) - ([ i32_to_sexp i ] : W.t list))); - ] - : W.t list)))) - : W.t) - (acc : W.t list)) + Hashset_int.fold global_ctx.tags [] (fun i -> + fun acc -> + let id_ = make_constr_id__ i in + let tid_enum = Ltype.tid_enum in + global ~id_ + (immut (ref_ ~id:tid_enum ())) + (int_const i @: [ struct_new tid_enum ]) + :: acc) in - let defaults = compile_defaults global_ctx in + let defaults, used_default_js_string = compile_defaults global_ctx in if !Basic_config.use_js_builtin_string then ( let constant_strings = Vec.empty () in - Const_table.iter_constant_string_with_index global_ctx.const_table - (fun s i -> - let name = make_string_constant_id i in - let esc_quote_hex s = "\"" ^ W.escaped s ^ "\"" in - let s = esc_quote_hex s in + Const_table.iter_constant_string_with_index global_ctx.const_table (fun s -> + fun i -> + let name = make_string_constant_id i in + let const_string_module_name = + esc_then_decode !Basic_config.const_string_module_name + in + let global = + import_global ~id_:name ~mod_:const_string_module_name ~s + (immut ref_extern_) + in + Vec.push constant_strings global); + let constant_strings = Vec.to_list constant_strings in + let constant_strings = + if used_default_js_string then + let s = "" in let const_string_module_name = - Basic_strutil.esc_quote !Basic_config.const_string_module_name + esc_then_decode !Basic_config.const_string_module_name in - let global = - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom name : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom const_string_module_name : W.t) - ([ Atom s ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - ([ Atom "extern" ] : W.t list)); - ] - : W.t list)))) - : W.t) - in - Vec.push constant_strings global); - let constant_strings = Vec.to_list constant_strings in - List.append - (constant_constr : W.t list) - (List.append (defaults : W.t list) (constant_strings : W.t list))) + let name = string_default_name in + import_global ~id_:name ~mod_:const_string_module_name ~s + (immut ref_extern_) + :: constant_strings + else constant_strings + in + (constant_constr @ defaults, constant_strings)) else let string_pool_len = Const_table.get_string_count global_ctx.const_table in let string_pool = - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom "$moonbit.string_pool" : W.t) - (List.cons - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom "$moonbit.string_pool_type" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "array.new_default" : W.t) - (List.cons - (Atom "$moonbit.string_pool_type" : W.t) - ([ i32_to_sexp string_pool_len ] : W.t list))); - ] - : W.t list)))) - : W.t) + global ~id_:"$moonbit.string_pool" + (immut (ref_ ~id_:"$moonbit.string_pool_type" ())) + (int_const string_pool_len + @: [ array_new_default ~id_:"$moonbit.string_pool_type" () ]) in - List.cons - (string_pool : W.t) - (List.append (constant_constr : W.t list) (defaults : W.t list)) + ((string_pool :: constant_constr) @ defaults, []) let compile_to_data (global_ctx : t) = let s = Const_table.to_wat_string global_ctx.const_table in - if s = "" then [] - else - let s = "\"" ^ W.escaped s ^ "\"" in - ([ - List - (List.cons - (Atom "data" : W.t) - (List.cons - (Atom "$moonbit.const_data" : W.t) - ([ Atom s ] : W.t list))); - ] - : W.t list) + if s = "" then [] else data ~name:"$moonbit.const_data" s let compile_func_ref_declare (global_ctx : t) = - let addr_to_string = Basic_fn_address.to_wasm_name in let fns = - Fn_addr_hashset.fold global_ctx.func_refs [] (fun addr acc -> - (Atom (addr_to_string addr) : W.t) :: acc) + Fn_addr_hashset.fold global_ctx.func_refs [] (fun addr -> + fun acc -> addr :: acc) in - if fns = [] then [] - else - ([ - List - (List.cons - (Atom "elem" : W.t) - (List.cons - (Atom "declare" : W.t) - (List.cons (Atom "func" : W.t) (fns : W.t list)))); - ] - : W.t list) + if fns = [] then [] else elem_declare_func fns let add_import (global_ctx : t) (import : Import.t) = Import_hash.find_or_update global_ctx.imports import ~update:(fun _ -> @@ -489,55 +353,26 @@ let add_func_ref (global_ctx : t) (address : Fn_addr.t) = Fn_addr_hashset.add global_ctx.func_refs address let compile_imports (global_ctx : t) = - let ltype_to_sexp = Transl_type.ltype_to_sexp in - Import_hash.fold global_ctx.imports [] - (fun { module_name; func_name; params_ty; return_ty } name acc -> - let mname = Basic_strutil.esc_quote module_name in - let fname = Basic_strutil.esc_quote func_name in - let params = - Lst.map params_ty (fun t : W.t -> - List - (List.cons (Atom "param" : W.t) ([ ltype_to_sexp t ] : W.t list))) - in - let return = - match return_ty with - | Some return_type -> - ([ - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp return_type ] : W.t list)); - ] - : W.t list) - | None -> [] - in - List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom name : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom mname : W.t) - ([ Atom fname ] : W.t list))) - : W.t) - (List.append (params : W.t list) (return : W.t list))))) - : W.t) - (acc : W.t list)) + (let func = Wasmlinear_constr.import_func in + Import_hash.fold global_ctx.imports [] + (fun { module_name; func_name; params_ty; return_ty } -> + fun fname -> + fun acc -> + let module_ = esc_then_decode module_name in + let name = esc_then_decode func_name in + let params = Lst.map params_ty (fun t -> param t) in + let results = + match return_ty with + | Some return_type -> [ result return_type ] + | None -> [] + in + import ~module_ ~name (func fname ~params ~results) @ acc) + : Ast.modulefield list) let compile_inlines (global_ctx : t) = - Vec.map_into_list global_ctx.inlines (fun (name, body) -> - match body with - | (List (Atom "func" :: a) : W.t) -> - (List - (List.cons - (Atom "func" : W.t) - (List.cons (Atom name : W.t) (a : W.t list))) - : W.t) + Vec.map_into_list global_ctx.inlines ~unorder:(fun (name, body) -> + match Dwarfsm_parse.modulefield body with + | Ast.Func func :: [] -> Ast.Func { func with id = binder name } | _ -> assert false) let find_default_elem (global_ctx : t) (type_defs : Ltype.def Tid.Hash.t) diff --git a/src/global_env.ml b/src/global_env.ml index b8630d5..3214848 100644 --- a/src/global_env.ml +++ b/src/global_env.ml @@ -24,7 +24,7 @@ module All_types = struct type t = { toplevel : Typing_info.types; builtin : Typing_info.types; - type_alias : Typedecl_info.alias Hash_string.t; + type_alias : Type_alias.t Hash_string.t; pkgs : Pkg.pkg_tbl; } @@ -37,7 +37,8 @@ module All_types = struct builtin = builtin__004_; type_alias = type_alias__006_; pkgs = pkgs__008_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__009_ = Pkg.sexp_of_pkg_tbl pkgs__008_ in @@ -45,7 +46,7 @@ module All_types = struct in let bnds__001_ = let arg__007_ = - Hash_string.sexp_of_t Typedecl_info.sexp_of_alias type_alias__006_ + Hash_string.sexp_of_t Type_alias.sexp_of_t type_alias__006_ in (S.List [ S.Atom "type_alias"; arg__007_ ] :: bnds__001_ : _ Stdlib.List.t) @@ -79,83 +80,65 @@ module All_types = struct let find_type_alias types x = find_type_alias_aux ~pkgs:types.pkgs ~type_alias:types.type_alias x - let find_type_aux ~pkgs ~builtin_types ~toplevel_types (x : Longident.t) ~loc - : Typedecl_info.t Local_diagnostics.info = - match x with - | Lident id -> ( - match Typing_info.find_type toplevel_types id with - | Some td -> Ok td - | None -> ( - match - Pkg.find_type pkgs { pkg = Basic_config.builtin_package; id } ~loc - with - | Ok td -> Ok td - | Error _ -> ( - match Typing_info.find_type builtin_types id with - | Some td -> Ok td - | None -> Error (Errors.unbound_type ~name:x ~loc)))) - | Ldot qual_name -> Pkg.find_type pkgs qual_name ~loc - let find_type_by_path_aux ~pkgs ~builtin_types ~toplevel_types - (p : Type_path.t) : Typedecl_info.t option = - match p with - | T_unit | T_bool | T_byte | T_char | T_int | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_option | T_result | T_error_value_result - | T_fixedarray | T_bytes | T_ref | T_error -> - Typing_info.find_type builtin_types (Type_path_util.name p) - | Toplevel { pkg; id } -> - if pkg = !Basic_config.current_package then - Typing_info.find_type toplevel_types id - else Pkg.find_type_opt pkgs ~pkg id - | Tuple _ -> None - | Constr _ -> None - - let find_type_by_path (types : t) (p : Type_path.t) : Typedecl_info.t option = - find_type_by_path_aux ~pkgs:types.pkgs ~builtin_types:types.builtin - ~toplevel_types:types.toplevel p - - let find_toplevel_type_exn (env : t) (x : string) : Typedecl_info.t = - match Typing_info.find_type env.toplevel x with - | Some td -> td - | None -> failwith ("toplevel type not found: " ^ x) - - let find_trait (env : t) (x : Longident.t) ~loc : - Trait_decl.t Local_diagnostics.info = - match x with - | Lident name -> ( - match Typing_info.find_trait env.toplevel name with - | Some trait -> Ok trait - | None -> ( - match - Pkg.find_trait env.pkgs - { pkg = Basic_config.builtin_package; id = name } - ~loc - with - | Ok trait -> Ok trait - | Error _ -> ( - match Typing_info.find_trait env.builtin name with - | Some trait -> Ok trait - | None -> Error (Errors.unbound_trait ~name:x ~loc)))) - | Ldot qual_name -> Pkg.find_trait env.pkgs qual_name ~loc + (p : Type_path.t) = + (match p with + | T_unit | T_bool | T_byte | T_int16 | T_uint16 | T_char | T_int | T_int64 + | T_uint | T_uint64 | T_float | T_double | T_string | T_option | T_result + | T_error_value_result | T_fixedarray | T_bytes | T_ref | T_error -> + Typing_info.find_type builtin_types (Type_path_util.name p) + | Toplevel { pkg; id } -> + if pkg = !Basic_config.current_package then + Typing_info.find_type toplevel_types id + else Pkg.find_type_opt pkgs ~pkg id + | Tuple _ -> None + | Constr _ -> None + | T_local _ -> None + : Typedecl_info.t option) + + let find_type_by_path (types : t) (p : Type_path.t) = + (find_type_by_path_aux ~pkgs:types.pkgs ~builtin_types:types.builtin + ~toplevel_types:types.toplevel p + : Typedecl_info.t option) + + let find_trait (env : t) (x : Longident.t) ~loc = + (match x with + | Lident name -> ( + match Typing_info.find_trait env.toplevel name with + | Some trait -> Ok trait + | None -> ( + match + Pkg.find_trait env.pkgs + { pkg = Basic_config.builtin_package; id = name } + ~loc + with + | Ok trait -> Ok trait + | Error _ -> ( + match Typing_info.find_trait env.builtin name with + | Some trait -> Ok trait + | None -> Error (Errors.unbound_trait ~name:x ~loc)))) + | Ldot qual_name -> Pkg.find_trait env.pkgs qual_name ~loc + : Trait_decl.t Local_diagnostics.info) let add_type_alias env name ty = Hash_string.replace env.type_alias name ty let add_type (t : t) = Typing_info.add_type t.toplevel let add_trait (t : t) = Typing_info.add_trait t.toplevel let find_trait_by_path_aux ~pkgs ~toplevel_types ~builtin_types - (p : Type_path.t) : Trait_decl.t option = - match p with - | T_unit | T_bool | T_byte | T_char | T_int | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_option | T_result | T_error_value_result - | T_fixedarray | T_bytes | T_ref | T_error -> - Typing_info.find_trait builtin_types (Type_path_util.name p) - | Toplevel { pkg; id } when pkg = !Basic_config.current_package -> - Typing_info.find_trait toplevel_types id - | Toplevel { pkg; id } -> ( - match Pkg.find_trait pkgs { pkg; id } ~loc:Rloc.no_location with - | Ok trait -> Some trait - | Error _ -> None) - | Tuple _ | Constr _ -> None + (p : Type_path.t) = + (match p with + | T_unit | T_bool | T_byte | T_int16 | T_uint16 | T_char | T_int | T_int64 + | T_uint | T_uint64 | T_float | T_double | T_string | T_option | T_result + | T_error_value_result | T_fixedarray | T_bytes | T_ref | T_error -> + Typing_info.find_trait builtin_types (Type_path_util.name p) + | Toplevel { pkg; id } when pkg = !Basic_config.current_package -> + Typing_info.find_trait toplevel_types id + | Toplevel { pkg; id } -> ( + match Pkg.find_trait pkgs { pkg; id } ~loc:Rloc.no_location with + | Ok trait -> Some trait + | Error _ -> None) + | Tuple _ | Constr _ | T_local _ -> None + : Trait_decl.t option) let find_trait_by_path (env : t) (p : Type_path.t) = find_trait_by_path_aux p ~pkgs:env.pkgs ~builtin_types:env.builtin @@ -170,32 +153,51 @@ module All_types = struct match Typing_info.find_trait env.toplevel id with | Some trait -> `Trait trait | None -> ( - match - Pkg.find_type_or_trait env.pkgs - ~pkg:Basic_config.builtin_package id ~loc - with - | (`Type _ | `Trait _) as result -> result - | `Error _ -> ( + match Pkg.find_type_or_trait_in_builtin env.pkgs id with + | (`Type _ | `Trait _) as x -> x + | `Not_found -> ( match Typing_info.find_type env.builtin id with | Some td -> `Type td - | None -> `Error (Errors.unbound_type_or_trait ~name ~loc))) - )) - | Ldot { pkg; id } -> Pkg.find_type_or_trait env.pkgs ~pkg id ~loc + | None -> ( + match id with + | "Unit" -> `Predef Stype.unit + | "Bool" -> `Predef Stype.bool + | "Byte" -> `Predef Stype.byte + | "Int16" -> `Predef Stype.int16 + | "UInt16" -> `Predef Stype.uint16 + | "Char" -> `Predef Stype.char + | "Int" -> `Predef Stype.int + | "Int64" -> `Predef Stype.int64 + | "UInt" -> `Predef Stype.uint + | "UInt64" -> `Predef Stype.uint64 + | "Float" -> `Predef Stype.float + | "Double" -> `Predef Stype.double + | "String" -> `Predef Stype.string + | "Bytes" -> `Predef Stype.bytes + | _ -> `Error (Errors.unbound_type_or_trait ~name ~loc)) + )))) + | Ldot { pkg; id } -> + (Pkg.find_type_or_trait env.pkgs ~pkg id ~loc + :> [ `Type of _ | `Trait of _ | `Predef of _ | `Error of _ ]) let find_foreign_value (env : t) ~pkg ~name = Pkg.find_regular_value env.pkgs ~pkg name end +module Qual_ident_hash = Basic_hashf.Make (Basic_qual_ident) + type t = { builtin_types : Typing_info.types; builtin_values : Typing_info.values; toplevel_types : Typing_info.types; toplevel_values : Typing_info.values; - type_alias : Typedecl_info.alias Hash_string.t; + type_alias : Type_alias.t Hash_string.t; pkg_tbl : Pkg.pkg_tbl; method_env : Method_env.t; ext_method_env : Ext_method_env.t; trait_impls : Trait_impl.t; + mutable cur_local_type_env : Local_type.env option; + all_local_type_env : Local_type.env Qual_ident_hash.t; } include struct @@ -212,8 +214,27 @@ include struct method_env = method_env__023_; ext_method_env = ext_method_env__025_; trait_impls = trait_impls__027_; - } -> + cur_local_type_env = cur_local_type_env__029_; + all_local_type_env = all_local_type_env__031_; + } + -> let bnds__010_ = ([] : _ Stdlib.List.t) in + let bnds__010_ = + let arg__032_ = + Qual_ident_hash.sexp_of_t Local_type.sexp_of_env + all_local_type_env__031_ + in + (S.List [ S.Atom "all_local_type_env"; arg__032_ ] :: bnds__010_ + : _ Stdlib.List.t) + in + let bnds__010_ = + let arg__030_ = + Moon_sexp_conv.sexp_of_option Local_type.sexp_of_env + cur_local_type_env__029_ + in + (S.List [ S.Atom "cur_local_type_env"; arg__030_ ] :: bnds__010_ + : _ Stdlib.List.t) + in let bnds__010_ = let arg__028_ = Trait_impl.sexp_of_t trait_impls__027_ in (S.List [ S.Atom "trait_impls"; arg__028_ ] :: bnds__010_ @@ -236,7 +257,7 @@ include struct in let bnds__010_ = let arg__020_ = - Hash_string.sexp_of_t Typedecl_info.sexp_of_alias type_alias__019_ + Hash_string.sexp_of_t Type_alias.sexp_of_t type_alias__019_ in (S.List [ S.Atom "type_alias"; arg__020_ ] :: bnds__010_ : _ Stdlib.List.t) @@ -268,18 +289,21 @@ include struct end let make ~(types : All_types.t) ~builtin ~toplevel ~method_env ~ext_method_env - ~trait_impls : t = - { - builtin_types = types.builtin; - builtin_values = builtin; - toplevel_types = types.toplevel; - toplevel_values = toplevel; - type_alias = types.type_alias; - pkg_tbl = types.pkgs; - method_env; - ext_method_env; - trait_impls; - } + ~trait_impls = + ({ + builtin_types = types.builtin; + builtin_values = builtin; + toplevel_types = types.toplevel; + toplevel_values = toplevel; + type_alias = types.type_alias; + pkg_tbl = types.pkgs; + method_env; + ext_method_env; + trait_impls; + cur_local_type_env = None; + all_local_type_env = Qual_ident_hash.create 17; + } + : t) let get_builtin_types (env : t) = env.builtin_types let get_builtin_values (env : t) = env.builtin_values @@ -291,96 +315,96 @@ let get_method_env (env : t) = env.method_env let get_ext_method_env (env : t) = env.ext_method_env let get_trait_impls (env : t) = env.trait_impls -let get_all_types (env : t) : All_types.t = - { - builtin = env.builtin_types; - toplevel = env.toplevel_types; - type_alias = env.type_alias; - pkgs = env.pkg_tbl; - } - -let unknown_value id : Value_info.t = - Toplevel_value - { - id; - typ = Stype.new_type_var Tvar_error; - pub = false; - kind = Normal; - loc_ = Loc.no_location; - doc_ = Docstring.empty; - ty_params_ = Tvar_env.empty; - arity_ = None; - param_names_ = []; - direct_use_loc_ = Not_direct_use; - } - -let find_type_alias (env : t) (x : Longident.t) : Typedecl_info.alias option = - All_types.find_type_alias_aux ~pkgs:env.pkg_tbl ~type_alias:env.type_alias x - -let find_type (env : t) (x : Longident.t) ~loc : - Typedecl_info.t Local_diagnostics.info = - let fallback () = - All_types.find_type_aux x ~loc ~pkgs:env.pkg_tbl - ~builtin_types:env.builtin_types ~toplevel_types:env.toplevel_types - [@@local] - in - match find_type_alias env x with - | Some alias -> ( - match Stype.type_repr alias.alias with - | T_constr { type_constructor = p; _ } -> ( - match - All_types.find_type_by_path_aux ~pkgs:env.pkg_tbl - ~builtin_types:env.builtin_types - ~toplevel_types:env.toplevel_types p - with - | None -> fallback () - | Some decl -> Ok decl) - | _ -> fallback ()) - | None -> fallback () - -let find_type_by_path (env : t) (p : Type_path.t) : Typedecl_info.t option = - All_types.find_type_by_path_aux p ~pkgs:env.pkg_tbl - ~builtin_types:env.builtin_types ~toplevel_types:env.toplevel_types - -let type_not_found_error (env : t) (p : Type_path.t) ~creating_value ~loc : - Local_diagnostics.report = - let pkg = Type_path.get_pkg p in - if - pkg <> !Basic_config.current_package - && Option.is_none (Pkg.find_pkg_opt (get_pkg_tbl env) ~pkg) - then - let action = if creating_value then "create value" else "destruct value" in - Errors.pkg_not_imported ~name:pkg - ~action:(action ^ " of type " ^ Type_path_util.name p : Stdlib.String.t) - ~loc - else Errors.type_not_found ~tycon:(Type_path_util.name p) ~loc - -let get_newtype_info (env : t) (ty : Stype.t) : - Typedecl_info.newtype_info option = - let ty = Stype.type_repr ty in - match ty with - | T_constr { type_constructor = p; _ } -> ( - match find_type_by_path env p with - | Some { ty_desc = New_type info; _ } -> Some info - | _ -> None) - | _ -> None - -let is_newtype (env : t) (ty : Stype.t) : bool = - Option.is_some (get_newtype_info env ty) - -let find_trait_by_path (env : t) (p : Type_path.t) : Trait_decl.t option = - All_types.find_trait_by_path_aux ~pkgs:env.pkg_tbl - ~toplevel_types:env.toplevel_types ~builtin_types:env.builtin_types p - -let find_methods_by_name (env : t) ~method_name = - match Method_env.find_methods_by_name env.method_env ~method_name with - | [] -> ( - match - Pkg.find_methods_by_name env.pkg_tbl ~pkg:Basic_config.builtin_package - ~method_name - with - | ms -> ms) - | ms -> ms +let get_all_types (env : t) = + ({ + builtin = env.builtin_types; + toplevel = env.toplevel_types; + type_alias = env.type_alias; + pkgs = env.pkg_tbl; + } + : All_types.t) + +let unknown_value id = + (Toplevel_value + { + id; + typ = Stype.new_type_var Tvar_error; + pub = false; + kind = Normal; + loc_ = Loc.no_location; + doc_ = Docstring.empty; + attrs = []; + ty_params_ = Tvar_env.empty; + arity_ = None; + param_names_ = []; + direct_use_loc_ = Not_direct_use; + } + : Value_info.t) + +let find_type_alias (env : t) (x : Longident.t) = + (All_types.find_type_alias_aux ~pkgs:env.pkg_tbl ~type_alias:env.type_alias x + : Type_alias.t option) + +let find_type_by_path (env : t) (p : Type_path.t) = + (All_types.find_type_by_path_aux p ~pkgs:env.pkg_tbl + ~builtin_types:env.builtin_types ~toplevel_types:env.toplevel_types + : Typedecl_info.t option) + +let type_not_found_error (env : t) (p : Type_path.t) ~creating_value ~loc = + (let pkg = Type_path.get_pkg p in + if + pkg <> !Basic_config.current_package + && + match Pkg.find_pkg_opt (get_pkg_tbl env) ~pkg with + | None -> true + | _ -> false + then + let action = if creating_value then "create value" else "destruct value" in + Errors.pkg_not_imported ~name:pkg + ~action:(action ^ " of type " ^ Type_path_util.name p : Stdlib.String.t) + ~loc + else Errors.type_not_found ~tycon:(Type_path_util.name p) ~loc + : Local_diagnostics.error) + +let get_newtype_info (env : t) (ty : Stype.t) = + (let find_local_newtype_info toplevel_id name = + let find_in_local_env env name = + match Local_type.find_type env name with + | Some { kind = Newtype info; _ } -> Some info + | _ -> None + [@@inline] + in + match env.cur_local_type_env with + | Some local_type_env -> find_in_local_env local_type_env name + | None -> ( + match + Qual_ident_hash.find_opt env.all_local_type_env + (Qual_ident.from_toplevel_id toplevel_id) + with + | Some local_type_env -> find_in_local_env local_type_env name + | _ -> None) + [@@inline] + in + let ty = Stype.type_repr ty in + match ty with + | T_constr { type_constructor = p; _ } -> ( + match p with + | T_local { toplevel_id; name } -> + find_local_newtype_info toplevel_id name + | _ -> ( + match find_type_by_path env p with + | Some { ty_desc = New_type info; _ } -> Some info + | _ -> None)) + | _ -> None + : Typedecl_info.newtype_info option) + +let is_newtype (env : t) (ty : Stype.t) = + (match get_newtype_info env ty with Some _ -> true | _ -> false : bool) + +let find_trait_by_path (env : t) (p : Type_path.t) = + (All_types.find_trait_by_path_aux ~pkgs:env.pkg_tbl + ~toplevel_types:env.toplevel_types ~builtin_types:env.builtin_types p + : Trait_decl.t option) let find_dot_method (env : t) ~(type_name : Type_path.t) ~(method_name : string) = @@ -396,21 +420,21 @@ let find_dot_method (env : t) ~(type_name : Type_path.t) ~(method_name : string) match Method_env.find_method_opt env.method_env ~type_name ~method_name with - | Some (Impl mis) -> mis - | None | Some (Regular _) -> [] + | Some (Only_impl mis) -> mis + | None | Some (Has_regular _) -> [] else [] [@@local] in match find_method_in_pkg pkg with - | Some (Regular mi) -> [ mi ] - | Some (Impl mis) -> + | Some (Has_regular { regular; impls = _ }) -> [ regular ] + | Some (Only_impl mis) -> if pkg <> Basic_config.builtin_package && Type_path.can_be_extended_from_builtin type_name then match find_method_in_pkg Basic_config.builtin_package with - | Some (Regular mi) -> [ mi ] - | Some (Impl mis') -> mis @ mis' + | Some (Has_regular { regular; impls = _ }) -> [ regular ] + | Some (Only_impl mis') -> mis @ mis' | None -> mis else mis | None -> @@ -419,8 +443,8 @@ let find_dot_method (env : t) ~(type_name : Type_path.t) ~(method_name : string) && Type_path.can_be_extended_from_builtin type_name then match find_method_in_pkg Basic_config.builtin_package with - | Some (Regular mi) -> [ mi ] - | Some (Impl mis) -> mis + | Some (Has_regular { regular; impls = _ }) -> [ regular ] + | Some (Only_impl mis) -> mis | None -> find_local_extension () else find_local_extension () @@ -490,194 +514,197 @@ let find_trait_impl (env : t) ~(trait : Type_path.t) ~(type_name : Type_path.t) | Some _ as result -> result | None -> find_in_builtin ()) -let find_value (env : t) (x : Longident.t) ~(loc : Rloc.t) : - Value_info.t Local_diagnostics.partial_info = - match x with - | Lident id -> ( - match Typing_info.find_value env.toplevel_values id with - | Some v -> Ok (Toplevel_value v) - | None -> ( - match - Pkg.find_value ~allow_method:false env.pkg_tbl - { pkg = Basic_config.builtin_package; id } - ~loc - with - | Ok vd -> Ok vd - | Error _ -> ( - match find_methods_by_name env ~method_name:id with - | (_, m) :: [] -> Ok (Method_env.to_value_info m) - | [] -> - let id = - Qual_ident.make ~pkg:!Basic_config.current_package ~name:id - in - Partial - (unknown_value id, [ Errors.unbound_value ~name:x ~loc ]) - | ms -> - let type_locs = - Lst.map ms (fun (type_name, m) -> (type_name, m.loc)) - in - let error = - Errors.ambiguous_method ~name:id ~type_locs ~loc - in - let id = - Qual_ident.make ~pkg:!Basic_config.current_package ~name:id - in - Partial (unknown_value id, [ error ])))) - | Ldot qual_name -> ( - match Pkg.find_value ~allow_method:true env.pkg_tbl qual_name ~loc with - | Ok vd -> Ok vd - | Error err -> - let id = Qual_ident.make ~pkg:qual_name.pkg ~name:qual_name.id in - Partial (unknown_value id, [ err ])) - -let find_value_by_qual_name (env : t) (q : Qual_ident.t) : Value_info.t option = - match q with - | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> - if pkg = !Basic_config.current_package then - match Typing_info.find_value env.toplevel_values name with - | Some v -> Some (Toplevel_value v) - | None -> None - else Pkg.find_regular_value env.pkg_tbl ~pkg name - | Qmethod { self_typ; name } -> ( - let pkg = Type_path.get_pkg self_typ in - let result = - if - pkg = !Basic_config.current_package - || !Basic_config.current_package = Basic_config.builtin_package - then - match - Method_env.find_regular_method env.method_env ~type_name:self_typ - ~method_name:name - with - | Some mi -> Some (Method_env.to_value_info mi) - | None -> None - else - Pkg.find_regular_method env.pkg_tbl ~pkg ~type_name:self_typ - ~method_name:name - |> Option.map Method_env.to_value_info - in - match result with - | Some _ -> result - | None -> ( - match - Pkg.find_regular_method env.pkg_tbl - ~pkg:Basic_config.builtin_package ~type_name:self_typ - ~method_name:name - with - | Some mi -> Some (Method_env.to_value_info mi) - | None -> None)) - | Qext_method { trait; self_typ; name } -> ( - let pkg_of_trait = Type_path.get_pkg trait in - let pkg_of_type = Type_path.get_pkg self_typ in - let find_ext_method pkg = - if pkg = !Basic_config.current_package then - Ext_method_env.find_method env.ext_method_env ~trait - ~self_type:self_typ ~method_name:name - else - Pkg.find_ext_method_opt env.pkg_tbl ~pkg ~trait ~self_type:self_typ - ~method_name:name - [@@inline] - in - match find_ext_method pkg_of_trait with - | Some mi -> Some (Method_env.to_value_info mi) - | None -> - if String.equal pkg_of_trait pkg_of_type then None - else - find_ext_method pkg_of_type |> Option.map Method_env.to_value_info) - -let find_constructor_or_constant (env : t) (x : string) ~loc : - [ `Constr of Typedecl_info.constructor | `Constant of Value_info.toplevel ] - Local_diagnostics.info = - let ambiguous_error (c1 : Typedecl_info.constructor) - (c2 : Typedecl_info.constructor) = - let first_ty = - c1.cs_res |> Stype.extract_tpath_exn |> Type_path_util.name - in - let second_ty = - c2.cs_res |> Stype.extract_tpath_exn |> Type_path_util.name - in - Error (Errors.ambiguous_constructor ~name:x ~first_ty ~second_ty ~loc) - [@@local] - in - match Typing_info.find_constructor env.toplevel_values x with - | constr :: [] -> Ok (`Constr constr) - | c1 :: c2 :: _ -> ambiguous_error c1 c2 - | [] -> ( - match Typing_info.find_value env.toplevel_values x with - | Some c -> Ok (`Constant c) - | None -> ( - match - Pkg.find_constructor_or_constant env.pkg_tbl - ~pkg:Basic_config.builtin_package x ~loc - with - | Ok _ as result -> result - | Error _ -> ( - match Typing_info.find_constructor env.builtin_values x with - | constr :: [] -> Ok (`Constr constr) - | c1 :: c2 :: _ -> ambiguous_error c1 c2 - | [] -> Error (Errors.constr_not_found ~ty:None ~constr:x ~loc)))) - -let try_pick_field (env : t) (x : string) : Typedecl_info.field option = - match Typing_info.find_field env.toplevel_values x with - | Some _ as result -> result - | None -> Typing_info.find_field env.builtin_values x +let find_value (env : t) (x : Longident.t) ~(loc : Rloc.t) ~diagnostics = + (match x with + | Lident id -> ( + match Typing_info.find_value env.toplevel_values id with + | Some v -> Toplevel_value v + | None -> ( + match Pkg.find_value_in_builtin_package env.pkg_tbl id with + | Some vd -> vd + | None -> + let id = + Qual_ident.make ~pkg:!Basic_config.current_package ~name:id + in + Local_diagnostics.add_error diagnostics + (Errors.unbound_value ~name:x ~loc); + unknown_value id)) + | Ldot qual_name -> ( + match Pkg.find_value env.pkg_tbl qual_name ~loc ~diagnostics with + | Some vd -> vd + | None -> + let id = Qual_ident.make ~pkg:qual_name.pkg ~name:qual_name.id in + unknown_value id) + : Value_info.t) + +let find_value_by_qual_name (env : t) (q : Qual_ident.t) = + (match q with + | Qregular { pkg; name } | Qregular_implicit_pkg { pkg; name } -> + if pkg = !Basic_config.current_package then + match Typing_info.find_value env.toplevel_values name with + | Some v -> Some (Toplevel_value v) + | None -> None + else Pkg.find_regular_value env.pkg_tbl ~pkg name + | Qmethod { self_typ; name } -> ( + let pkg = Type_path.get_pkg self_typ in + let result = + if + pkg = !Basic_config.current_package + || !Basic_config.current_package = Basic_config.builtin_package + then + match + Method_env.find_regular_method env.method_env ~type_name:self_typ + ~method_name:name + with + | Some mi -> Some (Method_env.to_value_info mi) + | None -> None + else + Option.map Method_env.to_value_info + (Pkg.find_regular_method env.pkg_tbl ~pkg ~type_name:self_typ + ~method_name:name) + in + match result with + | Some _ -> result + | None -> ( + match + Pkg.find_regular_method env.pkg_tbl + ~pkg:Basic_config.builtin_package ~type_name:self_typ + ~method_name:name + with + | Some mi -> Some (Method_env.to_value_info mi) + | None -> None)) + | Qext_method { trait; self_typ; name } -> ( + let pkg_of_trait = Type_path.get_pkg trait in + let pkg_of_type = Type_path.get_pkg self_typ in + let find_ext_method pkg = + if pkg = !Basic_config.current_package then + Ext_method_env.find_method env.ext_method_env ~trait + ~self_type:self_typ ~method_name:name + else + Pkg.find_ext_method_opt env.pkg_tbl ~pkg ~trait ~self_type:self_typ + ~method_name:name + [@@inline] + in + match find_ext_method pkg_of_trait with + | Some mi -> Some (Method_env.to_value_info mi) + | None -> + if String.equal pkg_of_trait pkg_of_type then None + else + Option.map Method_env.to_value_info (find_ext_method pkg_of_type)) + : Value_info.t option) + +let find_constructor_or_constant (env : t) (x : string) ~loc = + (let ambiguous_error (c1 : Typedecl_info.constructor) + (c2 : Typedecl_info.constructor) = + let first_ty = Type_path_util.name (Stype.extract_tpath_exn c1.cs_res) in + let second_ty = Type_path_util.name (Stype.extract_tpath_exn c2.cs_res) in + Error (Errors.ambiguous_constructor ~name:x ~first_ty ~second_ty ~loc) + [@@local] + in + let find_toplevel_constructor_or_constant () = + match Typing_info.find_constructor env.toplevel_values x with + | constr :: [] -> Ok (`Constr constr) + | c1 :: c2 :: _ -> ambiguous_error c1 c2 + | [] -> ( + match Typing_info.find_value env.toplevel_values x with + | Some c -> Ok (`Constant c) + | None -> ( + match + Pkg.find_constructor_or_constant env.pkg_tbl + ~pkg:Basic_config.builtin_package x ~loc + with + | Ok _ as result -> result + | Error _ -> ( + match Typing_info.find_constructor env.builtin_values x with + | constr :: [] -> Ok (`Constr constr) + | c1 :: c2 :: _ -> ambiguous_error c1 c2 + | [] -> Error (Errors.constr_not_found ~ty:None ~constr:x ~loc) + ))) + [@@local] + in + match env.cur_local_type_env with + | Some local_type_env -> ( + match Local_type.find_constr local_type_env x with + | constr :: [] -> Ok (`Constr constr) + | c1 :: c2 :: _ -> ambiguous_error c1 c2 + | [] -> find_toplevel_constructor_or_constant ()) + | None -> find_toplevel_constructor_or_constant () + : [ `Constr of Typedecl_info.constructor | `Constant of Value_info.toplevel ] + Local_diagnostics.info) + +let try_pick_field (env : t) (x : string) = + (match Typing_info.find_field env.toplevel_values x with + | Some _ as result -> result + | None -> Typing_info.find_field env.builtin_values x + : Typedecl_info.field option) let labels_of_record (env : t) (ty : Stype.t) ~loc - ~(context : [ `Create | `Update | `Pattern ]) : - Typedecl_info.fields Local_diagnostics.info = - let ty = Stype.type_repr ty in - let not_a_record kind = - Error - (Errors.not_a_record ~may_be_method:None - ~ty:(Printer.type_to_string ty) - ~kind ~loc) - in - match ty with - | T_constr { type_constructor = Tuple _; _ } -> not_a_record "tuple" - | T_constr { type_constructor = p; _ } -> ( - match find_type_by_path env p with - | Some type_info -> ( - match type_info.ty_desc with - | Record_type { fields = fs; has_private_field_ } -> - if Stype.is_external ty then - match (type_info.ty_vis, context) with - | Vis_readonly, (`Create | `Update) -> - let name = Type_path_util.name p in - Error (Errors.readonly_type ~name ~loc) - | Vis_fully_pub, `Create when has_private_field_ -> - let name = Type_path_util.name p in - Error - (Errors.cannot_create_struct_with_priv_field ~name ~loc) - | (Vis_fully_pub | Vis_readonly), _ -> Ok fs - | (Vis_default | Vis_priv), _ -> assert false - else Ok fs - | Error_type _ | ErrorEnum_type _ -> not_a_record "error type" - | New_type _ -> not_a_record "newtype" - | Variant_type _ -> not_a_record "variant" - | Extern_type | Abstract_type -> not_a_record "abstract") - | None -> - let creating_value = - match context with `Create | `Update -> true | `Pattern -> false - in - Error (type_not_found_error env p ~creating_value ~loc)) - | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> - Error Errors.swallow_error - | Tvar _ -> not_a_record "unknown" - | Tarrow _ -> not_a_record "function" - | Tparam _ -> not_a_record "type parameter" - | T_trait _ -> not_a_record "trait" - | T_builtin T_unit -> not_a_record "unit" - | T_builtin T_bool -> not_a_record "bool" - | T_builtin T_byte -> not_a_record "byte" - | T_builtin T_char -> not_a_record "char" - | T_builtin T_int -> not_a_record "int" - | T_builtin T_int64 -> not_a_record "int64" - | T_builtin T_uint -> not_a_record "uint" - | T_builtin T_uint64 -> not_a_record "uint64" - | T_builtin T_float -> not_a_record "float" - | T_builtin T_double -> not_a_record "double" - | T_builtin T_string -> not_a_record "string" - | T_builtin T_bytes -> not_a_record "bytes" + ~(context : [ `Create | `Update | `Pattern ]) = + (let ty = Stype.type_repr ty in + let not_a_record kind = + Error + (Errors.not_a_record ~may_be_method:None + ~ty:(Printer.type_to_string ty) + ~kind ~loc) + in + match ty with + | T_constr { type_constructor = Tuple _; _ } -> not_a_record "tuple" + | T_constr { type_constructor = T_local { name; _ }; _ } -> ( + match[@warning "-fragile-match"] env.cur_local_type_env with + | Some local_type_env -> ( + match Local_type.find_type local_type_env name with + | Some { kind = Struct fs; _ } -> Ok fs + | Some { kind = Enum _; _ } -> not_a_record "enum" + | Some { kind = Newtype _; _ } -> not_a_record "newtype" + | Some { kind = Placeholder; _ } | None -> assert false) + | _ -> assert false) + | T_constr { type_constructor = p; _ } -> ( + match find_type_by_path env p with + | Some type_info -> ( + match type_info.ty_desc with + | Record_type { fields = fs; has_private_field_ } -> + if Stype.is_external ty then + match (type_info.ty_vis, context) with + | Vis_readonly, (`Create | `Update) -> + let name = Type_path_util.name p in + Error (Errors.readonly_type ~name ~loc) + | Vis_fully_pub, `Create when has_private_field_ -> + let name = Type_path_util.name p in + Error + (Errors.cannot_create_struct_with_priv_field ~name ~loc) + | (Vis_fully_pub | Vis_readonly), _ -> Ok fs + | (Vis_default | Vis_priv), _ -> assert false + else Ok fs + | Error_type _ | ErrorEnum_type _ -> not_a_record "error type" + | New_type _ -> not_a_record "newtype" + | Variant_type _ -> not_a_record "variant" + | Extern_type | Abstract_type -> not_a_record "abstract") + | None -> + let creating_value = + match context with `Create | `Update -> true | `Pattern -> false + in + Error (type_not_found_error env p ~creating_value ~loc)) + | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> + Error Errors.swallow_error + | Tvar _ -> not_a_record "unknown" + | Tarrow _ -> not_a_record "function" + | Tparam _ -> not_a_record "type parameter" + | T_trait _ -> not_a_record "trait" + | T_builtin T_unit -> not_a_record "Unit" + | T_builtin T_bool -> not_a_record "Bool" + | T_builtin T_byte -> not_a_record "Byte" + | T_builtin T_int16 -> not_a_record "Int16" + | T_builtin T_uint16 -> not_a_record "Uint16" + | T_builtin T_char -> not_a_record "Char" + | T_builtin T_int -> not_a_record "Int" + | T_builtin T_int64 -> not_a_record "Int64" + | T_builtin T_uint -> not_a_record "Uint" + | T_builtin T_uint64 -> not_a_record "Uint64" + | T_builtin T_float -> not_a_record "Float" + | T_builtin T_double -> not_a_record "Double" + | T_builtin T_string -> not_a_record "String" + | T_builtin T_bytes -> not_a_record "Bytes" + : Typedecl_info.fields Local_diagnostics.info) let constrs_of_typedecl_info (td : Typedecl_info.t) ~loc ~error_ty = let not_a_variant kind = @@ -691,137 +718,123 @@ let constrs_of_typedecl_info (td : Typedecl_info.t) ~loc ~error_ty = | Record_type _ -> not_a_variant "record" | Extern_type | Abstract_type -> not_a_variant "abstract" -let constrs_of_variant (env : t) (ty : Stype.t) ~loc ~creating_value : - Typedecl_info.constructors Local_diagnostics.info = - let ty = Stype.type_repr ty in - let not_a_variant kind = - Error (Errors.not_a_variant ~ty:(Printer.type_to_string ty) ~kind ~loc) - in - match ty with - | T_constr { type_constructor = Tuple _; _ } -> not_a_variant "tuple" - | T_constr { type_constructor = p; _ } -> ( - match find_type_by_path env p with - | Some type_info -> - constrs_of_typedecl_info type_info ~loc ~error_ty:(fun () -> - Printer.type_to_string ty) - | None -> Error (type_not_found_error env p ~creating_value ~loc)) - | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> - Error Errors.swallow_error - | Tvar _ -> not_a_variant "unknown" - | Tarrow _ -> not_a_variant "function" - | Tparam _ -> not_a_variant "type parameter" - | T_trait _ -> not_a_variant "trait" - | T_builtin T_unit -> not_a_variant "unit" - | T_builtin T_bool -> not_a_variant "bool" - | T_builtin T_byte -> not_a_variant "byte" - | T_builtin T_char -> not_a_variant "char" - | T_builtin T_int -> not_a_variant "int" - | T_builtin T_int64 -> not_a_variant "int64" - | T_builtin T_uint -> not_a_variant "uint" - | T_builtin T_uint64 -> not_a_variant "uint64" - | T_builtin T_float -> not_a_variant "float" - | T_builtin T_double -> not_a_variant "double" - | T_builtin T_string -> not_a_variant "string" - | T_builtin T_bytes -> not_a_variant "bytes" - -let resolve_record (env : t) ~(labels : Syntax.label list) ~loc : - (Tvar_env.t * Stype.t * Typedecl_info.fields) Local_diagnostics.info = - let x = List.hd labels in - let all_possibles = - List.append - (Typing_info.find_all_fields env.toplevel_values x.label_name) - (Typing_info.find_all_fields env.builtin_values x.label_name) - in - match all_possibles with - | [] -> Error (Errors.unbound_field ~name:x.label_name ~loc:x.loc_) - | _ -> ( - let check_field_desc (field_desc : Typedecl_info.field) = - let all_labels = field_desc.all_labels in - Lst.same_length all_labels labels - && Lst.for_all labels (fun label -> - Lst.exists all_labels (fun label' -> label' = label.label_name)) - in - match Lst.filter all_possibles check_field_desc with - | [] -> - Error - (Errors.cannot_resolve_record - ~labels:(Lst.map labels (fun l -> l.label_name)) - ~loc) - | field_desc :: [] -> ( - let ty_record = field_desc.ty_record in - match ty_record with - | T_constr { type_constructor = p; _ } -> ( - match find_type_by_path env p with - | Some - { ty_desc = Record_type { has_private_field_ = true; _ }; _ } - when Type_path_util.is_foreign p -> - let name = Type_path_util.name p in - Error (Errors.cannot_create_struct_with_priv_field ~name ~loc) - | Some { ty_desc = Record_type { fields }; _ } -> - Ok (field_desc.ty_params_, ty_record, fields) - | _ -> assert false) - | _ -> assert false) - | field_descs -> - let extract_name (fd : Typedecl_info.field) = - match fd.ty_record with - | T_constr { type_constructor; _ } -> - Type_path_util.name type_constructor - | _ -> assert false - in - Error - (Errors.ambiguous_record - ~names:(Lst.map field_descs extract_name) - ~loc)) - -let resolve_constr_or_constant (env : t) ~(expect_ty : Stype.t option) - ~(constr : Syntax.constructor) ~(creating_value : bool) : - [ `Constr of Typedecl_info.constructor | `Constant of Value_info.toplevel ] - Local_diagnostics.info = - let ({ constr_name; extra_info; loc_ = loc } : Syntax.constructor) = constr in - let find_constr (fs : Typedecl_info.constructors) ty_str is_external : - _ Local_diagnostics.info = - match Lst.find_first fs (fun f -> f.constr_name = constr_name.name) with - | Some f -> - if creating_value && is_external && f.cs_vis <> Read_write then - Error (Errors.readonly_type ~name:f.constr_name ~loc) - else Ok (`Constr f) - | None -> - Error - (Errors.constr_not_found ~constr:constr_name.name - ~ty:(Some (ty_str ())) - ~loc) - in - match extra_info with - | Type_name { name } -> ( - match find_type env name ~loc with - | Ok type_info -> ( - match - constrs_of_typedecl_info type_info ~loc ~error_ty:(fun () -> - Longident.to_string name) - with - | Ok fs -> - find_constr fs - (fun () -> Longident.to_string name) - (Type_path_util.is_foreign type_info.ty_constr) - | Error _ as err -> err) - | Error _ as err -> err) - | No_extra_info -> ( - match Option.map Stype.type_repr expect_ty with - | None | Some (Tvar _) -> - find_constructor_or_constant env constr_name.name ~loc - | Some ty when Type.is_super_error ty -> - find_constructor_or_constant env constr_name.name ~loc - | Some (T_builtin _) -> - find_constructor_or_constant env constr_name.name ~loc - | Some ty -> ( - match constrs_of_variant env ty ~loc ~creating_value with - | Ok fs -> - find_constr fs - (fun () -> Printer.type_to_string ty) - (Stype.is_external ty) - | Error _ as err -> err)) - | Package pkg -> - Pkg.find_constructor_or_constant env.pkg_tbl ~pkg constr_name.name ~loc +let constrs_of_variant (env : t) (ty : Stype.t) ~loc ~creating_value = + (let ty = Stype.type_repr ty in + let not_a_variant kind = + Error (Errors.not_a_variant ~ty:(Printer.type_to_string ty) ~kind ~loc) + in + match ty with + | T_constr { type_constructor = Tuple _; _ } -> not_a_variant "tuple" + | T_constr { type_constructor = T_local { name; toplevel_id }; _ } -> ( + let local_type_env = + match env.cur_local_type_env with + | Some local_type_env -> local_type_env + | None -> + Qual_ident_hash.find_exn env.all_local_type_env + (Qual_ident.from_toplevel_id toplevel_id) + in + match Local_type.find_type local_type_env name with + | Some { kind = Enum cs; _ } -> Ok cs + | Some { kind = Struct _; _ } -> not_a_variant "struct" + | Some { kind = Newtype { newtype_constr; _ }; _ } -> + Ok [ newtype_constr ] + | Some { kind = Placeholder; _ } | None -> assert false) + | T_constr { type_constructor = p; _ } -> ( + match find_type_by_path env p with + | Some type_info -> + constrs_of_typedecl_info type_info ~loc ~error_ty:(fun () -> + Printer.type_to_string ty) + | None -> Error (type_not_found_error env p ~creating_value ~loc)) + | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> + Error Errors.swallow_error + | Tvar _ -> not_a_variant "unknown" + | Tarrow _ -> not_a_variant "function" + | Tparam _ -> not_a_variant "type parameter" + | T_trait _ -> not_a_variant "trait" + | T_builtin T_unit -> not_a_variant "unit" + | T_builtin T_bool -> not_a_variant "bool" + | T_builtin T_byte -> not_a_variant "byte" + | T_builtin T_int16 -> not_a_variant "int16" + | T_builtin T_uint16 -> not_a_variant "uint16" + | T_builtin T_char -> not_a_variant "char" + | T_builtin T_int -> not_a_variant "int" + | T_builtin T_int64 -> not_a_variant "int64" + | T_builtin T_uint -> not_a_variant "uint" + | T_builtin T_uint64 -> not_a_variant "uint64" + | T_builtin T_float -> not_a_variant "Float" + | T_builtin T_double -> not_a_variant "double" + | T_builtin T_string -> not_a_variant "string" + | T_builtin T_bytes -> not_a_variant "bytes" + : Typedecl_info.constructors Local_diagnostics.info) + +let resolve_record (env : t) ~(labels : Syntax.label list) ~loc = + (let first_label = List.hd labels in + let first_label_name = first_label.label_name in + let all_possibles = + List.append + (Typing_info.find_all_fields env.toplevel_values first_label_name) + (Typing_info.find_all_fields env.builtin_values first_label_name) + in + let all_possibles = + match env.cur_local_type_env with + | Some local_type_env -> + List.append + (Local_type.find_field local_type_env first_label_name) + all_possibles + | None -> all_possibles + in + match all_possibles with + | [] -> + Error (Errors.unbound_field ~name:first_label_name ~loc:first_label.loc_) + | _ -> ( + let check_field_desc (field_desc : Typedecl_info.field) = + let all_labels = field_desc.all_labels in + Lst.same_length all_labels labels + && Lst.for_all labels (fun label -> + Lst.exists all_labels (fun label' -> label' = label.label_name)) + in + match Lst.filter all_possibles check_field_desc with + | [] -> + Error + (Errors.cannot_resolve_record + ~labels:(Lst.map labels (fun l -> l.label_name)) + ~loc) + | field_desc :: [] -> ( + let ty_record = field_desc.ty_record in + match ty_record with + | T_constr + { type_constructor = T_local { toplevel_id = _; name }; _ } -> ( + match[@warning "-fragile-match"] env.cur_local_type_env with + | Some local_type_env -> ( + match Local_type.find_type local_type_env name with + | Some { kind = Struct fields; _ } -> + Ok (field_desc.ty_params_, ty_record, fields) + | _ -> assert false) + | _ -> assert false) + | T_constr { type_constructor = p; _ } -> ( + match find_type_by_path env p with + | Some + { ty_desc = Record_type { has_private_field_ = true; _ }; _ } + when Type_path_util.is_foreign p -> + let name = Type_path_util.name p in + Error + (Errors.cannot_create_struct_with_priv_field ~name ~loc) + | Some { ty_desc = Record_type { fields }; _ } -> + Ok (field_desc.ty_params_, ty_record, fields) + | _ -> assert false) + | _ -> assert false) + | field_descs -> + let extract_name (fd : Typedecl_info.field) = + match fd.ty_record with + | T_constr { type_constructor; _ } -> + Type_path_util.name type_constructor + | _ -> assert false + in + Error + (Errors.ambiguous_record + ~names:(Lst.map field_descs extract_name) + ~loc)) + : (Tvar_env.t * Stype.t * Typedecl_info.fields) Local_diagnostics.info) let export_mi (env : t) ~action ~pkg_name = Mi_format.export_mi ~action ~pkg_name ~types:env.toplevel_types @@ -829,5 +842,97 @@ let export_mi (env : t) ~action ~pkg_name = ~method_env:env.method_env ~ext_method_env:env.ext_method_env ~trait_impls:env.trait_impls -let report_unused_pkg ~diagnostics (global_env : t) : unit = - Pkg.report_unused ~diagnostics global_env.pkg_tbl +let report_unused_pkg ~diagnostics (global_env : t) = + (Pkg.report_unused ~diagnostics global_env.pkg_tbl : unit) + +let add_new_local_type_env (env : t) (toplevel_id : Qual_ident.t) base = + let local_type_env = Local_type.empty_env base in + env.cur_local_type_env <- Some local_type_env; + Qual_ident_hash.add env.all_local_type_env toplevel_id local_type_env + +let get_cur_local_type_env (env : t) = env.cur_local_type_env +let clear_cur_local_type_env (env : t) = env.cur_local_type_env <- None + +let add_local_type (env : t) (local_type : Local_type.t) = + match[@warning "-fragile-match"] env.cur_local_type_env with + | Some local_type_env -> Local_type.add_type local_type_env local_type + | _ -> assert false + +let find_local_type (env : t) (name : string) = + (match env.cur_local_type_env with + | None -> None + | Some local_type_env -> Local_type.find_type local_type_env name + : Local_type.t option) + +let update_local_type (env : t) (local_type : Local_type.t) = + match env.cur_local_type_env with + | None -> () + | Some local_type_env -> Local_type.update_type local_type_env local_type + +let add_local_field (env : t) (field : Local_type.field) = + match env.cur_local_type_env with + | None -> () + | Some local_type_env -> Local_type.add_field local_type_env field + +let add_local_constr (env : t) (constructor : Local_type.constructor) = + match env.cur_local_type_env with + | None -> () + | Some local_type_env -> Local_type.add_constr local_type_env constructor + +let all_local_types (env : t) = + let acc = Basic_vec.empty () in + Qual_ident_hash.iter2 env.all_local_type_env (fun _ -> + fun local_type_env -> + let base = Local_type.get_base_loc local_type_env in + Local_type.iter_types local_type_env (fun name -> + fun t -> + Basic_vec.push acc + ( Local_type.mangle_name t.toplevel_id name, + Local_type.to_generic_typedecl_info base t ))); + Basic_vec.to_array acc + +let find_all_type_by_path (env : t) (p : Type_path.t) = + (match p with + | T_local { toplevel_id; name } -> ( + match + Qual_ident_hash.find_opt env.all_local_type_env + (Qual_ident.from_toplevel_id toplevel_id) + with + | None -> None + | Some local_type_env -> + Option.map + (Local_type.to_generic_typedecl_info + (Local_type.get_base_loc local_type_env)) + (Local_type.find_type local_type_env name)) + | _ -> + All_types.find_type_by_path_aux p ~pkgs:env.pkg_tbl + ~builtin_types:env.builtin_types ~toplevel_types:env.toplevel_types + : Typedecl_info.t option) + +let find_local_type_env (env : t) (id : Qual_ident.t) = + (Qual_ident_hash.find_opt env.all_local_type_env id : Local_type.env option) + +let find_all_local_type (env : t) (id : Qual_ident.t) (name : string) = + (match find_local_type_env env id with + | None -> None + | Some local_type_env -> Local_type.find_type local_type_env name + : Local_type.t option) + +let get_all_local_type (env : t) (id : Qual_ident.t) = + (match find_local_type_env env id with + | None -> [] + | Some local_type_env -> + let names = Basic_vec.empty () in + Local_type.iter_types local_type_env (fun name -> + fun _ -> Basic_vec.push names name); + Basic_vec.to_list names + : string list) + +let add_local_type_after_typing (env : t) (local_type : Local_type.t) = + let id = Qual_ident.from_toplevel_id local_type.toplevel_id in + match Qual_ident_hash.find_opt env.all_local_type_env id with + | None -> + let local_type_env = Local_type.empty_env Loc.no_location in + Qual_ident_hash.add env.all_local_type_env id local_type_env; + Local_type.add_type local_type_env local_type + | Some local_type_env -> Local_type.add_type local_type_env local_type diff --git a/src/grouped_typedefs.ml b/src/grouped_typedefs.ml index d4efa3b..b057d2a 100644 --- a/src/grouped_typedefs.ml +++ b/src/grouped_typedefs.ml @@ -70,67 +70,73 @@ include struct let _ = sexp_of_t end -let collect_ref (def : Ltype.def) : Tid_hashset.t = - let tid_set = Tid_hashset.create 17 in - let go (ltype : Ltype.t) = - match ltype with - | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> - if - not - (Tid.equal tid Ltype.tid_enum - || Tid.equal tid Ltype.tid_bytes - || Tid.equal tid Ltype.tid_string) - then Tid_hashset.add tid_set tid - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char | I64 | F32 | F64 | Ref_extern | Ref_string | Ref_bytes - | Ref_func | Ref_any -> - () - in - (match def with - | Ref_array { elem } -> go elem - | Ref_struct { fields } -> Lst.iter fields (fun (t, _) -> go t) - | Ref_late_init_struct { fields } -> Lst.iter fields go - | Ref_constructor { args } -> Lst.iter args (fun (t, _) -> go t) - | Ref_closure_abstract { fn_sig = { params; ret } } -> - Lst.iter params go; - Lst.iter ret go - | Ref_object { methods } -> - Lst.iter methods (fun { params; ret } -> - Lst.iter params go; - Lst.iter ret go) - | Ref_closure { fn_sig_tid = fn_tid; captures } -> - Tid_hashset.add tid_set fn_tid; - Lst.iter captures go); - tid_set +let collect_ref (def : Ltype.def) = + (let tid_set = Tid_hashset.create 17 in + let go (ltype : Ltype.t) = + match ltype with + | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> + if + not + (Tid.equal tid Ltype.tid_enum + || Tid.equal tid Ltype.tid_bytes + || Tid.equal tid Ltype.tid_string) + then Tid_hashset.add tid_set tid + | I32 _ | I64 | F32 | F64 | Ref_extern | Ref_string | Ref_bytes | Ref_func + | Ref_any -> + () + in + (match def with + | Ref_array { elem } -> go elem + | Ref_struct { fields } -> Lst.iter fields ~f:(fun (t, _) -> go t) + | Ref_late_init_struct { fields } -> Lst.iter fields ~f:go + | Ref_constructor { args } -> Lst.iter args ~f:(fun (t, _) -> go t) + | Ref_closure_abstract { fn_sig = { params; ret } } -> + Lst.iter params ~f:go; + Lst.iter ret ~f:go + | Ref_object { methods } -> + Lst.iter methods ~f:(fun { params; ret } -> + Lst.iter params ~f:go; + Lst.iter ret ~f:go) + | Ref_concrete_object { abstract_obj_tid; self } -> + Tid_hashset.add tid_set abstract_obj_tid; + go self + | Ref_closure { fn_sig_tid = fn_tid; captures } -> + Tid_hashset.add tid_set fn_tid; + Lst.iter captures ~f:go); + tid_set + : Tid_hashset.t) -let group_typedefs (td : Ltype.type_defs) : t = - let td_arr = Tid_hash.to_array td in - let index_tbl = Tid_hash.create 17 in - let self_rec_set = Tid_hashset.create 17 in - Array.iteri (fun i (tid, _def) -> Tid_hash.add index_tbl tid i) td_arr; - let adjacency_array = - Array.init (Array.length td_arr) (fun _ -> VI.empty ()) - in - let add_edge (def : Tid.t) (ref_ : Tid.t) = - let def_index = Tid_hash.find_exn index_tbl def in - let ref_index = Tid_hash.find_exn index_tbl ref_ in - VI.push adjacency_array.(def_index) ref_index - in - Array.iter - (fun (tid, def) -> - let ref_set = collect_ref def in - if Tid_hashset.mem ref_set tid then Tid_hashset.add self_rec_set tid; - Tid_hashset.iter ref_set (fun ref_ -> add_edge tid ref_)) - td_arr; - let scc = Basic_scc.graph adjacency_array in - let res = - Vec.map_into_list scc (fun component -> - if VI.length component = 1 then - let tid_index = VI.get component 0 in - let tid, def = td_arr.(tid_index) in - if Tid_hashset.mem self_rec_set tid then Rec [ (tid, def) ] - else Nonrec (tid, def) - else - Rec (VI.map_into_list component (fun tid_index -> td_arr.(tid_index)))) - in - res +let group_typedefs (td : Ltype.type_defs) = + (let td_arr = Tid_hash.to_array td in + let index_tbl = Tid_hash.create 17 in + let self_rec_set = Tid_hashset.create 17 in + Array.iteri (fun i -> fun (tid, _def) -> Tid_hash.add index_tbl tid i) td_arr; + let adjacency_array = + Array.init (Array.length td_arr) (fun _ -> VI.empty ()) + in + let add_edge (def : Tid.t) (ref_ : Tid.t) = + let def_index = Tid_hash.find_exn index_tbl def in + let ref_index = Tid_hash.find_exn index_tbl ref_ in + VI.push adjacency_array.(def_index) ref_index + in + Array.iter + (fun (tid, def) -> + let ref_set = collect_ref def in + if Tid_hashset.mem ref_set tid then Tid_hashset.add self_rec_set tid; + Tid_hashset.iter ref_set (fun ref_ -> add_edge tid ref_)) + td_arr; + let scc = Basic_scc.graph adjacency_array in + let res = + Vec.map_into_list scc ~unorder:(fun component -> + if VI.length component = 1 then + let tid_index = VI.get component 0 in + let tid, def = td_arr.(tid_index) in + if Tid_hashset.mem self_rec_set tid then Rec [ (tid, def) ] + else Nonrec (tid, def) + else + Rec + (VI.map_into_list component ~unorder:(fun tid_index -> + td_arr.(tid_index)))) + in + res + : t) diff --git a/src/hash.c b/src/hash.c index 08614ef..7ce2dcc 100755 --- a/src/hash.c +++ b/src/hash.c @@ -1,28 +1,20 @@ -/* The MIT License - - Copyright (c) 2016--2024 Jane Street Group, LLC - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in all - copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - SOFTWARE. -*/ - /* * Initially copied from [https://github.com/janestreet/base/blob/master/hash_types/src/internalhash_stubs.c] + * + * Original Copyright (c) 2016--2024 Jane Street Group, LLC under MIT License + * + * Modified and redistributed under: + * Copyright (C) 2024 International Digital Economy Academy. + * This program is licensed under the MoonBit Public Source + * License as published by the International Digital Economy Academy, + * either version 1 of the License, or (at your option) any later + * version. This program is distributed in the hope that it will be + * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + * Public Source License for more details. You should have received a + * copy of the MoonBit Public Source License along with this program. If + * not, see + * . */ #include @@ -34,11 +26,35 @@ #include #include + +/* This pretends that the state of the OCaml internal hash function, which is an + int32, is actually stored in an OCaml int. */ + +CAMLprim value Ppx_fold_int32(value st, value i) +{ + return Val_long(caml_hash_mix_uint32(Long_val(st), Int32_val(i))); +} + +CAMLprim value Ppx_fold_nativeint(value st, value i) +{ + return Val_long(caml_hash_mix_intnat(Long_val(st), Nativeint_val(i))); +} + +CAMLprim value Ppx_fold_int64(value st, value i) +{ + return Val_long(caml_hash_mix_int64(Long_val(st), Int64_val(i))); +} + CAMLprim value Ppx_fold_int(value st, value i) { return Val_long(caml_hash_mix_intnat(Long_val(st), Long_val(i))); } +CAMLprim value Ppx_fold_float(value st, value i) +{ + return Val_long(caml_hash_mix_double(Long_val(st), Double_val(i))); +} + /* This code mimics what hashtbl.hash does in OCaml's hash.c */ #define FINAL_MIX(h) \ h ^= h >> 16; \ @@ -108,6 +124,8 @@ CAMLprim value Ppx_fold_string(value st, value v_str) return Val_long(h); } + + /* Final mix and return from the hash.c implementation from INRIA */ #define FINAL_MIX_AND_RETURN(h) \ h ^= h >> 16; \ diff --git a/src/hashed_type.ml b/src/hashed_type.ml index e852641..340d11c 100644 --- a/src/hashed_type.ml +++ b/src/hashed_type.ml @@ -24,12 +24,15 @@ module Hashed_type = struct params : t list; ret : t; err : t option; + is_async : bool; } | Hparam of { hash : int; [@sexp_drop] index : int } | Htrait of { hash : int; trait : Type_path.t } | Hunit | Hbool | Hbyte + | Hint16 + | Huint16 | Hchar | Hint | Hint64 @@ -70,8 +73,14 @@ module Hashed_type = struct params = params__011_; ret = ret__013_; err = err__015_; + is_async = is_async__017_; } -> let bnds__008_ = ([] : _ Stdlib.List.t) in + let bnds__008_ = + let arg__018_ = Moon_sexp_conv.sexp_of_bool is_async__017_ in + (S.List [ S.Atom "is_async"; arg__018_ ] :: bnds__008_ + : _ Stdlib.List.t) + in let bnds__008_ = let arg__016_ = Moon_sexp_conv.sexp_of_option sexp_of_t err__015_ @@ -97,35 +106,37 @@ module Hashed_type = struct : _ Stdlib.List.t) in S.List (S.Atom "Harrow" :: bnds__008_) - | Hparam { hash = hash__018_; index = index__020_ } -> - let bnds__017_ = ([] : _ Stdlib.List.t) in - let bnds__017_ = - let arg__021_ = Moon_sexp_conv.sexp_of_int index__020_ in - (S.List [ S.Atom "index"; arg__021_ ] :: bnds__017_ + | Hparam { hash = hash__020_; index = index__022_ } -> + let bnds__019_ = ([] : _ Stdlib.List.t) in + let bnds__019_ = + let arg__023_ = Moon_sexp_conv.sexp_of_int index__022_ in + (S.List [ S.Atom "index"; arg__023_ ] :: bnds__019_ : _ Stdlib.List.t) in - let bnds__017_ = - let arg__019_ = Moon_sexp_conv.sexp_of_int hash__018_ in - (S.List [ S.Atom "hash"; arg__019_ ] :: bnds__017_ + let bnds__019_ = + let arg__021_ = Moon_sexp_conv.sexp_of_int hash__020_ in + (S.List [ S.Atom "hash"; arg__021_ ] :: bnds__019_ : _ Stdlib.List.t) in - S.List (S.Atom "Hparam" :: bnds__017_) - | Htrait { hash = hash__023_; trait = trait__025_ } -> - let bnds__022_ = ([] : _ Stdlib.List.t) in - let bnds__022_ = - let arg__026_ = Type_path.sexp_of_t trait__025_ in - (S.List [ S.Atom "trait"; arg__026_ ] :: bnds__022_ + S.List (S.Atom "Hparam" :: bnds__019_) + | Htrait { hash = hash__025_; trait = trait__027_ } -> + let bnds__024_ = ([] : _ Stdlib.List.t) in + let bnds__024_ = + let arg__028_ = Type_path.sexp_of_t trait__027_ in + (S.List [ S.Atom "trait"; arg__028_ ] :: bnds__024_ : _ Stdlib.List.t) in - let bnds__022_ = - let arg__024_ = Moon_sexp_conv.sexp_of_int hash__023_ in - (S.List [ S.Atom "hash"; arg__024_ ] :: bnds__022_ + let bnds__024_ = + let arg__026_ = Moon_sexp_conv.sexp_of_int hash__025_ in + (S.List [ S.Atom "hash"; arg__026_ ] :: bnds__024_ : _ Stdlib.List.t) in - S.List (S.Atom "Htrait" :: bnds__022_) + S.List (S.Atom "Htrait" :: bnds__024_) | Hunit -> S.Atom "Hunit" | Hbool -> S.Atom "Hbool" | Hbyte -> S.Atom "Hbyte" + | Hint16 -> S.Atom "Hint16" + | Huint16 -> S.Atom "Huint16" | Hchar -> S.Atom "Hchar" | Hint -> S.Atom "Hint" | Hint64 -> S.Atom "Hint64" @@ -141,58 +152,64 @@ module Hashed_type = struct let _ = sexp_of_t let rec (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Hconstr _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.hash - in - Type_path.hash_fold_t hsv _ir.tycon - in - Ppx_base.hash_fold_list hash_fold_t hsv _ir.tys - | Harrow _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.hash - in - Ppx_base.hash_fold_list hash_fold_t hsv _ir.params - in - hash_fold_t hsv _ir.ret - in - Ppx_base.hash_fold_option hash_fold_t hsv _ir.err - | Hparam _ir -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.hash - in - Ppx_base.hash_fold_int hsv _ir.index - | Htrait _ir -> - let hsv = Ppx_base.hash_fold_int hsv 3 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv _ir.hash - in - Type_path.hash_fold_t hsv _ir.trait - | Hunit -> Ppx_base.hash_fold_int hsv 4 - | Hbool -> Ppx_base.hash_fold_int hsv 5 - | Hbyte -> Ppx_base.hash_fold_int hsv 6 - | Hchar -> Ppx_base.hash_fold_int hsv 7 - | Hint -> Ppx_base.hash_fold_int hsv 8 - | Hint64 -> Ppx_base.hash_fold_int hsv 9 - | Huint -> Ppx_base.hash_fold_int hsv 10 - | Huint64 -> Ppx_base.hash_fold_int hsv 11 - | Hfloat -> Ppx_base.hash_fold_int hsv 12 - | Hdouble -> Ppx_base.hash_fold_int hsv 13 - | Hstring -> Ppx_base.hash_fold_int hsv 14 - | Hbytes -> Ppx_base.hash_fold_int hsv 15 - | Hblackhole -> Ppx_base.hash_fold_int hsv 16 + (fun hsv -> + fun arg -> + match arg with + | Hconstr _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.hash + in + Type_path.hash_fold_t hsv _ir.tycon + in + Ppx_base.hash_fold_list hash_fold_t hsv _ir.tys + | Harrow _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = + let hsv = + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.hash + in + Ppx_base.hash_fold_list hash_fold_t hsv _ir.params + in + hash_fold_t hsv _ir.ret + in + Ppx_base.hash_fold_option hash_fold_t hsv _ir.err + in + Ppx_base.hash_fold_bool hsv _ir.is_async + | Hparam _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.hash + in + Ppx_base.hash_fold_int hsv _ir.index + | Htrait _ir -> + let hsv = Ppx_base.hash_fold_int hsv 3 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv _ir.hash + in + Type_path.hash_fold_t hsv _ir.trait + | Hunit -> Ppx_base.hash_fold_int hsv 4 + | Hbool -> Ppx_base.hash_fold_int hsv 5 + | Hbyte -> Ppx_base.hash_fold_int hsv 6 + | Hint16 -> Ppx_base.hash_fold_int hsv 7 + | Huint16 -> Ppx_base.hash_fold_int hsv 8 + | Hchar -> Ppx_base.hash_fold_int hsv 9 + | Hint -> Ppx_base.hash_fold_int hsv 10 + | Hint64 -> Ppx_base.hash_fold_int hsv 11 + | Huint -> Ppx_base.hash_fold_int hsv 12 + | Huint64 -> Ppx_base.hash_fold_int hsv 13 + | Hfloat -> Ppx_base.hash_fold_int hsv 14 + | Hdouble -> Ppx_base.hash_fold_int hsv 15 + | Hstring -> Ppx_base.hash_fold_int hsv 16 + | Hbytes -> Ppx_base.hash_fold_int hsv 17 + | Hblackhole -> Ppx_base.hash_fold_int hsv 18 : Ppx_base.state -> t -> Ppx_base.state) and (hash : t -> Ppx_base.hash_value) = @@ -214,8 +231,8 @@ module Hashed_type = struct | Hparam { hash; _ } | Htrait { hash; _ } -> hash - | Hunit | Hbool | Hbyte | Hchar | Hint | Hint64 | Huint | Huint64 | Hfloat - | Hdouble | Hstring | Hbytes | Hblackhole -> + | Hunit | Hbool | Hbyte | Hint16 | Huint16 | Hchar | Hint | Hint64 | Huint + | Huint64 | Hfloat | Hdouble | Hstring | Hbytes | Hblackhole -> hash t let hash_fold_t hsv t = Ppx_base.hash_fold_int hsv (hash t) @@ -228,11 +245,13 @@ module Hashed_type = struct Type_path.equal p1 p2 && Lst.for_all2_no_exn tys1 tys2 Basic_prelude.phys_equal | _ -> false) - | Harrow { hash = _; params = ps1; ret = r1; err = e1 } -> ( + | Harrow { hash = _; params = ps1; ret = r1; err = e1; is_async = a1 } -> ( match t2 with - | Harrow { hash = _; params = ps2; ret = r2; err = e2 } -> ( + | Harrow { hash = _; params = ps2; ret = r2; err = e2; is_async = a2 } + -> ( Lst.for_all2_no_exn ps1 ps2 Basic_prelude.phys_equal && Basic_prelude.phys_equal r1 r2 + && a1 = a2 && match (e1, e2) with | None, None -> true @@ -248,6 +267,8 @@ module Hashed_type = struct | Hunit -> ( match t2 with Hunit -> true | _ -> false) | Hbool -> ( match t2 with Hbool -> true | _ -> false) | Hbyte -> ( match t2 with Hbyte -> true | _ -> false) + | Hint16 -> ( match t2 with Hint16 -> true | _ -> false) + | Huint16 -> ( match t2 with Huint16 -> true | _ -> false) | Hchar -> ( match t2 with Hchar -> true | _ -> false) | Hint -> ( match t2 with Hint -> true | _ -> false) | Hint64 -> ( match t2 with Hint64 -> true | _ -> false) @@ -267,7 +288,7 @@ let equal (t1 : t) (t2 : t) = Basic_prelude.phys_equal t1 t2 type cache = Hashset.t -let make_cache () : cache = Hashset.create 42 +let make_cache () = (Hashset.create 42 : cache) let constr cache tycon tys = let hsv = Ppx_base.create () in @@ -278,13 +299,16 @@ let constr cache tycon tys = Hashset.find_or_add cache t [@@inline] -let arrow cache params ret err = +let arrow cache params ret err ~is_async = let hsv = Ppx_base.create () in let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = Ppx_base.hash_fold_bool hsv is_async in let hsv = Lst.fold_left params hsv hash_fold_t in let hsv = hash_fold_t hsv ret in let hsv = match err with None -> hsv | Some err -> hash_fold_t hsv err in - let t = Harrow { hash = Ppx_base.get_hash_value hsv; params; ret; err } in + let t = + Harrow { hash = Ppx_base.get_hash_value hsv; params; ret; err; is_async } + in Hashset.find_or_add cache t [@@inline] @@ -309,11 +333,12 @@ exception Unresolved_type_variable let rec of_stype cache (sty : Stype.t) = let go sty = of_stype cache sty [@@inline] in match sty with - | Tarrow { params_ty; ret_ty; err_ty } -> - arrow cache (List.map go params_ty) (go ret_ty) + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> + arrow cache (Lst.map params_ty go) (go ret_ty) (match err_ty with None -> None | Some e -> Some (go e)) + ~is_async | T_constr { type_constructor; tys } -> - constr cache type_constructor (List.map go tys) + constr cache type_constructor (Lst.map tys go) | Tparam { index } -> param cache index | T_trait t -> trait cache t | Tvar { contents = Tlink sty' } -> go sty' @@ -322,6 +347,8 @@ let rec of_stype cache (sty : Stype.t) = | T_builtin T_bool -> Hbool | T_builtin T_byte -> Hbyte | T_builtin T_char -> Hchar + | T_builtin T_int16 -> Hint16 + | T_builtin T_uint16 -> Huint16 | T_builtin T_int -> Hint | T_builtin T_int64 -> Hint64 | T_builtin T_uint -> Huint diff --git a/src/ice_catcher.ml b/src/ice_catcher.ml index 5c2b6f7..a64c4b7 100644 --- a/src/ice_catcher.ml +++ b/src/ice_catcher.ml @@ -51,7 +51,9 @@ let run_with_protection f = with exn -> Printf.eprintf "%s\n" ice_message; Printf.eprintf " %s\n\n" !current_bug_report_url; - let error_message = Printexc.to_string exn in + let error_message = + match exn with Failure msg -> msg | _ -> Printexc.to_string exn + in Printf.eprintf "Error: %s\n\n" error_message; (if Printexc.backtrace_status () then let backtrace = Printexc.get_backtrace () in diff --git a/src/join.ml b/src/join.ml index 2e204b7..5feb833 100644 --- a/src/join.ml +++ b/src/join.ml @@ -17,15 +17,16 @@ type t = int let equal = Int.equal -let sexp_of_t (i : int) : S.t = - Atom ("$join:" ^ Int.to_string i : Stdlib.String.t) +let sexp_of_t (i : int) = + (Atom ("$join:" ^ Int.to_string i : Stdlib.String.t) : S.t) let of_core_ident (id : Basic_core_ident.t) = match id with | Pident { stamp; _ } | Pmutable_ident { stamp; _ } -> stamp - | Pdot _ | Plocal_method _ -> assert false + | Pdot _ -> assert false + | Plocal_method _ -> assert false -let to_wasm_label x : Stdlib.String.t = "$join:" ^ Int.to_string x +let to_wasm_label x = ("$join:" ^ Int.to_string x : Stdlib.String.t) module Map = Basic_map_int module Hash = Basic_hash_int diff --git a/src/json.ml b/src/json.ml index 1c755a5..abb63bb 100644 --- a/src/json.ml +++ b/src/json.ml @@ -13,6 +13,8 @@ *) +module Lst = Basic_lst + type t = [ `Null | `Bool of bool @@ -34,6 +36,6 @@ let rec to_string (t : t) = | `Assoc l -> "{" ^ String.concat "," - (List.map (fun (k, v) -> escaped_quote k ^ ":" ^ to_string v) l) + (Lst.map l (fun (k, v) -> escaped_quote k ^ ":" ^ to_string v)) ^ "}" - | `List l -> "[" ^ String.concat "," (List.map to_string l) ^ "]" + | `List l -> "[" ^ String.concat "," (Lst.map l to_string) ^ "]" diff --git a/src/json_lexer.ml b/src/json_lexer.ml index b2e50a0..dbc415b 100644 --- a/src/json_lexer.ml +++ b/src/json_lexer.ml @@ -200,6 +200,7 @@ let __sedlex_partition_22 c = let open! Stdlib in if c <= 100 then -1 else if c <= 101 then 0 else -1 +module Basic_lexing = Lexing module Lexing = Lex_moon_rt module Vec = Basic_vec @@ -230,7 +231,7 @@ let report_error = function | Unexpected_token -> sprintf "Unexpected_token" | Unterminated_comment -> sprintf "Unterminated_comment" -exception Error of Stdlib.Lexing.position * Stdlib.Lexing.position * error +exception Error of Basic_lexing.position * Basic_lexing.position * error type token = | Comma @@ -253,13 +254,14 @@ type env = { mutable current_bol : int; } -let make_pos ~(env : env) cnum : Stdlib.Lexing.position = - { - pos_fname = env.name; - pos_lnum = env.current_line; - pos_cnum = cnum; - pos_bol = env.current_bol; - } +let make_pos ~(env : env) cnum = + ({ + pos_fname = env.name; + pos_lnum = env.current_line; + pos_cnum = cnum; + pos_bol = env.current_bol; + } + : Basic_lexing.position) [@@inline] let lexeme_spos ~env lexbuf = make_pos ~env (Lexing.lexeme_start lexbuf) @@ -303,29 +305,34 @@ let digit_value (c : int) = | _ -> assert false let char_for_hex_escape : int array -> int -> int -> Uchar.t = - fun buf pos len -> - let end_pos = pos + len in - let rec aux code pos = - if code > 0x10ffff then raise Overflow_max_codepoint - else if pos = end_pos then code - else - let digit = buf.(pos) in - aux ((code lsl 4) + digit_value digit) (pos + 1) - in - if len = 4 then Uchar.unsafe_of_int (aux 0 pos) else Uchar.of_int (aux 0 pos) + fun buf -> + fun pos -> + fun len -> + let end_pos = pos + len in + let rec aux code pos = + if code > 0x10ffff then raise Overflow_max_codepoint + else if pos = end_pos then code + else + let digit = buf.(pos) in + aux ((code lsl 4) + digit_value digit) (pos + 1) + in + if len = 4 then Uchar.unsafe_of_int (aux 0 pos) + else Uchar.of_int (aux 0 pos) [@@inline] let char_for_oct_escape : int array -> int -> int -> Uchar.t = - fun buf pos len -> - let end_pos = pos + len in - let rec aux code pos = - if code > 0x10ffff then raise Overflow_max_codepoint - else if pos = end_pos then code - else - let digit = buf.(pos) in - aux ((code lsl 3) + digit_value digit) (pos + 1) - in - Uchar.of_int (aux 0 pos) + fun buf -> + fun pos -> + fun len -> + let end_pos = pos + len in + let rec aux code pos = + if code > 0x10ffff then raise Overflow_max_codepoint + else if pos = end_pos then code + else + let digit = buf.(pos) in + aux ((code lsl 3) + digit_value digit) (pos + 1) + in + Uchar.of_int (aux 0 pos) [@@inline] let decode_utf16_escape ~env (lexbuf : Lexing.lexbuf) = diff --git a/src/json_literal.ml b/src/json_literal.ml index 067e6fb..bcc8297 100644 --- a/src/json_literal.ml +++ b/src/json_literal.ml @@ -27,90 +27,95 @@ let string : json_constructor = "String" let array : json_constructor = "Array" let object_ : json_constructor = "Object" -let get_json_constr_tag ~global_env ~diagnostics constr_name ~action ~loc = +let get_json_constr_info ~global_env ~diagnostics constr_name ~action ~loc = match Global_env.find_type_by_path global_env type_path_json with - | Some { ty_desc = Variant_type constrs; _ } -> ( - match - Lst.find_first constrs (fun constr -> constr.constr_name = constr_name) - with - | None -> Typeutil.unknown_tag - | Some constr -> constr.cs_tag) - | Some _ -> Typeutil.unknown_tag + | Some { ty_desc = Variant_type constrs; _ } -> + Lst.find_first constrs (fun constr -> constr.constr_name = constr_name) + | Some _ -> None | None -> Typeutil.add_local_typing_error diagnostics (Errors.pkg_not_imported ~name:"moonbitlang/core/json" ~action: - (action ^ " of type " ^ Type_path_util.name type_path_json + ((action ^ " of type " ^ Type_path_util.name type_path_json : Stdlib.String.t) + [@merlin.hide]) ~loc); - Typeutil.unknown_tag + None -let make_json_pat ~global_env ~diagnostics constr_name args ~loc : Typedtree.pat - = - let args = - Lst.mapi args (fun pos pat : Typedtree.constr_pat_arg -> - Constr_pat_arg { pat; kind = Positional; pos }) - in - Tpat_constr - { - constr = - { - constr_name = { name = constr_name; loc_ = Loc.no_location }; - extra_info = No_extra_info; - loc_ = Loc.no_location; - }; - args; - tag = - get_json_constr_tag ~global_env ~diagnostics constr_name ~loc - ~action:"destruct value"; - ty = Stype.json; - used_error_subtyping = false; - loc_ = Loc.no_location; - } +let make_json_pat ~global_env ~diagnostics constr_name args ~loc = + (let args = + Lst.mapi args (fun pos -> + fun pat -> + (Constr_pat_arg { pat; kind = Positional; pos } + : Typedtree.constr_pat_arg)) + in + match + get_json_constr_info ~global_env ~diagnostics constr_name ~loc + ~action:"destruct value" + with + | Some { cs_tag; cs_args; cs_arity_; _ } -> + Tpat_constr + { + type_name = None; + constr = { name = constr_name; loc_ = Loc.no_location }; + args; + tag = cs_tag; + ty = Stype.json; + used_error_subtyping = false; + arity_ = cs_arity_; + all_args_ = cs_args; + loc_ = loc; + } + | None -> Tpat_any { ty = Stype.json; loc_ = loc } + : Typedtree.pat) -let make_json_const_expr ~global_env ~diagnostics constr_name ~loc : - Typedtree.expr = - Texpr_constr - { - constr = - { - constr_name = { name = constr_name; loc_ = Loc.no_location }; - extra_info = No_extra_info; - loc_ = Loc.no_location; - }; - tag = - get_json_constr_tag ~global_env ~diagnostics constr_name ~loc - ~action:"create value"; - ty = Stype.json; - arity_ = Fn_arity.simple 0; - loc_ = loc; - } +let make_json_const_expr ~global_env ~diagnostics constr_name ~loc = + (let tag = + match + get_json_constr_info ~global_env ~diagnostics constr_name ~loc + ~action:"create value" + with + | Some { cs_tag; _ } -> cs_tag + | None -> Typeutil.unknown_tag + in + Texpr_constr + { + type_name = None; + constr = { name = constr_name; loc_ = Loc.no_location }; + tag; + ty = Stype.json; + arity_ = Fn_arity.simple 0; + loc_ = loc; + } + : Typedtree.expr) -let make_json_expr ~global_env ~diagnostics constr_name arg ~loc : - Typedtree.expr = - Texpr_apply - { - func = - Texpr_constr - { - constr = - { - constr_name = { name = constr_name; loc_ = Loc.no_location }; - extra_info = No_extra_info; - loc_ = Loc.no_location; - }; - tag = - get_json_constr_tag ~global_env ~diagnostics constr_name ~loc - ~action:"create value"; - ty = - Builtin.type_arrow - [ Typedtree_util.type_of_typed_expr arg ] - Stype.json ~err_ty:None; - arity_ = Fn_arity.simple 1; - loc_ = Loc.no_location; - }; - args = [ { arg_value = arg; arg_kind = Positional } ]; - ty = Stype.json; - kind_ = Normal; - loc_ = loc; - } +let make_json_expr ~global_env ~diagnostics constr_name arg ~loc = + (let tag = + match + get_json_constr_info ~global_env ~diagnostics constr_name ~loc + ~action:"create value" + with + | Some { cs_tag; _ } -> cs_tag + | None -> Typeutil.unknown_tag + in + Texpr_apply + { + func = + Texpr_constr + { + type_name = None; + constr = { name = constr_name; loc_ = Loc.no_location }; + tag; + ty = + Builtin.type_arrow + [ Typedtree_util.type_of_typed_expr arg ] + Stype.json ~err_ty:None ~is_async:false; + arity_ = Fn_arity.simple 1; + loc_ = Loc.no_location; + }; + args = [ { arg_value = arg; arg_kind = Positional } ]; + ty = Stype.json; + kind_ = Normal; + loc_ = loc; + } + : Typedtree.expr) diff --git a/src/json_parse.ml b/src/json_parse.ml index f4b74f8..893a1dd 100644 --- a/src/json_parse.ml +++ b/src/json_parse.ml @@ -20,61 +20,65 @@ let error loc e = let parse_json (tokens : (Json_lexer.token * Loc.t) Basic_vec.t) = let curr = ref 0 in - let next_token () : Json_lexer.token * Loc.t = - let t = Basic_vec.get tokens !curr in - incr curr; - t + let next_token () = + (let t = Basic_vec.get tokens !curr in + incr curr; + t + : Json_lexer.token * Loc.t) in - let peek_token () : Json_lexer.token * Loc.t = Basic_vec.get tokens !curr in + let peek_token () = (Basic_vec.get tokens !curr : Json_lexer.token * Loc.t) in let skip () = incr curr in - let rec json () : Json_types.t = - match next_token () with - | True, loc -> True loc - | False, loc -> False loc - | Null, loc -> Null loc - | Number s, loc -> Float { float = s; loc } - | String s, loc -> Str { str = s; loc } - | Lbracket, loc -> parse_array loc [] - | Lbrace, loc -> parse_map loc Map_string.empty - | _, loc -> error loc Unexpected_token - and parse_array loc_start acc : Json_types.t = - match peek_token () with - | Rbracket, loc_end -> - skip (); - Arr - { - loc = Loc.merge loc_start loc_end; - content = Basic_arr.reverse_of_list acc; - } - | _ -> ( - let item = json () in - match next_token () with - | Comma, _ -> parse_array loc_start (item :: acc) - | Rbracket, loc_end -> - Arr - { - content = Basic_arr.reverse_of_list (item :: acc); - loc = Loc.merge loc_start loc_end; - } - | _, loc -> error loc Expect_comma_or_rbracket) - and parse_map loc_start acc : Json_types.t = - match next_token () with - | Rbrace, loc_end -> Obj { map = acc; loc = Loc.merge loc_start loc_end } - | String key, _ -> ( - match next_token () with - | Colon, _ -> ( - let value = json () in - match next_token () with - | Rbrace, loc_end -> - Obj - { - map = Map_string.add acc key value; - loc = Loc.merge loc_start loc_end; - } - | Comma, _ -> parse_map loc_start (Map_string.add acc key value) - | _, loc -> error loc Expect_comma_or_rbrace) - | _, loc -> error loc Expect_colon) - | _, loc -> error loc Expect_string_or_rbrace + let rec json () = + (match next_token () with + | True, loc -> True loc + | False, loc -> False loc + | Null, loc -> Null loc + | Number s, loc -> Float { float = s; loc } + | String s, loc -> Str { str = s; loc } + | Lbracket, loc -> parse_array loc [] + | Lbrace, loc -> parse_map loc Map_string.empty + | _, loc -> error loc Unexpected_token + : Json_types.t) + and parse_array loc_start acc = + (match peek_token () with + | Rbracket, loc_end -> + skip (); + Arr + { + loc = Loc.merge loc_start loc_end; + content = Basic_arr.reverse_of_list acc; + } + | _ -> ( + let item = json () in + match next_token () with + | Comma, _ -> parse_array loc_start (item :: acc) + | Rbracket, loc_end -> + Arr + { + content = Basic_arr.reverse_of_list (item :: acc); + loc = Loc.merge loc_start loc_end; + } + | _, loc -> error loc Expect_comma_or_rbracket) + : Json_types.t) + and parse_map loc_start acc = + (match next_token () with + | Rbrace, loc_end -> Obj { map = acc; loc = Loc.merge loc_start loc_end } + | String key, _ -> ( + match next_token () with + | Colon, _ -> ( + let value = json () in + match next_token () with + | Rbrace, loc_end -> + Obj + { + map = Map_string.add acc key value; + loc = Loc.merge loc_start loc_end; + } + | Comma, _ -> parse_map loc_start (Map_string.add acc key value) + | _, loc -> error loc Expect_comma_or_rbrace) + | _, loc -> error loc Expect_colon) + | _, loc -> error loc Expect_string_or_rbrace + : Json_types.t) in let v = json () in match peek_token () with Eof, _ -> v | _, loc -> error loc Expect_eof diff --git a/src/label.ml b/src/label.ml index 3e8ce46..56c4aea 100644 --- a/src/label.ml +++ b/src/label.ml @@ -54,6 +54,9 @@ let to_wasm_name (t : t) = Stdlib.String.concat "" [ "$"; t.name; "/"; Int.to_string t.stamp ] ;; +let to_string t = t.name ^ "/" ^ string_of_int t.stamp +let basename t = t.name + let to_wasm_label_loop t = let x = t.stamp in ("$loop:" ^ Int.to_string x : Stdlib.String.t) diff --git a/src/lambda_lift.ml b/src/lambda_lift.ml index 838628a..4dbf66b 100644 --- a/src/lambda_lift.ml +++ b/src/lambda_lift.ml @@ -41,9 +41,9 @@ type convert_context = { } let free_vars ctx ~exclude fn = - let fvs = Core_util.free_vars ~exclude fn |> Map.bindings in + let fvs = Map.bindings (Core_util.free_vars ~exclude fn) in let dedup_map = Ident.Hash.create 17 in - Lst.iter fvs (fun ((id, _ty) as v) -> + Lst.iter fvs ~f:(fun ((id, _ty) as v) -> let id, ty = Ident.Map.find_default ctx.convert_info id v in if not (Ident.Hash.mem dedup_map id || Ident.Set.mem exclude id) then Ident.Hash.add dedup_map id ty); @@ -66,13 +66,14 @@ let convert_fn (ctx : lifter_context) (fn : Core.fn) match captures with | Single (cap_id, _) -> Ident.Map.add ctx.rename_table cap_id env_binder | Multiple captures -> - Lst.fold_left captures ctx.rename_table (fun acc (cap_id, _) -> - let new_cap_id = Ident.rename cap_id in - Ident.Map.add acc cap_id new_cap_id) + Lst.fold_left captures ctx.rename_table (fun acc -> + fun (cap_id, _) -> + let new_cap_id = Ident.rename cap_id in + Ident.Map.add acc cap_id new_cap_id) in let new_convert_info = - Lst.fold_left self_binders ctx.convert_info (fun acc self_binder -> - Ident.Map.add acc self_binder (env_binder, env_ty)) + Lst.fold_left self_binders ctx.convert_info (fun acc -> + fun self_binder -> Ident.Map.add acc self_binder (env_binder, env_ty)) in let new_ctx = { @@ -86,15 +87,18 @@ let convert_fn (ctx : lifter_context) (fn : Core.fn) match captures with | Single _ -> body | Multiple captures -> - Lst.fold_left_with_offset captures body 0 (fun (cap_id, cap_ty) acc i -> - let pos = - Parsing_syntax.Index { tuple_index = i; loc_ = Rloc.no_location } - in - let rhs = Core.field ~ty:cap_ty ~pos:i env_var pos in - let new_cap_id = Ident.Map.find_exn new_rename_table cap_id in - Core.let_ new_cap_id rhs acc) + Lst.fold_left_with_offset captures body 0 (fun (cap_id, cap_ty) -> + fun acc -> + fun i -> + let pos = + Parsing_syntax.Index + { tuple_index = i; loc_ = Rloc.no_location } + in + let rhs = Core.field ~ty:cap_ty ~pos:i env_var pos in + let new_cap_id = Ident.Map.find_exn new_rename_table cap_id in + Core.let_ new_cap_id rhs acc) in - ({ params = env :: fn.params; body } : Core.fn) + ({ params = env :: fn.params; body; is_async = fn.is_async } : Core.fn) let add_subtop (ctx : lifter_context) binder fn ~(convert_ctx : convert_context option) @@ -130,8 +134,8 @@ let add_subtop (ctx : lifter_context) binder fn let add_subtops ctx bindings ~(convert_ctx : convert_context option) ~(visit_expr : lifter_context -> Core.expr -> Core.expr) = let new_exclude = - Lst.fold_left bindings ctx.exclude (fun acc (binder, _) -> - Ident.Set.add acc binder) + Lst.fold_left bindings ctx.exclude (fun acc -> + fun (binder, _) -> Ident.Set.add acc binder) in let visit_fn ctx fn = match convert_ctx with @@ -142,20 +146,21 @@ let add_subtops ctx bindings ~(convert_ctx : convert_context option) match ctx.lift_to_top with | Subtop -> let new_ctx = { ctx with exclude = new_exclude } in - Lst.iter bindings (fun (binder, fn) -> + Lst.iter bindings ~f:(fun (binder, fn) -> let fn = visit_fn new_ctx fn in Vec.push new_ctx.subtops { binder; fn }); new_ctx | Toplevel { name_hint } -> let new_rename_table = - Lst.fold_left bindings ctx.rename_table (fun acc (binder, _) -> - let new_binder = Ident.make_global_binder ~name_hint binder in - Ident.Map.add acc binder new_binder) + Lst.fold_left bindings ctx.rename_table (fun acc -> + fun (binder, _) -> + let new_binder = Ident.make_global_binder ~name_hint binder in + Ident.Map.add acc binder new_binder) in let new_ctx = { ctx with rename_table = new_rename_table; exclude = new_exclude } in - Lst.iter bindings (fun (binder, fn) -> + Lst.iter bindings ~f:(fun (binder, fn) -> let new_binder = Ident.Map.find_exn new_rename_table binder in let fn = visit_fn new_ctx fn in let subtop : Core.subtop_fun_decl = { binder = new_binder; fn } in @@ -188,8 +193,8 @@ let lift_well_known (ctx : lifter_context) ~(kind : Core.letfn_kind) | fns -> add_subtops ctx fns ~convert_ctx:(Some convert_ctx) ~visit_expr in let new_convert_info = - Lst.fold_left binders new_ctx.convert_info (fun acc binder -> - Ident.Map.add acc binder (renamed_capture, capture_ty)) + Lst.fold_left binders new_ctx.convert_info (fun acc -> + fun binder -> Ident.Map.add acc binder (renamed_capture, capture_ty)) in let new_ctx_with_convert_info = { new_ctx with convert_info = new_convert_info } @@ -207,7 +212,6 @@ let lift_well_known (ctx : lifter_context) ~(kind : Core.letfn_kind) type_constructor = Type_path.tuple captures_len; tys = Lst.map captures snd; generic_ = false; - only_tag_enum_ = false; is_suberror_ = false; } in @@ -227,8 +231,8 @@ let lift_well_known (ctx : lifter_context) ~(kind : Core.letfn_kind) in let tuple_binder = Ident.fresh "*env" in let new_convert_info = - Lst.fold_left binders new_ctx.convert_info (fun acc binder -> - Ident.Map.add acc binder (tuple_binder, tuple_ty)) + Lst.fold_left binders new_ctx.convert_info (fun acc -> + fun binder -> Ident.Map.add acc binder (tuple_binder, tuple_ty)) in let new_ctx_with_convert_info = { new_ctx with convert_info = new_convert_info } @@ -242,7 +246,7 @@ let lifter = method! visit_Cexpr_let ctx binder rhs body ty loc = match (binder, rhs) with - | Pident _, Cexpr_function { func; _ } -> + | Pident _, Cexpr_function { func; is_raw_ = false; _ } -> let freevars = free_vars ctx ~exclude:ctx.exclude func in if freevars = [] then let new_ctx = @@ -280,14 +284,15 @@ let lifter = method! visit_Cexpr_letrec ctx bindings body ty loc = let exclude = - Lst.fold_left bindings ctx.exclude (fun acc (binder, _) -> - Ident.Set.add acc binder) + Lst.fold_left bindings ctx.exclude (fun acc -> + fun (binder, _) -> Ident.Set.add acc binder) in let free_vars, _ = - Lst.fold_right bindings ([], exclude) (fun (_, fn) (acc, exclude) -> - let new_free_vars = free_vars ctx ~exclude fn in - ( new_free_vars @ acc, - Ident.Set.add_list exclude (Lst.map new_free_vars fst) )) + Lst.fold_right bindings ([], exclude) (fun (_, fn) -> + fun (acc, exclude) -> + let new_free_vars = free_vars ctx ~exclude fn in + ( new_free_vars @ acc, + Ident.Set.add_list exclude (Lst.map new_free_vars fst) )) in if free_vars = [] then let new_ctx = @@ -307,7 +312,7 @@ let lifter = method! visit_Cexpr_apply ctx func args kind ty ty_args_ prim loc = match kind with | Join -> super#visit_Cexpr_apply ctx func args kind ty ty_args_ prim loc - | Normal _ -> + | Normal _ | Async _ -> let new_func = Ident.Map.find_default ctx.rename_table func func in let args = Lst.map args (self#visit_expr ctx) in let new_args = @@ -330,34 +335,34 @@ let non_well_known_collector = Ident.Hashset.add ctx id end -let lift_expr ~lift_to_top (expr : Core.expr) : - Core.expr * Core.subtop_fun_decl Vec.t = - let non_well_knowns = Ident.Hashset.create 17 in - non_well_known_collector#visit_expr non_well_knowns expr; - let ctx = - { - lift_to_top; - subtops = Vec.empty (); - rename_table = Ident.Map.empty; - exclude = Ident.Set.empty; - non_well_knowns; - convert_info = Ident.Map.empty; - } - in - let expr = lifter#visit_expr ctx expr in - (expr, ctx.subtops) +let lift_expr ~lift_to_top (expr : Core.expr) = + (let non_well_knowns = Ident.Hashset.create 17 in + non_well_known_collector#visit_expr non_well_knowns expr; + let ctx = + { + lift_to_top; + subtops = Vec.empty (); + rename_table = Ident.Map.empty; + exclude = Ident.Set.empty; + non_well_knowns; + convert_info = Ident.Map.empty; + } + in + let expr = lifter#visit_expr ctx expr in + (expr, ctx.subtops) + : Core.expr * Core.subtop_fun_decl Vec.t) -let subtop_to_top ({ binder; fn } : Core.subtop_fun_decl) ~loc_ : Core.top_item - = - Ctop_fn - { - binder; - func = fn; - subtops = []; - ty_params_ = Tvar_env.empty; - is_pub_ = false; - loc_; - } +let subtop_to_top ({ binder; fn } : Core.subtop_fun_decl) ~loc_ = + (Ctop_fn + { + binder; + func = fn; + subtops = []; + ty_params_ = Tvar_env.empty; + is_pub_ = false; + loc_; + } + : Core.top_item) let lift_item (acc : Core.top_item Vec.t) (item : Core.top_item) = match item with @@ -407,5 +412,5 @@ let lift_item (acc : Core.top_item Vec.t) (item : Core.top_item) = let lift_program (prog : Core.program) = let acc = Vec.empty () in - Lst.iter prog (fun item -> lift_item acc item); + Lst.iter prog ~f:(fun item -> lift_item acc item); Vec.to_list acc diff --git a/src/lex_keyword_tbl.ml b/src/lex_keyword_tbl.ml index 50344f4..ffc6261 100644 --- a/src/lex_keyword_tbl.ml +++ b/src/lex_keyword_tbl.ml @@ -34,6 +34,7 @@ let keyword_tbl = ("struct", STRUCT); ("enum", ENUM); ("trait", TRAIT); + ("traitalias", TRAITALIAS); ("derive", DERIVE); ("while", WHILE); ("break", BREAK); @@ -57,6 +58,8 @@ let keyword_tbl = ("impl", IMPL); ("with", WITH); ("guard", GUARD); + ("async", ASYNC); + ("is", IS); ] let reserved = @@ -70,7 +73,6 @@ let reserved = "unsafe"; "use"; "where"; - "async"; "await"; "dyn"; "abstract"; @@ -84,6 +86,7 @@ let reserved = "local"; "method"; "alias"; + "assert"; |] let find_opt lexeme = KeyTbl.find_opt keyword_tbl lexeme diff --git a/src/lex_literal.ml b/src/lex_literal.ml index 4752de7..757d16b 100644 --- a/src/lex_literal.ml +++ b/src/lex_literal.ml @@ -197,10 +197,11 @@ end let interp_content_to_string elems = List.fold_left - (fun acc elem -> - match elem with - | Interp_lit { c; _ } -> acc ^ c - | Interp_source { source; _ } -> acc ^ "\\{" ^ source ^ "}") + (fun acc -> + fun elem -> + match elem with + | Interp_lit { c; _ } -> acc ^ c + | Interp_source { source; _ } -> acc ^ "\\{" ^ source ^ "}") "" elems let interp_literal_to_string elems = diff --git a/src/lex_menhir_token.ml b/src/lex_menhir_token.ml index 5ba715f..28d402e 100644 --- a/src/lex_menhir_token.ml +++ b/src/lex_menhir_token.ml @@ -25,6 +25,7 @@ type token = | TYPE | TRY | TRUE + | TRAITALIAS | TRAIT | THROW | THIN_ARROW @@ -59,7 +60,7 @@ type token = | LET | LBRACKET | LBRACE - | LABEL of string + | IS | INTERP of Lex_literal.interp_literal | INT of string | INFIX4 of string @@ -103,6 +104,8 @@ type token = | BARBAR | BAR | AUGMENTED_ASSIGNMENT of string + | ATTRIBUTE of string + | ASYNC | AS | AMPERAMPER | AMPER @@ -122,6 +125,7 @@ include struct | TYPE -> S.Atom "TYPE" | TRY -> S.Atom "TRY" | TRUE -> S.Atom "TRUE" + | TRAITALIAS -> S.Atom "TRAITALIAS" | TRAIT -> S.Atom "TRAIT" | THROW -> S.Atom "THROW" | THIN_ARROW -> S.Atom "THIN_ARROW" @@ -170,27 +174,25 @@ include struct | LET -> S.Atom "LET" | LBRACKET -> S.Atom "LBRACKET" | LBRACE -> S.Atom "LBRACE" - | LABEL arg0__017_ -> - let res0__018_ = Moon_sexp_conv.sexp_of_string arg0__017_ in - S.List [ S.Atom "LABEL"; res0__018_ ] - | INTERP arg0__019_ -> - let res0__020_ = Lex_literal.sexp_of_interp_literal arg0__019_ in - S.List [ S.Atom "INTERP"; res0__020_ ] - | INT arg0__021_ -> + | IS -> S.Atom "IS" + | INTERP arg0__017_ -> + let res0__018_ = Lex_literal.sexp_of_interp_literal arg0__017_ in + S.List [ S.Atom "INTERP"; res0__018_ ] + | INT arg0__019_ -> + let res0__020_ = Moon_sexp_conv.sexp_of_string arg0__019_ in + S.List [ S.Atom "INT"; res0__020_ ] + | INFIX4 arg0__021_ -> let res0__022_ = Moon_sexp_conv.sexp_of_string arg0__021_ in - S.List [ S.Atom "INT"; res0__022_ ] - | INFIX4 arg0__023_ -> + S.List [ S.Atom "INFIX4"; res0__022_ ] + | INFIX3 arg0__023_ -> let res0__024_ = Moon_sexp_conv.sexp_of_string arg0__023_ in - S.List [ S.Atom "INFIX4"; res0__024_ ] - | INFIX3 arg0__025_ -> + S.List [ S.Atom "INFIX3"; res0__024_ ] + | INFIX2 arg0__025_ -> let res0__026_ = Moon_sexp_conv.sexp_of_string arg0__025_ in - S.List [ S.Atom "INFIX3"; res0__026_ ] - | INFIX2 arg0__027_ -> + S.List [ S.Atom "INFIX2"; res0__026_ ] + | INFIX1 arg0__027_ -> let res0__028_ = Moon_sexp_conv.sexp_of_string arg0__027_ in - S.List [ S.Atom "INFIX2"; res0__028_ ] - | INFIX1 arg0__029_ -> - let res0__030_ = Moon_sexp_conv.sexp_of_string arg0__029_ in - S.List [ S.Atom "INFIX1"; res0__030_ ] + S.List [ S.Atom "INFIX1"; res0__028_ ] | IN -> S.Atom "IN" | IMPORT -> S.Atom "IMPORT" | IMPL -> S.Atom "IMPL" @@ -198,9 +200,9 @@ include struct | GUARD -> S.Atom "GUARD" | FOR -> S.Atom "FOR" | FN -> S.Atom "FN" - | FLOAT arg0__031_ -> - let res0__032_ = Moon_sexp_conv.sexp_of_string arg0__031_ in - S.List [ S.Atom "FLOAT"; res0__032_ ] + | FLOAT arg0__029_ -> + let res0__030_ = Moon_sexp_conv.sexp_of_string arg0__029_ in + S.List [ S.Atom "FLOAT"; res0__030_ ] | FAT_ARROW -> S.Atom "FAT_ARROW" | FALSE -> S.Atom "FALSE" | EXTERN -> S.Atom "EXTERN" @@ -210,42 +212,46 @@ include struct | ENUM -> S.Atom "ENUM" | ELSE -> S.Atom "ELSE" | ELLIPSIS -> S.Atom "ELLIPSIS" - | DOT_UIDENT arg0__033_ -> + | DOT_UIDENT arg0__031_ -> + let res0__032_ = Moon_sexp_conv.sexp_of_string arg0__031_ in + S.List [ S.Atom "DOT_UIDENT"; res0__032_ ] + | DOT_LIDENT arg0__033_ -> let res0__034_ = Moon_sexp_conv.sexp_of_string arg0__033_ in - S.List [ S.Atom "DOT_UIDENT"; res0__034_ ] - | DOT_LIDENT arg0__035_ -> - let res0__036_ = Moon_sexp_conv.sexp_of_string arg0__035_ in - S.List [ S.Atom "DOT_LIDENT"; res0__036_ ] - | DOT_INT arg0__037_ -> - let res0__038_ = Moon_sexp_conv.sexp_of_int arg0__037_ in - S.List [ S.Atom "DOT_INT"; res0__038_ ] + S.List [ S.Atom "DOT_LIDENT"; res0__034_ ] + | DOT_INT arg0__035_ -> + let res0__036_ = Moon_sexp_conv.sexp_of_int arg0__035_ in + S.List [ S.Atom "DOT_INT"; res0__036_ ] | DOTDOT -> S.Atom "DOTDOT" | DERIVE -> S.Atom "DERIVE" | CONTINUE -> S.Atom "CONTINUE" | CONST -> S.Atom "CONST" - | COMMENT arg0__039_ -> - let res0__040_ = Comment.sexp_of_t arg0__039_ in - S.List [ S.Atom "COMMENT"; res0__040_ ] + | COMMENT arg0__037_ -> + let res0__038_ = Comment.sexp_of_t arg0__037_ in + S.List [ S.Atom "COMMENT"; res0__038_ ] | COMMA -> S.Atom "COMMA" | COLONCOLON -> S.Atom "COLONCOLON" | COLON -> S.Atom "COLON" - | CHAR arg0__041_ -> - let res0__042_ = Lex_literal.sexp_of_char_literal arg0__041_ in - S.List [ S.Atom "CHAR"; res0__042_ ] + | CHAR arg0__039_ -> + let res0__040_ = Lex_literal.sexp_of_char_literal arg0__039_ in + S.List [ S.Atom "CHAR"; res0__040_ ] | CATCH -> S.Atom "CATCH" | CARET -> S.Atom "CARET" - | BYTES arg0__043_ -> - let res0__044_ = Lex_literal.sexp_of_bytes_literal arg0__043_ in - S.List [ S.Atom "BYTES"; res0__044_ ] - | BYTE arg0__045_ -> - let res0__046_ = Lex_literal.sexp_of_byte_literal arg0__045_ in - S.List [ S.Atom "BYTE"; res0__046_ ] + | BYTES arg0__041_ -> + let res0__042_ = Lex_literal.sexp_of_bytes_literal arg0__041_ in + S.List [ S.Atom "BYTES"; res0__042_ ] + | BYTE arg0__043_ -> + let res0__044_ = Lex_literal.sexp_of_byte_literal arg0__043_ in + S.List [ S.Atom "BYTE"; res0__044_ ] | BREAK -> S.Atom "BREAK" | BARBAR -> S.Atom "BARBAR" | BAR -> S.Atom "BAR" - | AUGMENTED_ASSIGNMENT arg0__047_ -> + | AUGMENTED_ASSIGNMENT arg0__045_ -> + let res0__046_ = Moon_sexp_conv.sexp_of_string arg0__045_ in + S.List [ S.Atom "AUGMENTED_ASSIGNMENT"; res0__046_ ] + | ATTRIBUTE arg0__047_ -> let res0__048_ = Moon_sexp_conv.sexp_of_string arg0__047_ in - S.List [ S.Atom "AUGMENTED_ASSIGNMENT"; res0__048_ ] + S.List [ S.Atom "ATTRIBUTE"; res0__048_ ] + | ASYNC -> S.Atom "ASYNC" | AS -> S.Atom "AS" | AMPERAMPER -> S.Atom "AMPERAMPER" | AMPER -> S.Atom "AMPER" @@ -264,6 +270,7 @@ type 'a terminal = | T_TYPE : unit terminal | T_TRY : unit terminal | T_TRUE : unit terminal + | T_TRAITALIAS : unit terminal | T_TRAIT : unit terminal | T_THROW : unit terminal | T_THIN_ARROW : unit terminal @@ -298,7 +305,7 @@ type 'a terminal = | T_LET : unit terminal | T_LBRACKET : unit terminal | T_LBRACE : unit terminal - | T_LABEL : string terminal + | T_IS : unit terminal | T_INTERP : Lex_literal.interp_literal terminal | T_INT : string terminal | T_INFIX4 : string terminal @@ -342,6 +349,8 @@ type 'a terminal = | T_BARBAR : unit terminal | T_BAR : unit terminal | T_AUGMENTED_ASSIGNMENT : string terminal + | T_ATTRIBUTE : string terminal + | T_ASYNC : unit terminal | T_AS : unit terminal | T_AMPERAMPER : unit terminal | T_AMPER : unit terminal @@ -350,98 +359,102 @@ include struct let _ = fun (_ : 'a terminal) -> () let sexp_of_terminal : 'a. ('a -> S.t) -> 'a terminal -> S.t = - fun (type a__050_) : ((a__050_ -> S.t) -> a__050_ terminal -> S.t) -> - fun _of_a__049_ -> function - | T_error -> S.Atom "T_error" - | T_WITH -> S.Atom "T_WITH" - | T_WHILE -> S.Atom "T_WHILE" - | T_UNDERSCORE -> S.Atom "T_UNDERSCORE" - | T_UIDENT -> S.Atom "T_UIDENT" - | T_TYPEALIAS -> S.Atom "T_TYPEALIAS" - | T_TYPE -> S.Atom "T_TYPE" - | T_TRY -> S.Atom "T_TRY" - | T_TRUE -> S.Atom "T_TRUE" - | T_TRAIT -> S.Atom "T_TRAIT" - | T_THROW -> S.Atom "T_THROW" - | T_THIN_ARROW -> S.Atom "T_THIN_ARROW" - | T_TEST -> S.Atom "T_TEST" - | T_STRUCT -> S.Atom "T_STRUCT" - | T_STRING -> S.Atom "T_STRING" - | T_SEMI -> S.Atom "T_SEMI" - | T_RPAREN -> S.Atom "T_RPAREN" - | T_RETURN -> S.Atom "T_RETURN" - | T_READONLY -> S.Atom "T_READONLY" - | T_RBRACKET -> S.Atom "T_RBRACKET" - | T_RBRACE -> S.Atom "T_RBRACE" - | T_RANGE_INCLUSIVE -> S.Atom "T_RANGE_INCLUSIVE" - | T_RANGE_EXCLUSIVE -> S.Atom "T_RANGE_EXCLUSIVE" - | T_RAISE -> S.Atom "T_RAISE" - | T_QUESTION -> S.Atom "T_QUESTION" - | T_PUB -> S.Atom "T_PUB" - | T_PRIV -> S.Atom "T_PRIV" - | T_POST_LABEL -> S.Atom "T_POST_LABEL" - | T_PLUS -> S.Atom "T_PLUS" - | T_PIPE -> S.Atom "T_PIPE" - | T_PACKAGE_NAME -> S.Atom "T_PACKAGE_NAME" - | T_NEWLINE -> S.Atom "T_NEWLINE" - | T_MUTABLE -> S.Atom "T_MUTABLE" - | T_MULTILINE_STRING -> S.Atom "T_MULTILINE_STRING" - | T_MULTILINE_INTERP -> S.Atom "T_MULTILINE_INTERP" - | T_MINUS -> S.Atom "T_MINUS" - | T_MATCH -> S.Atom "T_MATCH" - | T_LPAREN -> S.Atom "T_LPAREN" - | T_LOOP -> S.Atom "T_LOOP" - | T_LIDENT -> S.Atom "T_LIDENT" - | T_LET -> S.Atom "T_LET" - | T_LBRACKET -> S.Atom "T_LBRACKET" - | T_LBRACE -> S.Atom "T_LBRACE" - | T_LABEL -> S.Atom "T_LABEL" - | T_INTERP -> S.Atom "T_INTERP" - | T_INT -> S.Atom "T_INT" - | T_INFIX4 -> S.Atom "T_INFIX4" - | T_INFIX3 -> S.Atom "T_INFIX3" - | T_INFIX2 -> S.Atom "T_INFIX2" - | T_INFIX1 -> S.Atom "T_INFIX1" - | T_IN -> S.Atom "T_IN" - | T_IMPORT -> S.Atom "T_IMPORT" - | T_IMPL -> S.Atom "T_IMPL" - | T_IF -> S.Atom "T_IF" - | T_GUARD -> S.Atom "T_GUARD" - | T_FOR -> S.Atom "T_FOR" - | T_FN -> S.Atom "T_FN" - | T_FLOAT -> S.Atom "T_FLOAT" - | T_FAT_ARROW -> S.Atom "T_FAT_ARROW" - | T_FALSE -> S.Atom "T_FALSE" - | T_EXTERN -> S.Atom "T_EXTERN" - | T_EXCLAMATION -> S.Atom "T_EXCLAMATION" - | T_EQUAL -> S.Atom "T_EQUAL" - | T_EOF -> S.Atom "T_EOF" - | T_ENUM -> S.Atom "T_ENUM" - | T_ELSE -> S.Atom "T_ELSE" - | T_ELLIPSIS -> S.Atom "T_ELLIPSIS" - | T_DOT_UIDENT -> S.Atom "T_DOT_UIDENT" - | T_DOT_LIDENT -> S.Atom "T_DOT_LIDENT" - | T_DOT_INT -> S.Atom "T_DOT_INT" - | T_DOTDOT -> S.Atom "T_DOTDOT" - | T_DERIVE -> S.Atom "T_DERIVE" - | T_CONTINUE -> S.Atom "T_CONTINUE" - | T_CONST -> S.Atom "T_CONST" - | T_COMMENT -> S.Atom "T_COMMENT" - | T_COMMA -> S.Atom "T_COMMA" - | T_COLONCOLON -> S.Atom "T_COLONCOLON" - | T_COLON -> S.Atom "T_COLON" - | T_CHAR -> S.Atom "T_CHAR" - | T_CATCH -> S.Atom "T_CATCH" - | T_CARET -> S.Atom "T_CARET" - | T_BYTES -> S.Atom "T_BYTES" - | T_BYTE -> S.Atom "T_BYTE" - | T_BREAK -> S.Atom "T_BREAK" - | T_BARBAR -> S.Atom "T_BARBAR" - | T_BAR -> S.Atom "T_BAR" - | T_AUGMENTED_ASSIGNMENT -> S.Atom "T_AUGMENTED_ASSIGNMENT" - | T_AS -> S.Atom "T_AS" - | T_AMPERAMPER -> S.Atom "T_AMPERAMPER" - | T_AMPER -> S.Atom "T_AMPER" + fun (type a__050_) -> + (fun _of_a__049_ -> function + | T_error -> S.Atom "T_error" + | T_WITH -> S.Atom "T_WITH" + | T_WHILE -> S.Atom "T_WHILE" + | T_UNDERSCORE -> S.Atom "T_UNDERSCORE" + | T_UIDENT -> S.Atom "T_UIDENT" + | T_TYPEALIAS -> S.Atom "T_TYPEALIAS" + | T_TYPE -> S.Atom "T_TYPE" + | T_TRY -> S.Atom "T_TRY" + | T_TRUE -> S.Atom "T_TRUE" + | T_TRAITALIAS -> S.Atom "T_TRAITALIAS" + | T_TRAIT -> S.Atom "T_TRAIT" + | T_THROW -> S.Atom "T_THROW" + | T_THIN_ARROW -> S.Atom "T_THIN_ARROW" + | T_TEST -> S.Atom "T_TEST" + | T_STRUCT -> S.Atom "T_STRUCT" + | T_STRING -> S.Atom "T_STRING" + | T_SEMI -> S.Atom "T_SEMI" + | T_RPAREN -> S.Atom "T_RPAREN" + | T_RETURN -> S.Atom "T_RETURN" + | T_READONLY -> S.Atom "T_READONLY" + | T_RBRACKET -> S.Atom "T_RBRACKET" + | T_RBRACE -> S.Atom "T_RBRACE" + | T_RANGE_INCLUSIVE -> S.Atom "T_RANGE_INCLUSIVE" + | T_RANGE_EXCLUSIVE -> S.Atom "T_RANGE_EXCLUSIVE" + | T_RAISE -> S.Atom "T_RAISE" + | T_QUESTION -> S.Atom "T_QUESTION" + | T_PUB -> S.Atom "T_PUB" + | T_PRIV -> S.Atom "T_PRIV" + | T_POST_LABEL -> S.Atom "T_POST_LABEL" + | T_PLUS -> S.Atom "T_PLUS" + | T_PIPE -> S.Atom "T_PIPE" + | T_PACKAGE_NAME -> S.Atom "T_PACKAGE_NAME" + | T_NEWLINE -> S.Atom "T_NEWLINE" + | T_MUTABLE -> S.Atom "T_MUTABLE" + | T_MULTILINE_STRING -> S.Atom "T_MULTILINE_STRING" + | T_MULTILINE_INTERP -> S.Atom "T_MULTILINE_INTERP" + | T_MINUS -> S.Atom "T_MINUS" + | T_MATCH -> S.Atom "T_MATCH" + | T_LPAREN -> S.Atom "T_LPAREN" + | T_LOOP -> S.Atom "T_LOOP" + | T_LIDENT -> S.Atom "T_LIDENT" + | T_LET -> S.Atom "T_LET" + | T_LBRACKET -> S.Atom "T_LBRACKET" + | T_LBRACE -> S.Atom "T_LBRACE" + | T_IS -> S.Atom "T_IS" + | T_INTERP -> S.Atom "T_INTERP" + | T_INT -> S.Atom "T_INT" + | T_INFIX4 -> S.Atom "T_INFIX4" + | T_INFIX3 -> S.Atom "T_INFIX3" + | T_INFIX2 -> S.Atom "T_INFIX2" + | T_INFIX1 -> S.Atom "T_INFIX1" + | T_IN -> S.Atom "T_IN" + | T_IMPORT -> S.Atom "T_IMPORT" + | T_IMPL -> S.Atom "T_IMPL" + | T_IF -> S.Atom "T_IF" + | T_GUARD -> S.Atom "T_GUARD" + | T_FOR -> S.Atom "T_FOR" + | T_FN -> S.Atom "T_FN" + | T_FLOAT -> S.Atom "T_FLOAT" + | T_FAT_ARROW -> S.Atom "T_FAT_ARROW" + | T_FALSE -> S.Atom "T_FALSE" + | T_EXTERN -> S.Atom "T_EXTERN" + | T_EXCLAMATION -> S.Atom "T_EXCLAMATION" + | T_EQUAL -> S.Atom "T_EQUAL" + | T_EOF -> S.Atom "T_EOF" + | T_ENUM -> S.Atom "T_ENUM" + | T_ELSE -> S.Atom "T_ELSE" + | T_ELLIPSIS -> S.Atom "T_ELLIPSIS" + | T_DOT_UIDENT -> S.Atom "T_DOT_UIDENT" + | T_DOT_LIDENT -> S.Atom "T_DOT_LIDENT" + | T_DOT_INT -> S.Atom "T_DOT_INT" + | T_DOTDOT -> S.Atom "T_DOTDOT" + | T_DERIVE -> S.Atom "T_DERIVE" + | T_CONTINUE -> S.Atom "T_CONTINUE" + | T_CONST -> S.Atom "T_CONST" + | T_COMMENT -> S.Atom "T_COMMENT" + | T_COMMA -> S.Atom "T_COMMA" + | T_COLONCOLON -> S.Atom "T_COLONCOLON" + | T_COLON -> S.Atom "T_COLON" + | T_CHAR -> S.Atom "T_CHAR" + | T_CATCH -> S.Atom "T_CATCH" + | T_CARET -> S.Atom "T_CARET" + | T_BYTES -> S.Atom "T_BYTES" + | T_BYTE -> S.Atom "T_BYTE" + | T_BREAK -> S.Atom "T_BREAK" + | T_BARBAR -> S.Atom "T_BARBAR" + | T_BAR -> S.Atom "T_BAR" + | T_AUGMENTED_ASSIGNMENT -> S.Atom "T_AUGMENTED_ASSIGNMENT" + | T_ATTRIBUTE -> S.Atom "T_ATTRIBUTE" + | T_ASYNC -> S.Atom "T_ASYNC" + | T_AS -> S.Atom "T_AS" + | T_AMPERAMPER -> S.Atom "T_AMPERAMPER" + | T_AMPER -> S.Atom "T_AMPER" + : (a__050_ -> S.t) -> a__050_ terminal -> S.t) let _ = sexp_of_terminal end @@ -457,6 +470,7 @@ let kind_of_token = function | TYPE -> Token_kind T_TYPE | TRY -> Token_kind T_TRY | TRUE -> Token_kind T_TRUE + | TRAITALIAS -> Token_kind T_TRAITALIAS | TRAIT -> Token_kind T_TRAIT | THROW -> Token_kind T_THROW | THIN_ARROW -> Token_kind T_THIN_ARROW @@ -491,7 +505,7 @@ let kind_of_token = function | LET -> Token_kind T_LET | LBRACKET -> Token_kind T_LBRACKET | LBRACE -> Token_kind T_LBRACE - | LABEL _ -> Token_kind T_LABEL + | IS -> Token_kind T_IS | INTERP _ -> Token_kind T_INTERP | INT _ -> Token_kind T_INT | INFIX4 _ -> Token_kind T_INFIX4 @@ -535,6 +549,8 @@ let kind_of_token = function | BARBAR -> Token_kind T_BARBAR | BAR -> Token_kind T_BAR | AUGMENTED_ASSIGNMENT _ -> Token_kind T_AUGMENTED_ASSIGNMENT + | ATTRIBUTE _ -> Token_kind T_ATTRIBUTE + | ASYNC -> Token_kind T_ASYNC | AS -> Token_kind T_AS | AMPERAMPER -> Token_kind T_AMPERAMPER | AMPER -> Token_kind T_AMPER diff --git a/src/lex_menhir_token_util.ml b/src/lex_menhir_token_util.ml new file mode 100644 index 0000000..21a072f --- /dev/null +++ b/src/lex_menhir_token_util.ml @@ -0,0 +1,204 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Menhir_token = Lex_menhir_token + +let token_kind_to_expect_string (t : Menhir_token.token_kind) = + match t with + | Token_kind T_error -> assert false + | Token_kind T_WHILE -> "`while`" + | Token_kind T_UNDERSCORE -> "`_`" + | Token_kind T_UIDENT -> "identifier" + | Token_kind T_TYPE -> "`type`" + | Token_kind T_TYPEALIAS -> "`typealias`" + | Token_kind T_TRUE -> "`true`" + | Token_kind T_STRUCT -> "`struct`" + | Token_kind T_STRING -> "string" + | Token_kind T_MULTILINE_STRING -> "multiline string" + | Token_kind T_MULTILINE_INTERP -> "multiline string interpolation" + | Token_kind T_SEMI -> "`;`" + | Token_kind T_RPAREN -> "`)`" + | Token_kind T_RETURN -> "`return`" + | Token_kind T_THROW -> "`throw`" + | Token_kind T_RAISE -> "`raise`" + | Token_kind T_TRY -> "`try`" + | Token_kind T_CATCH -> "`catch`" + | Token_kind T_READONLY -> "`readonly`" + | Token_kind T_RBRACKET -> "`]`" + | Token_kind T_RBRACE -> "`}`" + | Token_kind T_PUB -> "`pub`" + | Token_kind T_PRIV -> "`priv`" + | Token_kind T_PLUS -> "+" + | Token_kind T_PACKAGE_NAME -> "package name" + | Token_kind T_NEWLINE -> "new line" + | Token_kind T_MUTABLE -> "`mut`" + | Token_kind T_MINUS -> "`-`" + | Token_kind T_MATCH -> "`match`" + | Token_kind T_LPAREN -> "`(`" + | Token_kind T_LIDENT -> "`identifier`" + | Token_kind T_POST_LABEL -> "`label~`" + | Token_kind T_LET -> "`let`" + | Token_kind T_LBRACKET -> "`[`" + | Token_kind T_LBRACE -> "`{`" + | Token_kind T_IMPL -> "`impl`" + | Token_kind T_WITH -> "`with`" + | Token_kind T_INT -> "integer" + | Token_kind T_BYTE -> "byte" + | Token_kind T_BYTES -> "bytes" + | Token_kind T_INFIX4 -> "infix 4" + | Token_kind T_INFIX3 -> "infix 3" + | Token_kind T_INFIX2 -> "infix 2" + | Token_kind T_INFIX1 -> "infix 1" + | Token_kind T_QUESTION -> "`?`" + | Token_kind T_EXCLAMATION -> "`!`" + | Token_kind T_TRAITALIAS -> "`traitalias`" + | Token_kind T_TRAIT -> "`trait`" + | Token_kind T_DERIVE -> "derive" + | Token_kind T_IMPORT -> "`import`" + | Token_kind T_EXTERN -> "`extern`" + | Token_kind T_IF -> "`if`" + | Token_kind T_FN -> "`fn`" + | Token_kind T_FLOAT -> "float" + | Token_kind T_FAT_ARROW -> "`=>`" + | Token_kind T_THIN_ARROW -> "`->`" + | Token_kind T_FALSE -> "`false`" + | Token_kind T_EQUAL -> "`=`" + | Token_kind T_AUGMENTED_ASSIGNMENT -> "`augmented assignment`" + | Token_kind T_EOF -> "`end of file`" + | Token_kind T_ENUM -> "`enum`" + | Token_kind T_ELSE -> "`else`" + | Token_kind T_DOT_UIDENT -> "`.` identifier" + | Token_kind T_DOT_LIDENT -> "`.` identifier" + | Token_kind T_DOT_INT -> "`.` integer" + | Token_kind T_CONTINUE -> "`continue`" + | Token_kind T_CONST -> "`const`" + | Token_kind T_COMMENT -> "comment" + | Token_kind T_COMMA -> "`,`" + | Token_kind T_COLONCOLON -> "`::`" + | Token_kind T_COLON -> "`:`" + | Token_kind T_CHAR -> "character" + | Token_kind T_BREAK -> "`break`" + | Token_kind T_BARBAR -> "`||`" + | Token_kind T_BAR -> "`|`" + | Token_kind T_ASYNC -> "`async`" + | Token_kind T_AS -> "`as`" + | Token_kind T_AMPERAMPER -> "`&&`" + | Token_kind T_DOTDOT -> ".." + | Token_kind T_RANGE_INCLUSIVE -> "..=" + | Token_kind T_RANGE_EXCLUSIVE -> "..<" + | Token_kind T_INTERP -> "string interpolation" + | Token_kind T_TEST -> "`test`" + | Token_kind T_LOOP -> "`loop`" + | Token_kind T_FOR -> "`for`" + | Token_kind T_IN -> "`in`" + | Token_kind T_PIPE -> "|>" + | Token_kind T_AMPER -> "`&`" + | Token_kind T_CARET -> "`^`" + | Token_kind T_GUARD -> "guard" + | Token_kind T_ELLIPSIS -> "`...`" + | Token_kind T_ATTRIBUTE -> "`attribute`" + | Token_kind T_IS -> "`is`" + +let token_to_string = function + | Menhir_token.CHAR { char_repr; _ } -> "'" ^ char_repr ^ "'" + | INT s -> s + | BYTE { byte_repr; _ } -> "b'" ^ byte_repr ^ "'" + | BYTES { bytes_repr; _ } -> "b\"" ^ bytes_repr ^ "\"" + | FLOAT s -> s + | STRING { string_repr; _ } -> "\"" ^ string_repr ^ "\"" + | MULTILINE_STRING s -> "#|" ^ s + | MULTILINE_INTERP interp -> + "$|" ^ Lex_literal.interp_content_to_string interp + | INTERP interp -> Lex_literal.interp_literal_to_string interp + | LIDENT s | UIDENT s -> s + | POST_LABEL s -> s ^ "~" + | COMMENT { content; _ } -> content + | NEWLINE -> "\n" + | INFIX1 s | INFIX2 s | INFIX3 s | INFIX4 s -> s + | AUGMENTED_ASSIGNMENT s -> s ^ "=" + | EOF -> "" + | FALSE -> "false" + | TRUE -> "true" + | PUB -> "pub" + | PRIV -> "priv" + | READONLY -> "readonly" + | IMPORT -> "import" + | EXTERN -> "extern" + | BREAK -> "break" + | CONTINUE -> "continue" + | CONST -> "const" + | STRUCT -> "struct" + | ENUM -> "enum" + | TRAITALIAS -> "traitalias" + | TRAIT -> "trait" + | DERIVE -> "derive" + | IMPL -> "impl" + | WITH -> "with" + | RAISE -> "raise" + | THROW -> "throw" + | TRY -> "try" + | CATCH -> "catch" + | EQUAL -> "=" + | LPAREN -> "(" + | RPAREN -> ")" + | COMMA -> "," + | MINUS -> "-" + | QUESTION -> "?" + | EXCLAMATION -> "!" + | DOT_UIDENT s -> "." ^ s + | DOT_LIDENT s -> "." ^ s + | DOT_INT s -> "." ^ Int.to_string s + | COLONCOLON -> "::" + | COLON -> ":" + | SEMI true -> ";" + | SEMI false -> "" + | LBRACKET -> "[" + | PLUS -> "+" + | RBRACKET -> "]" + | UNDERSCORE -> "_" + | BAR -> "|" + | LBRACE -> "{" + | RBRACE -> "}" + | AMPERAMPER -> "&&" + | BARBAR -> "||" + | ASYNC -> "async" + | AS -> "as" + | PIPE -> "|>" + | ELSE -> "else" + | FN -> "fn" + | IF -> "if" + | LET -> "let" + | MATCH -> "match" + | MUTABLE -> "mut" + | TYPE -> "type" + | TYPEALIAS -> "typealias" + | FAT_ARROW -> "=>" + | THIN_ARROW -> "->" + | WHILE -> "while" + | RETURN -> "return" + | DOTDOT -> ".." + | RANGE_INCLUSIVE -> "..=" + | RANGE_EXCLUSIVE -> "..<" + | TEST -> "test" + | LOOP -> "loop" + | FOR -> "for" + | IN -> "in" + | PACKAGE_NAME s -> "@" ^ s + | AMPER -> "&" + | CARET -> "^" + | GUARD -> "guard" + | ELLIPSIS -> "..." + | ATTRIBUTE s -> "#" ^ s + | IS -> "is" diff --git a/src/lex_moon_rt.ml b/src/lex_moon_rt.ml index be7cafe..45115e6 100644 --- a/src/lex_moon_rt.ml +++ b/src/lex_moon_rt.ml @@ -32,15 +32,16 @@ let from_int_vec (a : Basic_vec_int.t) = let len = Basic_vec_int.length a in empty_lexbuf ~buf:a.arr ~len -let __private__next_int lexbuf : int = - if lexbuf.pos = lexbuf.len then -1 - else - let ret = lexbuf.buf.!(lexbuf.pos) in - lexbuf.pos <- lexbuf.pos + 1; - ret - -let peek_next_int lexbuf : int = - if lexbuf.pos = lexbuf.len then -1 else lexbuf.buf.!(lexbuf.pos) +let __private__next_int lexbuf = + (if lexbuf.pos = lexbuf.len then -1 + else + let ret = lexbuf.buf.!(lexbuf.pos) in + lexbuf.pos <- lexbuf.pos + 1; + ret + : int) + +let peek_next_int lexbuf = + (if lexbuf.pos = lexbuf.len then -1 else lexbuf.buf.!(lexbuf.pos) : int) let mark lexbuf i = lexbuf.marked_pos <- lexbuf.pos; diff --git a/src/lex_semi_insertion.ml b/src/lex_semi_insertion.ml index b777bee..4d4eb59 100644 --- a/src/lex_semi_insertion.ml +++ b/src/lex_semi_insertion.ml @@ -23,16 +23,16 @@ let can_occur_before_semi (token : Menhir_token.token) = | INT _ | BYTE _ | BYTES _ | TRUE | FALSE | STRING _ | MULTILINE_STRING _ | MULTILINE_INTERP _ | INTERP _ | CHAR _ | RBRACE | RPAREN | RBRACKET | UNDERSCORE | BREAK | CONTINUE | RETURN | THROW | QUESTION | EXCLAMATION - | RANGE_INCLUSIVE | RANGE_EXCLUSIVE | PIPE | ELLIPSIS -> + | RANGE_INCLUSIVE | RANGE_EXCLUSIVE | PIPE | ELLIPSIS | POST_LABEL _ -> true | TYPE | TYPEALIAS | STRUCT | SEMI _ | PLUS | PACKAGE_NAME _ | NEWLINE - | MUTABLE | MINUS | MATCH | TRY | CATCH | POST_LABEL _ | LABEL _ | LPAREN - | LET | CONST | LBRACKET | LBRACE | INFIX1 _ | INFIX4 _ | INFIX3 _ | INFIX2 _ - | IMPL | WITH | IMPORT | IF | GUARD | WHILE | FN | FAT_ARROW | THIN_ARROW | IN - | EQUAL | AUGMENTED_ASSIGNMENT _ | EOF | ENUM | ELSE | EXTERN | COMMENT _ - | COMMA | COLON | BARBAR | BAR | AS | AMPERAMPER | DOTDOT | PUB | PRIV - | READONLY | TRAIT | DERIVE | COLONCOLON | TEST | LOOP | FOR | AMPER | CARET - | RAISE -> + | MUTABLE | MINUS | MATCH | TRY | CATCH | LPAREN | LET | CONST | LBRACKET + | LBRACE | INFIX1 _ | INFIX4 _ | INFIX3 _ | INFIX2 _ | IMPL | WITH | IMPORT + | IF | GUARD | WHILE | ASYNC | FN | FAT_ARROW | THIN_ARROW | IN | EQUAL + | AUGMENTED_ASSIGNMENT _ | EOF | ENUM | ELSE | EXTERN | COMMENT _ | COMMA + | COLON | BARBAR | BAR | AS | IS | AMPERAMPER | DOTDOT | PUB | PRIV | READONLY + | TRAIT | TRAITALIAS | DERIVE | COLONCOLON | TEST | LOOP | FOR | AMPER | CARET + | RAISE | ATTRIBUTE _ -> false [@@inline] @@ -41,9 +41,10 @@ let can_occur_after_semi (token : Menhir_token.token) = | UIDENT _ | LIDENT _ | FLOAT _ | INT _ | BYTE _ | BYTES _ | TRUE | FALSE | STRING _ | MULTILINE_STRING _ | MULTILINE_INTERP _ | INTERP _ | CHAR _ | LBRACE | LPAREN | LBRACKET | UNDERSCORE | BREAK | CONTINUE | RETURN | THROW - | RAISE | TYPE | TYPEALIAS | STRUCT | TRAIT | PACKAGE_NAME _ | MUTABLE | MATCH - | TRY | LET | CONST | IMPL | IMPORT | EXTERN | IF | GUARD | WHILE | FN | EOF - | ENUM | PUB | PRIV | READONLY | TEST | LOOP | FOR | ELLIPSIS -> + | RAISE | TYPE | TYPEALIAS | STRUCT | TRAIT | TRAITALIAS | PACKAGE_NAME _ + | MUTABLE | MATCH | TRY | LET | CONST | IMPL | IMPORT | EXTERN | IF | GUARD + | WHILE | ASYNC | FN | EOF | ENUM | PUB | PRIV | READONLY | TEST | LOOP | FOR + | ELLIPSIS | POST_LABEL _ | ATTRIBUTE _ -> true | COMMENT _ | NEWLINE -> true | MINUS -> true @@ -53,9 +54,8 @@ let can_occur_after_semi (token : Menhir_token.token) = | RBRACE -> false | DOT_UIDENT _ | DOT_LIDENT _ | DOT_INT _ | COLONCOLON | RPAREN | RBRACKET | SEMI _ | FAT_ARROW | THIN_ARROW | IN | PIPE | EQUAL | AUGMENTED_ASSIGNMENT _ - | ELSE | CATCH | COMMA | COLON | BAR | AS | DOTDOT | DERIVE | POST_LABEL _ - | LABEL _ | WITH | QUESTION | RANGE_INCLUSIVE | RANGE_EXCLUSIVE | EXCLAMATION - -> + | ELSE | CATCH | COMMA | COLON | BAR | AS | IS | DOTDOT | DERIVE | WITH + | QUESTION | RANGE_INCLUSIVE | RANGE_EXCLUSIVE | EXCLAMATION -> false [@@inline] diff --git a/src/lex_token_triple.ml b/src/lex_token_triple.ml index 61c65ea..0542d00 100644 --- a/src/lex_token_triple.ml +++ b/src/lex_token_triple.ml @@ -17,15 +17,16 @@ module Menhir_token = Lex_menhir_token type t = Menhir_token.token * Lexing.position * Lexing.position -let sexp_of_t ((tok, a, b) : t) : S.t = - S.List - [ - Menhir_token.sexp_of_token tok; - Atom - (Printf.sprintf "%d:%d-%d:%d" a.pos_lnum - (a.pos_cnum - a.pos_bol + 1) - b.pos_lnum - (b.pos_cnum - b.pos_bol + 1)); - ] +let sexp_of_t ((tok, a, b) : t) = + (S.List + [ + Menhir_token.sexp_of_token tok; + Atom + (Printf.sprintf "%d:%d-%d:%d" a.pos_lnum + (a.pos_cnum - a.pos_bol + 1) + b.pos_lnum + (b.pos_cnum - b.pos_bol + 1)); + ] + : S.t) let null : t = (Menhir_token.EOF, Lexing.dummy_pos, Lexing.dummy_pos) diff --git a/src/lex_unicode_lex.ml b/src/lex_unicode_lex.ml index 1f63075..e7618a6 100644 --- a/src/lex_unicode_lex.ml +++ b/src/lex_unicode_lex.ml @@ -13,10 +13,10 @@ *) -let __sedlex_table_4 = +let __sedlex_table_3 = "\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_11 = +let __sedlex_table_9 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\000\000\000\000\001\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001" let __sedlex_table_28 = "\001\001\001\001\001\001\001\001\001\001\000\001\001" @@ -24,7 +24,7 @@ let __sedlex_table_28 = "\001\001\001\001\001\001\001\001\001\001\000\001\001" let __sedlex_table_35 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002" -let __sedlex_table_9 = +let __sedlex_table_7 = "\001\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001" let __sedlex_table_39 = @@ -33,16 +33,16 @@ let __sedlex_table_39 = let __sedlex_table_42 = "\001\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001" -let __sedlex_table_22 = +let __sedlex_table_21 = "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001" -let __sedlex_table_23 = +let __sedlex_table_22 = "\001\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\000\000\000\000\002\000\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002" -let __sedlex_table_24 = +let __sedlex_table_23 = "\001\000\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\003" -let __sedlex_table_17 = "\001\002" +let __sedlex_table_16 = "\001\002" let __sedlex_table_38 = "\001\000\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\004\000\004\005\000\000\000\000\000\006\000\000\007\000\000\000\000\000\000\002\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\005\000\000\000\000\000\000\000\000\007" @@ -50,55 +50,58 @@ let __sedlex_table_38 = let __sedlex_table_43 = "\001\000\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\002\002\002\002\002\002\000\000\000\000\000\003\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\002\000\002\002\002\002\002\002" -let __sedlex_table_8 = +let __sedlex_table_6 = "\001\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_25 = +let __sedlex_table_24 = "\001\000\000\000\000\000\000\000\000\000\000\000\000\000\002\003" -let __sedlex_table_20 = +let __sedlex_table_19 = "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001\001\001" let __sedlex_table_29 = "\001\000\001\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\001\003\000\000\001\000\001\000\000\000\004" -let __sedlex_table_2 = +let __sedlex_table_1 = "\001\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\001\002\000\000\001\000\001\003\000\000\004" -let __sedlex_table_5 = +let __sedlex_table_4 = "\001\000\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\002\002\002\002\002\002\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\002\002\002\002\002\002\000\000\000\000\000\000\000\000\000\003" -let __sedlex_table_19 = "\001\000\002\002\002\002\002\002\002\002\002\002" +let __sedlex_table_18 = "\001\000\002\002\002\002\002\002\002\002\002\002" + +let __sedlex_table_31 = + "\001\002\002\002\002\002\002\002\002\002\002\003\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003" -let __sedlex_table_10 = +let __sedlex_table_8 = "\001\000\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_27 = +let __sedlex_table_26 = "\001\000\002\002\002\002\002\002\002\002\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_26 = +let __sedlex_table_25 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\002\002\002\002\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002" -let __sedlex_table_15 = - "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\002\002\002\002\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\003" +let __sedlex_table_14 = + "\001\001\001\001\001\001\001\001\001\001\000\001\001\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002" -let __sedlex_table_16 = +let __sedlex_table_15 = "\001\000\001\000\000\002\002\002\002\002\002\002\002\002\002" -let __sedlex_table_33 = - "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002" +let __sedlex_table_34 = + "\001\001\001\001\001\001\001\001\001\001\000\001\001\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\002\002\002\002\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\003" -let __sedlex_table_12 = "\001\000\000\000\000\002" +let __sedlex_table_10 = "\001\000\000\000\000\002" -let __sedlex_table_34 = +let __sedlex_table_12 = "\001\002\002\002\002\002\002\002\002\002\003\004\003\003\005\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\006\007\b\t\n\ \011\012\r\014\015\016\017\018\019\020\021\022\022\022\022\022\022\022\022\022\023\024\025\026\027\028\029\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\030\002\031 \ - \002\002\002!\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\"#$%\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002" + \002\002\002!\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\"#$\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002" let __sedlex_table_36 = "\001\002\002\002\002\002\002\002\002\002\003\004\003\003\004\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\005\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002" -let __sedlex_table_14 = +let __sedlex_table_13 = "\001\002\002\002\002\002\002\002\002\002\002\003\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\004\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\005\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002" let __sedlex_table_30 = @@ -107,64 +110,55 @@ let __sedlex_table_30 = let __sedlex_table_41 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001" -let __sedlex_table_31 = +let __sedlex_table_32 = "\001\001\001\001\001\001\001\001\001\001\000\001\001\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002" -let __sedlex_table_21 = +let __sedlex_table_20 = "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_3 = +let __sedlex_table_2 = "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_7 = +let __sedlex_table_5 = "\001\002\002\002\002\002\002\002\002\002\002\003\002\002\003\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\004\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\005" -let __sedlex_table_13 = +let __sedlex_table_37 = + "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\000\002" + +let __sedlex_table_11 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\002\002" -let __sedlex_table_32 = - "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002" +let __sedlex_table_27 = + "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\002\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\002\003\001\001\002\001\002\001\001\001\004" -let __sedlex_table_37 = - "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\002\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\002\003\001\001\002\001\002\004\001\001\005" +let __sedlex_table_33 = + "\001\001\001\001\001\001\001\001\001\001\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002" let __sedlex_table_40 = "\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002" -let __sedlex_table_1 = - "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\002\002\002\002\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\002\002\002\002\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\003" - -let __sedlex_table_6 = - "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002" - -let __sedlex_table_18 = +let __sedlex_table_17 = "\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\002\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\002\001\001\001\001\001\002\001\001\001\001\001\001\001\001\001\001\001\002\003\001\001\002\001\002\004\001\001\005\001\001\006" -let __sedlex_partition_16 c = - let open! Stdlib in - if c <= -1 then -1 - else if c <= 123 then Char.code (String.unsafe_get __sedlex_table_1 c) - 1 - else 0 - -let __sedlex_partition_27 c = +let __sedlex_partition_28 c = let open! Stdlib in if c <= 31 then -1 else if c <= 120 then - Char.code (String.unsafe_get __sedlex_table_2 (c - 32)) - 1 + Char.code (String.unsafe_get __sedlex_table_1 (c - 32)) - 1 else -1 let __sedlex_partition_50 c = let open! Stdlib in if c <= 47 then -1 else if c <= 112 then - Char.code (String.unsafe_get __sedlex_table_3 (c - 48)) - 1 + Char.code (String.unsafe_get __sedlex_table_2 (c - 48)) - 1 else -1 let __sedlex_partition_58 c = let open! Stdlib in if c <= 61 then -1 else if c <= 124 then - Char.code (String.unsafe_get __sedlex_table_4 (c - 62)) - 1 + Char.code (String.unsafe_get __sedlex_table_3 (c - 62)) - 1 else -1 let __sedlex_partition_43 c = @@ -175,21 +169,15 @@ let __sedlex_partition_49 c = let open! Stdlib in if c <= 45 then -1 else if c <= 112 then - Char.code (String.unsafe_get __sedlex_table_5 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_4 (c - 46)) - 1 else -1 -let __sedlex_partition_6 c = - let open! Stdlib in - if c <= -1 then -1 - else if c <= 123 then Char.code (String.unsafe_get __sedlex_table_6 c) - 1 - else 0 - -let __sedlex_partition_14 c = +let __sedlex_partition_12 c = let open! Stdlib in - if c <= 92 then Char.code (String.unsafe_get __sedlex_table_7 (c - -1)) - 1 + if c <= 92 then Char.code (String.unsafe_get __sedlex_table_5 (c - -1)) - 1 else 1 -let __sedlex_partition_28 c = +let __sedlex_partition_29 c = let open! Stdlib in if c <= 47 then -1 else if c <= 51 then 0 else -1 @@ -197,14 +185,14 @@ let __sedlex_partition_46 c = let open! Stdlib in if c <= 45 then -1 else if c <= 95 then - Char.code (String.unsafe_get __sedlex_table_8 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_6 (c - 46)) - 1 else -1 -let __sedlex_partition_18 c = +let __sedlex_partition_17 c = let open! Stdlib in if c <= 8 then -1 else if c <= 5760 then - Char.code (String.unsafe_get __sedlex_table_9 (c - 9)) - 1 + Char.code (String.unsafe_get __sedlex_table_7 (c - 9)) - 1 else if c <= 8191 then -1 else if c <= 65279 then if c <= 12288 then @@ -225,14 +213,14 @@ let __sedlex_partition_47 c = let open! Stdlib in if c <= 45 then -1 else if c <= 95 then - Char.code (String.unsafe_get __sedlex_table_10 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_8 (c - 46)) - 1 else -1 let __sedlex_partition_53 c = let open! Stdlib in if c <= 64 then -1 else if c <= 122 then - Char.code (String.unsafe_get __sedlex_table_11 (c - 65)) - 1 + Char.code (String.unsafe_get __sedlex_table_9 (c - 65)) - 1 else -1 let __sedlex_partition_21 c = @@ -243,24 +231,39 @@ let __sedlex_partition_55 c = let open! Stdlib in if c <= 33 then -1 else if c <= 39 then - Char.code (String.unsafe_get __sedlex_table_12 (c - 34)) - 1 + Char.code (String.unsafe_get __sedlex_table_10 (c - 34)) - 1 else -1 let __sedlex_partition_5 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 55 then Char.code (String.unsafe_get __sedlex_table_13 c) - 1 + else if c <= 55 then Char.code (String.unsafe_get __sedlex_table_11 c) - 1 else 0 +let __sedlex_partition_19 c = + let open! Stdlib in + if c <= 8191 then Char.code (String.unsafe_get __sedlex_table_12 (c - -1)) - 1 + else if c <= 12287 then + if c <= 8238 then + if c <= 8231 then if c <= 8202 then 2 else 1 + else if c <= 8233 then 3 + else 1 + else if c <= 8286 then if c <= 8239 then 2 else 1 + else if c <= 8287 then 2 + else 1 + else if c <= 65278 then if c <= 12288 then 2 else 1 + else if c <= 65279 then 2 + else 1 + let __sedlex_partition_1 c = let open! Stdlib in - if c <= 127 then Char.code (String.unsafe_get __sedlex_table_14 (c - -1)) - 1 + if c <= 127 then Char.code (String.unsafe_get __sedlex_table_13 (c - -1)) - 1 else 5 -let __sedlex_partition_17 c = +let __sedlex_partition_16 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 125 then Char.code (String.unsafe_get __sedlex_table_15 c) - 1 + else if c <= 125 then Char.code (String.unsafe_get __sedlex_table_14 c) - 1 else 0 let __sedlex_partition_35 c = @@ -271,55 +274,55 @@ let __sedlex_partition_40 c = let open! Stdlib in if c <= 42 then -1 else if c <= 57 then - Char.code (String.unsafe_get __sedlex_table_16 (c - 43)) - 1 + Char.code (String.unsafe_get __sedlex_table_15 (c - 43)) - 1 else -1 let __sedlex_partition_52 c = let open! Stdlib in if c <= 59 then -1 else if c <= 61 then - Char.code (String.unsafe_get __sedlex_table_17 (c - 60)) - 1 + Char.code (String.unsafe_get __sedlex_table_16 (c - 60)) - 1 else -1 -let __sedlex_partition_15 c = +let __sedlex_partition_13 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 123 then Char.code (String.unsafe_get __sedlex_table_18 c) - 1 + else if c <= 123 then Char.code (String.unsafe_get __sedlex_table_17 c) - 1 else 0 let __sedlex_partition_33 c = let open! Stdlib in if c <= 45 then -1 else if c <= 57 then - Char.code (String.unsafe_get __sedlex_table_19 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_18 (c - 46)) - 1 else -1 -let __sedlex_partition_13 c = +let __sedlex_partition_11 c = let open! Stdlib in if c <= 47 then -1 else if c <= 102 then - Char.code (String.unsafe_get __sedlex_table_20 (c - 48)) - 1 + Char.code (String.unsafe_get __sedlex_table_19 (c - 48)) - 1 else -1 -let __sedlex_partition_22 c = - let open! Stdlib in - if c <= 123 then -1 else if c <= 124 then 0 else -1 - -let __sedlex_partition_30 c = +let __sedlex_partition_14 c = let open! Stdlib in if c <= 47 then -1 else if c <= 123 then - Char.code (String.unsafe_get __sedlex_table_21 (c - 48)) - 1 + Char.code (String.unsafe_get __sedlex_table_20 (c - 48)) - 1 else -1 +let __sedlex_partition_24 c = + let open! Stdlib in + if c <= 123 then -1 else if c <= 124 then 0 else -1 + let __sedlex_partition_41 c = let open! Stdlib in if c <= 47 then -1 else if c <= 95 then - Char.code (String.unsafe_get __sedlex_table_22 (c - 48)) - 1 + Char.code (String.unsafe_get __sedlex_table_21 (c - 48)) - 1 else -1 -let __sedlex_partition_26 c = +let __sedlex_partition_27 c = let open! Stdlib in if c <= 38 then -1 else if c <= 39 then 0 else -1 @@ -327,37 +330,37 @@ let __sedlex_partition_32 c = let open! Stdlib in if c <= 60 then -1 else if c <= 62 then - Char.code (String.unsafe_get __sedlex_table_17 (c - 61)) - 1 + Char.code (String.unsafe_get __sedlex_table_16 (c - 61)) - 1 else -1 let __sedlex_partition_54 c = let open! Stdlib in if c <= 46 then -1 else if c <= 122 then - Char.code (String.unsafe_get __sedlex_table_23 (c - 47)) - 1 + Char.code (String.unsafe_get __sedlex_table_22 (c - 47)) - 1 else -1 let __sedlex_partition_38 c = let open! Stdlib in if c <= 45 then -1 else if c <= 101 then - Char.code (String.unsafe_get __sedlex_table_24 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_23 (c - 46)) - 1 else -1 let __sedlex_partition_34 c = let open! Stdlib in if c <= 45 then -1 else if c <= 61 then - Char.code (String.unsafe_get __sedlex_table_25 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_24 (c - 46)) - 1 else -1 -let __sedlex_partition_8 c = +let __sedlex_partition_6 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 102 then Char.code (String.unsafe_get __sedlex_table_26 c) - 1 + else if c <= 102 then Char.code (String.unsafe_get __sedlex_table_25 c) - 1 else 0 -let __sedlex_partition_29 c = +let __sedlex_partition_30 c = let open! Stdlib in if c <= 47 then -1 else if c <= 55 then 0 else -1 @@ -365,9 +368,15 @@ let __sedlex_partition_42 c = let open! Stdlib in if c <= 45 then -1 else if c <= 95 then - Char.code (String.unsafe_get __sedlex_table_27 (c - 46)) - 1 + Char.code (String.unsafe_get __sedlex_table_26 (c - 46)) - 1 else -1 +let __sedlex_partition_2 c = + let open! Stdlib in + if c <= -1 then -1 + else if c <= 120 then Char.code (String.unsafe_get __sedlex_table_27 c) - 1 + else 0 + let __sedlex_partition_23 c = let open! Stdlib in if c <= -1 then -1 @@ -382,7 +391,7 @@ let __sedlex_partition_57 c = Char.code (String.unsafe_get __sedlex_table_29 (c - 32)) - 1 else -1 -let __sedlex_partition_11 c = +let __sedlex_partition_9 c = let open! Stdlib in if c <= 91 then -1 else if c <= 92 then 0 else -1 @@ -393,51 +402,41 @@ let __sedlex_partition_36 c = Char.code (String.unsafe_get __sedlex_table_30 (c - 47)) - 1 else -1 +let __sedlex_partition_18 c = + let open! Stdlib in + if c <= 39 then Char.code (String.unsafe_get __sedlex_table_31 (c - -1)) - 1 + else 1 + let __sedlex_partition_20 c = let open! Stdlib in if c <= 9 then -1 else if c <= 10 then 0 else -1 -let __sedlex_partition_25 c = +let __sedlex_partition_26 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 92 then Char.code (String.unsafe_get __sedlex_table_31 c) - 1 + else if c <= 92 then Char.code (String.unsafe_get __sedlex_table_32 c) - 1 else 0 let __sedlex_partition_31 c = let open! Stdlib in if c <= 47 then -1 else if c <= 125 then - Char.code (String.unsafe_get __sedlex_table_32 (c - 48)) - 1 + Char.code (String.unsafe_get __sedlex_table_33 (c - 48)) - 1 else -1 -let __sedlex_partition_7 c = +let __sedlex_partition_15 c = let open! Stdlib in if c <= -1 then -1 - else if c <= 125 then Char.code (String.unsafe_get __sedlex_table_33 c) - 1 + else if c <= 125 then Char.code (String.unsafe_get __sedlex_table_34 c) - 1 else 0 -let __sedlex_partition_19 c = - let open! Stdlib in - if c <= 8191 then Char.code (String.unsafe_get __sedlex_table_34 (c - -1)) - 1 - else if c <= 12287 then - if c <= 8238 then - if c <= 8231 then if c <= 8202 then 2 else 1 - else if c <= 8233 then 3 - else 1 - else if c <= 8286 then if c <= 8239 then 2 else 1 - else if c <= 8287 then 2 - else 1 - else if c <= 65278 then if c <= 12288 then 2 else 1 - else if c <= 65279 then 2 - else 1 - let __sedlex_partition_3 c = let open! Stdlib in if c <= -1 then -1 else if c <= 51 then Char.code (String.unsafe_get __sedlex_table_35 c) - 1 else 0 -let __sedlex_partition_9 c = +let __sedlex_partition_7 c = let open! Stdlib in if c <= 8191 then Char.code (String.unsafe_get __sedlex_table_36 (c - -1)) - 1 else if c <= 65278 then @@ -451,11 +450,12 @@ let __sedlex_partition_9 c = else if c <= 65279 then 2 else 1 -let __sedlex_partition_2 c = +let __sedlex_partition_22 c = let open! Stdlib in - if c <= -1 then -1 - else if c <= 120 then Char.code (String.unsafe_get __sedlex_table_37 c) - 1 - else 0 + if c <= 64 then -1 + else if c <= 124 then + Char.code (String.unsafe_get __sedlex_table_37 (c - 65)) - 1 + else -1 let __sedlex_partition_37 c = let open! Stdlib in @@ -475,11 +475,11 @@ let __sedlex_partition_4 c = let open! Stdlib in if c <= -1 then -1 else 0 -let __sedlex_partition_12 c = +let __sedlex_partition_10 c = let open! Stdlib in if c <= 116 then -1 else if c <= 117 then 0 else -1 -let __sedlex_partition_24 c = +let __sedlex_partition_25 c = let open! Stdlib in if c <= 37 then -1 else if c <= 38 then 0 else -1 @@ -496,7 +496,7 @@ let __sedlex_partition_56 c = else if c <= 127 then Char.code (String.unsafe_get __sedlex_table_41 c) - 1 else -1 -let __sedlex_partition_10 c = +let __sedlex_partition_8 c = let open! Stdlib in if c <= 8 then -1 else if c <= 5760 then @@ -545,11 +545,12 @@ type lexical_error = | Unterminated_bytes | Interp_invalid_multiline_string | Interp_invalid_comment + | Interp_invalid_attribute | Interp_missing_expression | Invalid_escape_sequence of string | Non_ascii_in_bytes of string - | Empty_label - | Invalid_label_name of string + | Invalid_dot_int of string + | Invalid_byte_literal of string include struct let _ = fun (_ : lexical_error) -> () @@ -566,6 +567,7 @@ include struct | Interp_invalid_multiline_string -> S.Atom "Interp_invalid_multiline_string" | Interp_invalid_comment -> S.Atom "Interp_invalid_comment" + | Interp_invalid_attribute -> S.Atom "Interp_invalid_attribute" | Interp_missing_expression -> S.Atom "Interp_missing_expression" | Invalid_escape_sequence arg0__003_ -> let res0__004_ = Moon_sexp_conv.sexp_of_string arg0__003_ in @@ -573,10 +575,12 @@ include struct | Non_ascii_in_bytes arg0__005_ -> let res0__006_ = Moon_sexp_conv.sexp_of_string arg0__005_ in S.List [ S.Atom "Non_ascii_in_bytes"; res0__006_ ] - | Empty_label -> S.Atom "Empty_label" - | Invalid_label_name arg0__007_ -> + | Invalid_dot_int arg0__007_ -> let res0__008_ = Moon_sexp_conv.sexp_of_string arg0__007_ in - S.List [ S.Atom "Invalid_label_name"; res0__008_ ] + S.List [ S.Atom "Invalid_dot_int"; res0__008_ ] + | Invalid_byte_literal arg0__009_ -> + let res0__010_ = Moon_sexp_conv.sexp_of_string arg0__009_ in + S.List [ S.Atom "Invalid_byte_literal"; res0__010_ ] : lexical_error -> S.t) let _ = sexp_of_lexical_error @@ -592,20 +596,24 @@ let lexing_error ~loc_start ~loc_end err = | Interp_invalid_multiline_string -> "invalid multiline string in string interpolation" | Interp_invalid_comment -> "invalid comment in string interpolation" + | Interp_invalid_attribute -> "invalid attribute in string interpolation" | Interp_missing_expression -> "missing expression in string interpolation" | Unterminated_string_in_variable_interploation -> "(unterminated string in variable interpolation)" | Invalid_escape_sequence seq -> "invalid escape sequence: " ^ seq - | Empty_label -> "label cannot be empty" - | Invalid_label_name s -> - ("invalid label name '" ^ s ^ "'" : Stdlib.String.t) | Non_ascii_in_bytes s -> ("non-ASCII character is not allowed in bytes literal. If you meant to \ use the UTF-8 encoding of '" ^ s ^ "', use escape sequence instead." : Stdlib.String.t) + [@merlin.hide] + | Invalid_dot_int s -> + ("invalid tuple accessor: ." ^ s : Stdlib.String.t) [@merlin.hide] + | Invalid_byte_literal s -> + ("invalid byte literal: " ^ s : Stdlib.String.t) [@merlin.hide] in Errors.lexing_error ~loc_start ~loc_end message +module Basic_lexing = Lexing module Lexing = Lex_moon_rt module Lex_env : sig @@ -698,42 +706,48 @@ let char_for_backslash : int -> Uchar.t = exception Overflow_max_codepoint let char_code_for_hex_escape : int array -> int -> int -> int = - fun buf pos len -> - let end_pos = pos + len in - let rec aux code pos = - if code > 0x10ffff then raise Overflow_max_codepoint - else if pos = end_pos then code - else - let digit = buf.(pos) in - aux ((code lsl 4) + digit_value digit) (pos + 1) - in - aux 0 pos + fun buf -> + fun pos -> + fun len -> + let end_pos = pos + len in + let rec aux code pos = + if code > 0x10ffff then raise Overflow_max_codepoint + else if pos = end_pos then code + else + let digit = buf.(pos) in + aux ((code lsl 4) + digit_value digit) (pos + 1) + in + aux 0 pos [@@inline] let char_for_hex_escape : int array -> int -> int -> Uchar.t = - fun buf pos len -> Uchar.of_int (char_code_for_hex_escape buf pos len) + fun buf -> + fun pos -> fun len -> Uchar.of_int (char_code_for_hex_escape buf pos len) [@@inline] let char_for_oct_escape : int array -> int -> int -> Uchar.t = - fun buf pos len -> - let end_pos = pos + len in - let rec aux code pos = - if code > 0x10ffff then raise Overflow_max_codepoint - else if pos = end_pos then code - else - let digit = buf.(pos) in - aux ((code lsl 3) + digit_value digit) (pos + 1) - in - Uchar.of_int (aux 0 pos) + fun buf -> + fun pos -> + fun len -> + let end_pos = pos + len in + let rec aux code pos = + if code > 0x10ffff then raise Overflow_max_codepoint + else if pos = end_pos then code + else + let digit = buf.(pos) in + aux ((code lsl 3) + digit_value digit) (pos + 1) + in + Uchar.of_int (aux 0 pos) [@@inline] -let make_pos ~(env : Lex_env.t) cnum : Stdlib.Lexing.position = - { - pos_fname = env.name; - pos_lnum = env.current_line; - pos_cnum = env.start_cnum + cnum; - pos_bol = env.current_bol; - } +let make_pos ~(env : Lex_env.t) cnum = + ({ + pos_fname = env.name; + pos_lnum = env.current_line; + pos_cnum = env.start_cnum + cnum; + pos_bol = env.current_bol; + } + : Basic_lexing.position) [@@inline] let lexeme_spos ~env lexbuf = make_pos ~env (Lexing.lexeme_start lexbuf) @@ -755,767 +769,592 @@ let add_lexing_warning ~(env : Lex_env.t) lexbuf kind = let loc = Loc.of_menhir (a, b) in Diagnostics.add_warning env.diagnostics { Warnings.loc; kind } -let bytes ~env lexbuf : Menhir_token.token = - let buf = Buffer.create 20 in - let repr_buf = Buffer.create 20 in - let keep_going = ref true in - while !keep_going do - let rec __sedlex_state_0 = function - | lexbuf -> ( - match - __sedlex_partition_1 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 5 - | 1 -> 7 - | 2 -> 6 - | 3 -> 0 - | 4 -> __sedlex_state_5 lexbuf - | 5 -> 8 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_5 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_2 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | 1 -> 1 - | 2 -> __sedlex_state_8 lexbuf - | 3 -> __sedlex_state_14 lexbuf - | 4 -> __sedlex_state_25 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_8 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_3 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_9 lexbuf - | 1 -> __sedlex_state_11 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_9 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_10 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_10 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_11 = function - | lexbuf -> ( - match - __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_10 lexbuf - | 1 -> __sedlex_state_12 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_12 = function - | lexbuf -> ( - match - __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | 1 -> 3 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_14 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_6 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_15 lexbuf - | 1 -> __sedlex_state_18 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_15 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_16 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_16 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_17 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_17 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_18 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_19 lexbuf - | 1 -> __sedlex_state_24 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_19 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_20 lexbuf - | 1 -> __sedlex_state_23 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_20 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_21 lexbuf - | 1 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_21 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_22 lexbuf - | 1 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_22 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_22 lexbuf - | 1 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_23 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_24 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_17 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_25 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_26 lexbuf - | 1 -> __sedlex_state_27 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_26 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_27 = function - | lexbuf -> ( - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 4 - | 1 -> 2 - | _ -> Lex_moon_rt.backtrack lexbuf) - in - Lex_moon_rt.start lexbuf; - match __sedlex_state_0 lexbuf with - | 0 -> keep_going := false - | 1 -> - let c = - Lexing.current_code_point lexbuf - |> char_for_backslash |> Uchar.to_char - in - Buffer.add_char buf c; - Buffer.add_string repr_buf (lexeme lexbuf) - | 2 -> - let c = - char_for_hex_escape lexbuf.buf (lexbuf.pos - 2) 2 |> Uchar.to_char - in - Buffer.add_char buf c; - Buffer.add_string repr_buf (lexeme lexbuf) - | 3 -> - let c = - char_for_oct_escape lexbuf.buf (lexbuf.pos - 3) 3 |> Uchar.to_char - in - Buffer.add_char buf c; - Buffer.add_string repr_buf (lexeme lexbuf) - | 4 -> - add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)) - | 5 -> - add_lexing_error ~env lexbuf Unterminated_bytes; - keep_going := false - | 6 -> - Lexing.backoff lexbuf 1; - add_lexing_error ~env lexbuf Unterminated_bytes; - keep_going := false - | 7 -> - let c = Lexing.current_code_point lexbuf |> Char.chr in - Buffer.add_char buf c; - Buffer.add_char repr_buf c - | 8 -> add_lexing_error ~env lexbuf (Non_ascii_in_bytes (lexeme lexbuf)) - | _ -> assert false - done; - Menhir_token.BYTES - { bytes_val = Buffer.contents buf; bytes_repr = Buffer.contents repr_buf } - -let string ~env ~multiline_string lexbuf startpos : Literal.interp_elem list = - let buf = Buffer.create 20 in - let repr_buf = Buffer.create 20 in - let interps : Literal.interp_elem Vec.t = Vec.empty () in - let rec interp_handle () : int = - let rec __sedlex_state_0 = function - | lexbuf -> ( - match - __sedlex_partition_9 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 1 - | 1 -> 4 - | 2 -> __sedlex_state_3 lexbuf - | 3 -> 2 - | 4 -> 0 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_3 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 4; - match - __sedlex_partition_10 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_4 lexbuf - | 1 -> 0 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_4 = function - | lexbuf -> ( - match - __sedlex_partition_10 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_4 lexbuf - | 1 -> 0 - | _ -> Lex_moon_rt.backtrack lexbuf) - in - Lex_moon_rt.start lexbuf; - match __sedlex_state_0 lexbuf with - | 0 -> Lexing.lexeme_start lexbuf - | 1 -> - add_lexing_error ~env lexbuf Unterminated_string; - Lexing.lexeme_start lexbuf - | 2 -> - add_lexing_error ~env lexbuf - Unterminated_string_in_variable_interploation; - Lexing.backoff lexbuf 1; - Lexing.lexeme_start lexbuf - | 3 -> - add_lexing_error ~env lexbuf - Unterminated_string_in_variable_interploation; - Lexing.lexeme_start lexbuf - | 4 -> - let is_valid_interp c = - Uchar.is_valid c - && c <> Char.code '\n' - && c <> Char.code '"' - && c <> Char.code '{' - in - let head = Lexing.current_code_point lexbuf in - if is_valid_interp head then ( - Buffer.add_utf_8_uchar buf (Uchar.of_int head); - lex_unicode_ident lexbuf buf; - interp_handle ()) - else ( +let bytes ~env lexbuf = + (let buf = Buffer.create 20 in + let repr_buf = Buffer.create 20 in + let keep_going = ref true in + while !keep_going do + let rec __sedlex_state_0 = function + | lexbuf -> ( + match + __sedlex_partition_1 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 7 + | 1 -> 9 + | 2 -> 8 + | 3 -> 0 + | 4 -> __sedlex_state_5 lexbuf + | 5 -> 10 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_5 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 9; + match + __sedlex_partition_2 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 6 + | 1 -> 1 + | 2 -> __sedlex_state_8 lexbuf + | 3 -> __sedlex_state_15 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_8 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 6; + match + __sedlex_partition_3 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_9 lexbuf + | 1 -> __sedlex_state_12 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_9 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_10 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_10 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 5 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_12 = function + | lexbuf -> ( + match + __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_10 lexbuf + | 1 -> __sedlex_state_13 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_13 = function + | lexbuf -> ( + match + __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 5 + | 1 -> 4 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_15 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 6; + match + __sedlex_partition_6 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_16 lexbuf + | 1 -> __sedlex_state_18 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_16 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 3 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_18 = function + | lexbuf -> ( + match + __sedlex_partition_6 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 3 + | 1 -> 2 + | _ -> Lex_moon_rt.backtrack lexbuf) + in + Lex_moon_rt.start lexbuf; + match __sedlex_state_0 lexbuf with + | 0 -> keep_going := false + | 1 -> + let c = + Uchar.to_char (char_for_backslash (Lexing.current_code_point lexbuf)) + in + Buffer.add_char buf c; + Buffer.add_string repr_buf (lexeme lexbuf) + | 2 -> + let c = + Uchar.to_char (char_for_hex_escape lexbuf.buf (lexbuf.pos - 2) 2) + in + Buffer.add_char buf c; + Buffer.add_string repr_buf (lexeme lexbuf) + | 3 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)) + | 4 -> + let c = + Uchar.to_char (char_for_oct_escape lexbuf.buf (lexbuf.pos - 3) 3) + in + Buffer.add_char buf c; + Buffer.add_string repr_buf (lexeme lexbuf) + | 5 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)) + | 6 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)) + | 7 -> + add_lexing_error ~env lexbuf Unterminated_bytes; + keep_going := false + | 8 -> + Lexing.backoff lexbuf 1; + add_lexing_error ~env lexbuf Unterminated_bytes; + keep_going := false + | 9 -> + let c = Char.chr (Lexing.current_code_point lexbuf) in + Buffer.add_char buf c; + Buffer.add_char repr_buf c + | 10 -> add_lexing_error ~env lexbuf (Non_ascii_in_bytes (lexeme lexbuf)) + | _ -> assert false + done; + Menhir_token.BYTES + { bytes_val = Buffer.contents buf; bytes_repr = Buffer.contents repr_buf } + : Menhir_token.token) + +let string ~env ~multiline_string lexbuf startpos = + (let buf = Buffer.create 20 in + let repr_buf = Buffer.create 20 in + let interps : Literal.interp_elem Vec.t = Vec.empty () in + let rec interp_handle () = + (let rec __sedlex_state_0 = function + | lexbuf -> ( + match + __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 1 + | 1 -> 4 + | 2 -> __sedlex_state_3 lexbuf + | 3 -> 2 + | 4 -> 0 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_3 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 4; + match + __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_4 lexbuf + | 1 -> 0 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_4 = function + | lexbuf -> ( + match + __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_4 lexbuf + | 1 -> 0 + | _ -> Lex_moon_rt.backtrack lexbuf) + in + Lex_moon_rt.start lexbuf; + match __sedlex_state_0 lexbuf with + | 0 -> Lexing.lexeme_start lexbuf + | 1 -> + add_lexing_error ~env lexbuf Unterminated_string; + Lexing.lexeme_start lexbuf + | 2 -> add_lexing_error ~env lexbuf - (Illegal_character (Lexing.lexeme_start lexbuf)); - Buffer.add_utf_8_uchar buf - (Uchar.of_int (Lexing.current_code_point lexbuf)); - interp_handle ()) - | _ -> assert false - in - let rec normal ~startpos = - let rec __sedlex_state_0 = function - | lexbuf -> ( - match - __sedlex_partition_14 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 8 - | 1 -> 10 - | 2 -> 9 - | 3 -> 0 - | 4 -> __sedlex_state_5 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_5 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 10; - match - __sedlex_partition_15 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | 1 -> 1 - | 2 -> __sedlex_state_8 lexbuf - | 3 -> __sedlex_state_14 lexbuf - | 4 -> __sedlex_state_35 lexbuf - | 5 -> __sedlex_state_39 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_8 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_3 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_9 lexbuf - | 1 -> __sedlex_state_11 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_9 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_10 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_10 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_11 = function - | lexbuf -> ( - match - __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_10 lexbuf - | 1 -> __sedlex_state_12 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_12 = function - | lexbuf -> ( - match - __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | 1 -> 3 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_14 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_16 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_15 lexbuf - | 1 -> __sedlex_state_18 lexbuf - | 2 -> __sedlex_state_22 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_15 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_16 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_16 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_17 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_17 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_18 = function - | lexbuf -> ( - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_16 lexbuf - | 1 -> __sedlex_state_19 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_19 = function - | lexbuf -> ( - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_17 lexbuf - | 1 -> __sedlex_state_20 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_20 = function - | lexbuf -> ( - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | 1 -> 4 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_22 = function - | lexbuf -> ( - match - __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_23 lexbuf - | 1 -> __sedlex_state_28 lexbuf - | 2 -> __sedlex_state_34 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_23 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_24 lexbuf - | 1 -> __sedlex_state_27 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_24 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_25 lexbuf - | 1 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_25 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_26 lexbuf - | 1 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_26 = function - | lexbuf -> ( - match - __sedlex_partition_7 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_26 lexbuf - | 1 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_27 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_28 = function - | lexbuf -> ( - match - __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_24 lexbuf - | 1 -> __sedlex_state_29 lexbuf - | 2 -> __sedlex_state_33 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_29 = function - | lexbuf -> ( - match - __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_25 lexbuf - | 1 -> __sedlex_state_30 lexbuf - | 2 -> 5 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_30 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_26 lexbuf - | 1 -> __sedlex_state_31 lexbuf - | 2 -> 5 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_31 = function - | lexbuf -> ( - match - __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_26 lexbuf - | 1 -> __sedlex_state_31 lexbuf - | 2 -> 5 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_33 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 5; - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_34 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_17 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_35 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 7; - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_36 lexbuf - | 1 -> __sedlex_state_37 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_36 = function - | lexbuf -> ( - match - __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_37 = function - | lexbuf -> ( - match - __sedlex_partition_8 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 7 - | 1 -> 2 - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_39 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 6; - match - __sedlex_partition_18 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_40 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_40 = function - | lexbuf -> ( - Lex_moon_rt.mark lexbuf 6; - match - __sedlex_partition_18 (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_40 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - in - Lex_moon_rt.start lexbuf; - match __sedlex_state_0 lexbuf with - | 0 -> - if multiline_string then ( - Buffer.add_utf_8_uchar buf - (Lexing.current_code_point lexbuf |> Uchar.of_int); - Buffer.add_utf_8_uchar repr_buf - (Lexing.current_code_point lexbuf |> Uchar.of_int); - normal ~startpos) - else if Buffer.length buf <> 0 then - Vec.push interps - (Literal.Interp_lit - { - c = Buffer.contents buf; - repr = Buffer.contents repr_buf; - loc_ = - Loc.of_menhir - ( make_pos ~env startpos, - make_pos ~env (Lexing.lexeme_end lexbuf) ); - }) - | 1 -> - let s = Lexing.current_code_point lexbuf in - Buffer.add_utf_8_uchar buf (char_for_backslash s); - Buffer.add_string repr_buf (lexeme lexbuf); - normal ~startpos - | 2 -> - Buffer.add_utf_8_uchar buf - (char_for_hex_escape lexbuf.buf (lexbuf.pos - 2) 2); - Buffer.add_string repr_buf (lexeme lexbuf); - normal ~startpos - | 3 -> - Buffer.add_utf_8_uchar buf - (char_for_oct_escape lexbuf.buf (lexbuf.pos - 3) 3); - Buffer.add_string repr_buf (lexeme lexbuf); - normal ~startpos - | 4 -> - let code = char_code_for_hex_escape lexbuf.buf (lexbuf.pos - 4) 4 in - (if 0xD800 <= code && code <= 0xDBFF then ( - let first_code_repr = lexeme lexbuf in - Buffer.add_string repr_buf first_code_repr; - let rec __sedlex_state_0 = function - | lexbuf -> ( - match - __sedlex_partition_11 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_1 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_1 = function - | lexbuf -> ( - match - __sedlex_partition_12 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_2 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_2 = function - | lexbuf -> ( - match - __sedlex_partition_13 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_3 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_3 = function - | lexbuf -> ( - match - __sedlex_partition_13 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_4 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_4 = function - | lexbuf -> ( - match - __sedlex_partition_13 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> __sedlex_state_5 lexbuf - | _ -> Lex_moon_rt.backtrack lexbuf) - and __sedlex_state_5 = function - | lexbuf -> ( - match - __sedlex_partition_13 - (Lex_moon_rt.__private__next_int lexbuf) - with - | 0 -> 0 - | _ -> Lex_moon_rt.backtrack lexbuf) - in - Lex_moon_rt.start lexbuf; - match __sedlex_state_0 lexbuf with - | 0 -> - let second_code_repr = lexeme lexbuf in - Buffer.add_string repr_buf second_code_repr; - let code2 = - char_code_for_hex_escape lexbuf.buf (lexbuf.pos - 4) 4 - in - if code2 >= 0xDC00 then - let actual_code = - ((code - 0xD800) lsl 10) + (code2 - 0xDC00) + 0x10000 - in - if Uchar.is_valid actual_code then - Buffer.add_utf_8_uchar buf (Uchar.of_int actual_code) - else - add_lexing_error ~env lexbuf - (Invalid_escape_sequence - (first_code_repr ^ second_code_repr)) - else - add_lexing_error ~env lexbuf - (Invalid_escape_sequence (first_code_repr ^ second_code_repr)) - | _ -> - add_lexing_error ~env lexbuf - (Invalid_escape_sequence first_code_repr)) - else if Uchar.is_valid code then ( - Buffer.add_utf_8_uchar buf (Uchar.unsafe_of_int code); - Buffer.add_string repr_buf (lexeme lexbuf)) - else - let code_repr = lexeme lexbuf in - Buffer.add_string repr_buf code_repr; - add_lexing_error ~env lexbuf (Invalid_escape_sequence code_repr)); - normal ~startpos - | 5 -> - (try + Unterminated_string_in_variable_interploation; + Lexing.backoff lexbuf 1; + Lexing.lexeme_start lexbuf + | 3 -> + add_lexing_error ~env lexbuf + Unterminated_string_in_variable_interploation; + Lexing.lexeme_start lexbuf + | 4 -> + let is_valid_interp c = + Uchar.is_valid c + && c <> Char.code '\n' + && c <> Char.code '"' + && c <> Char.code '{' + in + let head = Lexing.current_code_point lexbuf in + if is_valid_interp head then ( + Buffer.add_utf_8_uchar buf (Uchar.of_int head); + lex_unicode_ident lexbuf buf; + interp_handle ()) + else ( + add_lexing_error ~env lexbuf + (Illegal_character (Lexing.lexeme_start lexbuf)); + Buffer.add_utf_8_uchar buf + (Uchar.of_int (Lexing.current_code_point lexbuf)); + interp_handle ()) + | _ -> assert false + : int) + in + let rec normal ~startpos = + let rec __sedlex_state_0 = function + | lexbuf -> ( + match + __sedlex_partition_12 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 11 + | 1 -> 13 + | 2 -> 12 + | 3 -> 0 + | 4 -> __sedlex_state_5 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_5 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 13; + match + __sedlex_partition_13 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 10 + | 1 -> 1 + | 2 -> __sedlex_state_8 lexbuf + | 3 -> __sedlex_state_15 lexbuf + | 4 -> __sedlex_state_25 lexbuf + | 5 -> __sedlex_state_30 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_8 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 10; + match + __sedlex_partition_3 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_9 lexbuf + | 1 -> __sedlex_state_12 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_9 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_10 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_10 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 5 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_12 = function + | lexbuf -> ( + match + __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_10 lexbuf + | 1 -> __sedlex_state_13 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_13 = function + | lexbuf -> ( + match + __sedlex_partition_5 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 5 + | 1 -> 4 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_15 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 10; + match + __sedlex_partition_14 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_16 lexbuf + | 1 -> __sedlex_state_20 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_16 = function + | lexbuf -> ( + match + __sedlex_partition_11 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_17 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_17 = function + | lexbuf -> ( + match + __sedlex_partition_11 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_18 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_18 = function + | lexbuf -> ( + match + __sedlex_partition_11 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 6 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_20 = function + | lexbuf -> ( + match + __sedlex_partition_15 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_21 lexbuf + | 1 -> __sedlex_state_23 lexbuf + | 2 -> 8 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_21 = function + | lexbuf -> ( + match + __sedlex_partition_16 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_21 lexbuf + | 1 -> 8 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_23 = function + | lexbuf -> ( + match + __sedlex_partition_15 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_21 lexbuf + | 1 -> __sedlex_state_23 lexbuf + | 2 -> 7 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_25 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 10; + match + __sedlex_partition_6 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_26 lexbuf + | 1 -> __sedlex_state_28 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_26 = function + | lexbuf -> ( + match + __sedlex_partition_4 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 3 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_28 = function + | lexbuf -> ( + match + __sedlex_partition_6 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 3 + | 1 -> 2 + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_30 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 9; + match + __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_31 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_31 = function + | lexbuf -> ( + Lex_moon_rt.mark lexbuf 9; + match + __sedlex_partition_17 (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_31 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + in + Lex_moon_rt.start lexbuf; + match __sedlex_state_0 lexbuf with + | 0 -> + if multiline_string then ( Buffer.add_utf_8_uchar buf - (char_for_hex_escape lexbuf.buf (lexbuf.start_pos + 3) - (lexbuf.pos - lexbuf.start_pos - 4)) - with Overflow_max_codepoint -> - add_lexing_error ~env lexbuf - (Invalid_escape_sequence (lexeme lexbuf))); - Buffer.add_string repr_buf (lexeme lexbuf); - normal ~startpos - | 6 -> - if Buffer.length buf <> 0 then - Vec.push interps - (Literal.Interp_lit - { - c = Buffer.contents buf; - repr = Buffer.contents repr_buf; - loc_ = - Loc.of_menhir - ( make_pos ~env startpos, - make_pos ~env (Lexing.lexeme_start lexbuf) ); - }); - Buffer.clear buf; - Buffer.clear repr_buf; - let apos = Lexing.lexeme_end lexbuf in - let bpos = interp_handle () in - let loc = Loc.of_menhir (make_pos ~env apos, make_pos ~env bpos) in - if Buffer.length buf = 0 then - add_lexing_error ~env lexbuf Interp_missing_expression - else - Vec.push interps - (Literal.Interp_source { source = Buffer.contents buf; loc_ = loc }); - Buffer.clear buf; - let startpos = Lexing.lexeme_end lexbuf in - normal ~startpos - | 7 -> - add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)); - normal ~startpos - | 8 -> - add_lexing_error ~env lexbuf Unterminated_string; - if Buffer.length buf <> 0 then - Vec.push interps - (Literal.Interp_lit - { - c = Buffer.contents buf; - repr = Buffer.contents repr_buf; - loc_ = - Loc.of_menhir - ( make_pos ~env startpos, - make_pos ~env (Lexing.lexeme_end lexbuf) ); - }) - | 9 -> - Lexing.backoff lexbuf 1; - if not multiline_string then - add_lexing_error ~env lexbuf Unterminated_string; - if Buffer.length buf <> 0 then - Vec.push interps - (Literal.Interp_lit - { - c = Buffer.contents buf; - repr = Buffer.contents repr_buf; - loc_ = - Loc.of_menhir - ( make_pos ~env startpos, - make_pos ~env (Lexing.lexeme_end lexbuf) ); - }) - | 10 -> - Buffer.add_utf_8_uchar buf - (Lexing.current_code_point lexbuf |> Uchar.of_int); - Buffer.add_utf_8_uchar repr_buf - (Lexing.current_code_point lexbuf |> Uchar.of_int); - normal ~startpos - | _ -> assert false - in - normal ~startpos; - if Vec.is_empty interps then - [ - Literal.Interp_lit - { - c = ""; - repr = ""; - loc_ = - Loc.of_menhir - (make_pos ~env startpos, make_pos ~env (Lexing.lexeme_end lexbuf)); - }; - ] - else Vec.to_list interps + (Uchar.of_int (Lexing.current_code_point lexbuf)); + Buffer.add_utf_8_uchar repr_buf + (Uchar.of_int (Lexing.current_code_point lexbuf)); + normal ~startpos) + else if Buffer.length buf <> 0 then + Vec.push interps + (Literal.Interp_lit + { + c = Buffer.contents buf; + repr = Buffer.contents repr_buf; + loc_ = + Loc.of_menhir + ( make_pos ~env startpos, + make_pos ~env (Lexing.lexeme_end lexbuf) ); + }) + | 1 -> + let s = Lexing.current_code_point lexbuf in + Buffer.add_utf_8_uchar buf (char_for_backslash s); + Buffer.add_string repr_buf (lexeme lexbuf); + normal ~startpos + | 2 -> + Buffer.add_utf_8_uchar buf + (char_for_hex_escape lexbuf.buf (lexbuf.pos - 2) 2); + Buffer.add_string repr_buf (lexeme lexbuf); + normal ~startpos + | 3 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)); + normal ~startpos + | 4 -> + Buffer.add_utf_8_uchar buf + (char_for_oct_escape lexbuf.buf (lexbuf.pos - 3) 3); + Buffer.add_string repr_buf (lexeme lexbuf); + normal ~startpos + | 5 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)); + normal ~startpos + | 6 -> + let code = char_code_for_hex_escape lexbuf.buf (lexbuf.pos - 4) 4 in + (if 0xD800 <= code && code <= 0xDBFF then ( + let first_code_repr = lexeme lexbuf in + Buffer.add_string repr_buf first_code_repr; + let rec __sedlex_state_0 = function + | lexbuf -> ( + match + __sedlex_partition_9 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_1 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_1 = function + | lexbuf -> ( + match + __sedlex_partition_10 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_2 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_2 = function + | lexbuf -> ( + match + __sedlex_partition_11 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_3 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_3 = function + | lexbuf -> ( + match + __sedlex_partition_11 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_4 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_4 = function + | lexbuf -> ( + match + __sedlex_partition_11 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> __sedlex_state_5 lexbuf + | _ -> Lex_moon_rt.backtrack lexbuf) + and __sedlex_state_5 = function + | lexbuf -> ( + match + __sedlex_partition_11 + (Lex_moon_rt.__private__next_int lexbuf) + with + | 0 -> 0 + | _ -> Lex_moon_rt.backtrack lexbuf) + in + Lex_moon_rt.start lexbuf; + match __sedlex_state_0 lexbuf with + | 0 -> + let second_code_repr = lexeme lexbuf in + Buffer.add_string repr_buf second_code_repr; + let code2 = + char_code_for_hex_escape lexbuf.buf (lexbuf.pos - 4) 4 + in + if code2 >= 0xDC00 then + let actual_code = + ((code - 0xD800) lsl 10) + (code2 - 0xDC00) + 0x10000 + in + if Uchar.is_valid actual_code then + Buffer.add_utf_8_uchar buf (Uchar.of_int actual_code) + else + add_lexing_error ~env lexbuf + (Invalid_escape_sequence + (first_code_repr ^ second_code_repr)) + else + add_lexing_error ~env lexbuf + (Invalid_escape_sequence (first_code_repr ^ second_code_repr)) + | _ -> + add_lexing_error ~env lexbuf + (Invalid_escape_sequence first_code_repr)) + else if Uchar.is_valid code then ( + Buffer.add_utf_8_uchar buf (Uchar.unsafe_of_int code); + Buffer.add_string repr_buf (lexeme lexbuf)) + else + let code_repr = lexeme lexbuf in + Buffer.add_string repr_buf code_repr; + add_lexing_error ~env lexbuf (Invalid_escape_sequence code_repr)); + normal ~startpos + | 7 -> + (try + Buffer.add_utf_8_uchar buf + (char_for_hex_escape lexbuf.buf (lexbuf.start_pos + 3) + (lexbuf.pos - lexbuf.start_pos - 4)) + with Overflow_max_codepoint -> + add_lexing_error ~env lexbuf + (Invalid_escape_sequence (lexeme lexbuf))); + Buffer.add_string repr_buf (lexeme lexbuf); + normal ~startpos + | 8 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)); + normal ~startpos + | 9 -> + if Buffer.length buf <> 0 then + Vec.push interps + (Literal.Interp_lit + { + c = Buffer.contents buf; + repr = Buffer.contents repr_buf; + loc_ = + Loc.of_menhir + ( make_pos ~env startpos, + make_pos ~env (Lexing.lexeme_start lexbuf) ); + }); + Buffer.clear buf; + Buffer.clear repr_buf; + let apos = Lexing.lexeme_end lexbuf in + let bpos = interp_handle () in + let loc = Loc.of_menhir (make_pos ~env apos, make_pos ~env bpos) in + if Buffer.length buf = 0 then + add_lexing_error ~env lexbuf Interp_missing_expression + else + Vec.push interps + (Literal.Interp_source { source = Buffer.contents buf; loc_ = loc }); + Buffer.clear buf; + let startpos = Lexing.lexeme_end lexbuf in + normal ~startpos + | 10 -> + add_lexing_error ~env lexbuf (Invalid_escape_sequence (lexeme lexbuf)); + normal ~startpos + | 11 -> + add_lexing_error ~env lexbuf Unterminated_string; + if Buffer.length buf <> 0 then + Vec.push interps + (Literal.Interp_lit + { + c = Buffer.contents buf; + repr = Buffer.contents repr_buf; + loc_ = + Loc.of_menhir + ( make_pos ~env startpos, + make_pos ~env (Lexing.lexeme_end lexbuf) ); + }) + | 12 -> + Lexing.backoff lexbuf 1; + if not multiline_string then + add_lexing_error ~env lexbuf Unterminated_string; + if Buffer.length buf <> 0 then + Vec.push interps + (Literal.Interp_lit + { + c = Buffer.contents buf; + repr = Buffer.contents repr_buf; + loc_ = + Loc.of_menhir + ( make_pos ~env startpos, + make_pos ~env (Lexing.lexeme_end lexbuf) ); + }) + | 13 -> + Buffer.add_utf_8_uchar buf + (Uchar.of_int (Lexing.current_code_point lexbuf)); + Buffer.add_utf_8_uchar repr_buf + (Uchar.of_int (Lexing.current_code_point lexbuf)); + normal ~startpos + | _ -> assert false + in + normal ~startpos; + if Vec.is_empty interps then + [ + Literal.Interp_lit + { + c = ""; + repr = ""; + loc_ = + Loc.of_menhir + (make_pos ~env startpos, make_pos ~env (Lexing.lexeme_end lexbuf)); + }; + ] + else Vec.to_list interps + : Literal.interp_elem list) let add_token ~(env : Lex_env.t) (tok : Menhir_token.token) sp ep = Semi_insertion.add_token env.asi_context ~tokens:env.vec tok @@ -1581,54 +1420,53 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = let rec __sedlex_state_0 = function | b -> ( match __sedlex_partition_19 (Lex_moon_rt.__private__next_int b) with - | 0 -> 62 - | 1 -> 63 + | 0 -> 63 + | 1 -> 64 | 2 -> __sedlex_state_3 b | 3 -> 0 | 4 -> __sedlex_state_6 b | 5 -> __sedlex_state_8 b | 6 -> 11 | 7 -> __sedlex_state_11 b - | 8 -> __sedlex_state_13 b - | 9 -> __sedlex_state_15 b - | 10 -> __sedlex_state_17 b - | 11 -> __sedlex_state_19 b - | 12 -> 26 - | 13 -> 27 - | 14 -> __sedlex_state_46 b - | 15 -> __sedlex_state_47 b - | 16 -> 33 - | 17 -> __sedlex_state_49 b - | 18 -> __sedlex_state_51 b - | 19 -> __sedlex_state_57 b - | 20 -> __sedlex_state_59 b - | 21 -> __sedlex_state_81 b - | 22 -> __sedlex_state_82 b - | 23 -> 39 - | 24 -> __sedlex_state_85 b - | 25 -> __sedlex_state_88 b - | 26 -> __sedlex_state_91 b - | 27 -> 54 - | 28 -> __sedlex_state_94 b - | 29 -> 46 - | 30 -> 48 - | 31 -> 25 - | 32 -> __sedlex_state_100 b - | 33 -> 47 - | 34 -> __sedlex_state_119 b - | 35 -> 49 - | 36 -> 36 + | 8 -> __sedlex_state_14 b + | 9 -> __sedlex_state_16 b + | 10 -> __sedlex_state_18 b + | 11 -> __sedlex_state_20 b + | 12 -> 28 + | 13 -> 29 + | 14 -> __sedlex_state_47 b + | 15 -> __sedlex_state_48 b + | 16 -> 35 + | 17 -> __sedlex_state_50 b + | 18 -> __sedlex_state_52 b + | 19 -> __sedlex_state_58 b + | 20 -> __sedlex_state_60 b + | 21 -> __sedlex_state_82 b + | 22 -> __sedlex_state_83 b + | 23 -> 40 + | 24 -> __sedlex_state_86 b + | 25 -> __sedlex_state_89 b + | 26 -> __sedlex_state_92 b + | 27 -> 55 + | 28 -> __sedlex_state_95 b + | 29 -> 47 + | 30 -> 49 + | 31 -> 27 + | 32 -> __sedlex_state_101 b + | 33 -> 48 + | 34 -> __sedlex_state_120 b + | 35 -> 50 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_3 = function | b -> ( Lex_moon_rt.mark b 1; - match __sedlex_partition_18 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_17 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_4 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_4 = function | b -> ( Lex_moon_rt.mark b 1; - match __sedlex_partition_18 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_17 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_4 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_6 = function @@ -1639,69 +1477,71 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_8 = function | b -> ( - Lex_moon_rt.mark b 55; + Lex_moon_rt.mark b 56; match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with - | 0 -> 44 + | 0 -> 45 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_11 = function | b -> ( - Lex_moon_rt.mark b 63; + Lex_moon_rt.mark b 64; match __sedlex_partition_22 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_12 b + | 1 -> __sedlex_state_13 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_12 = function | b -> ( - Lex_moon_rt.mark b 14; + Lex_moon_rt.mark b 15; match __sedlex_partition_23 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_12 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_13 = function | b -> ( - Lex_moon_rt.mark b 63; - match __sedlex_partition_22 (Lex_moon_rt.__private__next_int b) with - | 0 -> 13 + Lex_moon_rt.mark b 14; + match __sedlex_partition_23 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_13 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_15 = function + and __sedlex_state_14 = function | b -> ( - Lex_moon_rt.mark b 30; - match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with - | 0 -> 60 + Lex_moon_rt.mark b 64; + match __sedlex_partition_24 (Lex_moon_rt.__private__next_int b) with + | 0 -> 13 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_17 = function + and __sedlex_state_16 = function | b -> ( - Lex_moon_rt.mark b 24; - match __sedlex_partition_24 (Lex_moon_rt.__private__next_int b) with - | 0 -> 23 + Lex_moon_rt.mark b 32; + match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with + | 0 -> 61 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_19 = function + and __sedlex_state_18 = function | b -> ( - Lex_moon_rt.mark b 63; + Lex_moon_rt.mark b 26; match __sedlex_partition_25 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_20 b - | 1 -> __sedlex_state_22 b + | 0 -> 25 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_20 = function | b -> ( + Lex_moon_rt.mark b 64; match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 5 + | 0 -> __sedlex_state_21 b + | 1 -> __sedlex_state_23 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_22 = function + and __sedlex_state_21 = function | b -> ( match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_23 b - | 1 -> __sedlex_state_25 b - | 2 -> __sedlex_state_30 b - | 3 -> __sedlex_state_40 b + | 0 -> 5 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_23 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 6 + match __sedlex_partition_28 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_24 b + | 1 -> __sedlex_state_26 b + | 2 -> __sedlex_state_31 b + | 3 -> __sedlex_state_41 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_25 = function + and __sedlex_state_24 = function | b -> ( - match __sedlex_partition_28 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_26 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 6 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_26 = function | b -> ( @@ -1710,364 +1550,365 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_27 = function | b -> ( - match __sedlex_partition_29 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_28 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_28 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 8 + match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_29 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_30 = function + and __sedlex_state_29 = function | b -> ( - match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_31 b - | 1 -> __sedlex_state_36 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 8 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_31 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_14 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_32 b + | 1 -> __sedlex_state_37 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_32 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_33 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_33 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_34 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_34 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 9 + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_35 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_36 = function + and __sedlex_state_35 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_37 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 9 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_37 = function | b -> ( - match __sedlex_partition_31 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_37 b - | 1 -> __sedlex_state_38 b + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_38 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_38 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 10 + match __sedlex_partition_31 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_38 b + | 1 -> __sedlex_state_39 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_40 = function + and __sedlex_state_39 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_41 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 10 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_41 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_42 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_42 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 7 + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_43 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_46 = function + and __sedlex_state_43 = function | b -> ( - Lex_moon_rt.mark b 28; - match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with - | 0 -> 60 + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 7 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_47 = function | b -> ( - Lex_moon_rt.mark b 52; + Lex_moon_rt.mark b 30; match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with - | 0 -> 60 + | 0 -> 61 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_49 = function + and __sedlex_state_48 = function | b -> ( Lex_moon_rt.mark b 53; + match __sedlex_partition_21 (Lex_moon_rt.__private__next_int b) with + | 0 -> 61 + | _ -> Lex_moon_rt.backtrack b) + and __sedlex_state_50 = function + | b -> ( + Lex_moon_rt.mark b 54; match __sedlex_partition_32 (Lex_moon_rt.__private__next_int b) with - | 0 -> 60 + | 0 -> 61 | 1 -> 3 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_51 = function + and __sedlex_state_52 = function | b -> ( - Lex_moon_rt.mark b 35; + Lex_moon_rt.mark b 37; match __sedlex_partition_33 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_52 b - | 1 -> __sedlex_state_56 b + | 0 -> __sedlex_state_53 b + | 1 -> __sedlex_state_57 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_52 = function + and __sedlex_state_53 = function | b -> ( - Lex_moon_rt.mark b 56; + Lex_moon_rt.mark b 57; match __sedlex_partition_34 (Lex_moon_rt.__private__next_int b) with - | 0 -> 59 - | 1 -> 58 - | 2 -> 57 + | 0 -> 60 + | 1 -> 59 + | 2 -> 58 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_56 = function + and __sedlex_state_57 = function | b -> ( - Lex_moon_rt.mark b 34; + Lex_moon_rt.mark b 36; match __sedlex_partition_35 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_56 b + | 0 -> __sedlex_state_57 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_57 = function + and __sedlex_state_58 = function | b -> ( - Lex_moon_rt.mark b 29; + Lex_moon_rt.mark b 31; match __sedlex_partition_36 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_58 b - | 1 -> 60 + | 0 -> __sedlex_state_59 b + | 1 -> 61 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_58 = function + and __sedlex_state_59 = function | b -> ( Lex_moon_rt.mark b 4; match __sedlex_partition_23 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_58 b - | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_59 = function - | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_37 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_60 b - | 1 -> __sedlex_state_66 b - | 2 -> __sedlex_state_70 b - | 3 -> __sedlex_state_67 b - | 4 -> __sedlex_state_72 b - | 5 -> __sedlex_state_69 b - | 6 -> __sedlex_state_74 b + | 0 -> __sedlex_state_59 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_60 = function | b -> ( Lex_moon_rt.mark b 22; - match __sedlex_partition_38 (Lex_moon_rt.__private__next_int b) with - | 0 -> 21 - | 1 -> __sedlex_state_62 b - | 2 -> __sedlex_state_63 b + match __sedlex_partition_37 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_61 b + | 1 -> __sedlex_state_67 b + | 2 -> __sedlex_state_71 b + | 3 -> __sedlex_state_68 b + | 4 -> __sedlex_state_73 b + | 5 -> __sedlex_state_70 b + | 6 -> __sedlex_state_75 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_62 = function + and __sedlex_state_61 = function | b -> ( - Lex_moon_rt.mark b 22; - match __sedlex_partition_39 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_62 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_38 (Lex_moon_rt.__private__next_int b) with + | 0 -> 23 | 1 -> __sedlex_state_63 b + | 2 -> __sedlex_state_64 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_63 = function | b -> ( - match __sedlex_partition_40 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_64 b - | 1 -> __sedlex_state_65 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_39 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_63 b + | 1 -> __sedlex_state_64 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_64 = function | b -> ( - match __sedlex_partition_35 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_40 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_65 b + | 1 -> __sedlex_state_66 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_65 = function | b -> ( - Lex_moon_rt.mark b 22; - match __sedlex_partition_41 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_65 b + match __sedlex_partition_35 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_66 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_66 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_42 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_60 b - | 1 -> __sedlex_state_66 b - | 2 -> __sedlex_state_67 b - | 3 -> __sedlex_state_69 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_41 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_66 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_67 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_43 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_68 b + Lex_moon_rt.mark b 22; + match __sedlex_partition_42 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_61 b + | 1 -> __sedlex_state_67 b + | 2 -> __sedlex_state_68 b + | 3 -> __sedlex_state_70 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_68 = function | b -> ( + Lex_moon_rt.mark b 22; match __sedlex_partition_43 (Lex_moon_rt.__private__next_int b) with - | 0 -> 21 + | 0 -> __sedlex_state_69 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_69 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_44 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_68 b - | 1 -> __sedlex_state_67 b + match __sedlex_partition_43 (Lex_moon_rt.__private__next_int b) with + | 0 -> 23 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_70 = function | b -> ( - match __sedlex_partition_45 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_71 b + Lex_moon_rt.mark b 22; + match __sedlex_partition_44 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_69 b + | 1 -> __sedlex_state_68 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_71 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_46 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_68 b - | 1 -> __sedlex_state_71 b - | 2 -> __sedlex_state_67 b - | 3 -> __sedlex_state_69 b + match __sedlex_partition_45 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_72 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_72 = function | b -> ( - match __sedlex_partition_29 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_73 b + Lex_moon_rt.mark b 22; + match __sedlex_partition_46 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_69 b + | 1 -> __sedlex_state_72 b + | 2 -> __sedlex_state_68 b + | 3 -> __sedlex_state_70 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_73 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_47 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_68 b - | 1 -> __sedlex_state_73 b - | 2 -> __sedlex_state_67 b - | 3 -> __sedlex_state_69 b + match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_74 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_74 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_75 b + Lex_moon_rt.mark b 22; + match __sedlex_partition_47 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_69 b + | 1 -> __sedlex_state_74 b + | 2 -> __sedlex_state_68 b + | 3 -> __sedlex_state_70 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_75 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_48 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_76 b - | 1 -> __sedlex_state_75 b - | 2 -> __sedlex_state_67 b - | 3 -> __sedlex_state_69 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_76 = function | b -> ( Lex_moon_rt.mark b 22; - match __sedlex_partition_49 (Lex_moon_rt.__private__next_int b) with - | 0 -> 21 - | 1 -> __sedlex_state_77 b - | 2 -> __sedlex_state_78 b + match __sedlex_partition_48 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_77 b + | 1 -> __sedlex_state_76 b + | 2 -> __sedlex_state_68 b + | 3 -> __sedlex_state_70 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_77 = function | b -> ( - Lex_moon_rt.mark b 22; - match __sedlex_partition_50 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_77 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_49 (Lex_moon_rt.__private__next_int b) with + | 0 -> 23 | 1 -> __sedlex_state_78 b + | 2 -> __sedlex_state_79 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_78 = function | b -> ( - match __sedlex_partition_40 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_79 b - | 1 -> __sedlex_state_80 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_50 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_78 b + | 1 -> __sedlex_state_79 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_79 = function | b -> ( - match __sedlex_partition_35 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_40 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_80 b + | 1 -> __sedlex_state_81 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_80 = function | b -> ( - Lex_moon_rt.mark b 22; - match __sedlex_partition_41 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_80 b + match __sedlex_partition_35 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_81 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_81 = function | b -> ( - Lex_moon_rt.mark b 20; - match __sedlex_partition_42 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_60 b - | 1 -> __sedlex_state_66 b - | 2 -> __sedlex_state_67 b - | 3 -> __sedlex_state_69 b + Lex_moon_rt.mark b 24; + match __sedlex_partition_41 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_81 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_82 = function | b -> ( - Lex_moon_rt.mark b 38; + Lex_moon_rt.mark b 22; + match __sedlex_partition_42 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_61 b + | 1 -> __sedlex_state_67 b + | 2 -> __sedlex_state_68 b + | 3 -> __sedlex_state_70 b + | _ -> Lex_moon_rt.backtrack b) + and __sedlex_state_83 = function + | b -> ( + Lex_moon_rt.mark b 39; match __sedlex_partition_51 (Lex_moon_rt.__private__next_int b) with - | 0 -> 37 + | 0 -> 38 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_85 = function + and __sedlex_state_86 = function | b -> ( - Lex_moon_rt.mark b 42; + Lex_moon_rt.mark b 43; match __sedlex_partition_52 (Lex_moon_rt.__private__next_int b) with - | 0 -> 31 - | 1 -> 45 + | 0 -> 33 + | 1 -> 46 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_88 = function + and __sedlex_state_89 = function | b -> ( - Lex_moon_rt.mark b 40; + Lex_moon_rt.mark b 41; match __sedlex_partition_32 (Lex_moon_rt.__private__next_int b) with - | 0 -> 43 + | 0 -> 44 | 1 -> 2 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_91 = function + and __sedlex_state_92 = function | b -> ( - Lex_moon_rt.mark b 41; + Lex_moon_rt.mark b 42; match __sedlex_partition_32 (Lex_moon_rt.__private__next_int b) with - | 0 -> 45 - | 1 -> 32 + | 0 -> 46 + | 1 -> 34 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_94 = function + and __sedlex_state_95 = function | b -> ( - Lex_moon_rt.mark b 63; + Lex_moon_rt.mark b 64; match __sedlex_partition_53 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_95 b + | 0 -> __sedlex_state_96 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_95 = function + and __sedlex_state_96 = function | b -> ( - Lex_moon_rt.mark b 15; + Lex_moon_rt.mark b 16; match __sedlex_partition_54 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_96 b - | 1 -> __sedlex_state_95 b + | 0 -> __sedlex_state_97 b + | 1 -> __sedlex_state_96 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_96 = function + and __sedlex_state_97 = function | b -> ( match __sedlex_partition_53 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_95 b + | 0 -> __sedlex_state_96 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_100 = function + and __sedlex_state_101 = function | b -> ( - Lex_moon_rt.mark b 63; + Lex_moon_rt.mark b 64; match __sedlex_partition_55 (Lex_moon_rt.__private__next_int b) with | 0 -> 12 - | 1 -> __sedlex_state_102 b - | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_102 = function - | b -> ( - match __sedlex_partition_56 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_103 b - | 1 -> __sedlex_state_105 b + | 1 -> __sedlex_state_103 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_103 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 18 + Lex_moon_rt.mark b 21; + match __sedlex_partition_56 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_104 b + | 1 -> __sedlex_state_106 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_105 = function + and __sedlex_state_104 = function | b -> ( - match __sedlex_partition_57 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_106 b - | 1 -> __sedlex_state_108 b - | 2 -> __sedlex_state_109 b - | 3 -> __sedlex_state_114 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 19 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_106 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 19 + match __sedlex_partition_57 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_107 b + | 1 -> __sedlex_state_109 b + | 2 -> __sedlex_state_110 b + | 3 -> __sedlex_state_115 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_108 = function + and __sedlex_state_107 = function | b -> ( - Lex_moon_rt.mark b 18; - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 19 + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 20 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_109 = function | b -> ( - match __sedlex_partition_28 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_110 b + Lex_moon_rt.mark b 19; + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 20 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_110 = function | b -> ( @@ -2076,35 +1917,40 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_111 = function | b -> ( - match __sedlex_partition_29 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_112 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_112 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 17 + match __sedlex_partition_30 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_113 b | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_114 = function + and __sedlex_state_113 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with - | 0 -> __sedlex_state_115 b + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 18 | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_115 = function | b -> ( - match __sedlex_partition_13 (Lex_moon_rt.__private__next_int b) with + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with | 0 -> __sedlex_state_116 b | _ -> Lex_moon_rt.backtrack b) and __sedlex_state_116 = function | b -> ( - match __sedlex_partition_26 (Lex_moon_rt.__private__next_int b) with - | 0 -> 16 + match __sedlex_partition_11 (Lex_moon_rt.__private__next_int b) with + | 0 -> __sedlex_state_117 b + | _ -> Lex_moon_rt.backtrack b) + and __sedlex_state_117 = function + | b -> ( + match __sedlex_partition_27 (Lex_moon_rt.__private__next_int b) with + | 0 -> 17 | _ -> Lex_moon_rt.backtrack b) - and __sedlex_state_119 = function + and __sedlex_state_120 = function | b -> ( - Lex_moon_rt.mark b 50; + Lex_moon_rt.mark b 51; match __sedlex_partition_58 (Lex_moon_rt.__private__next_int b) with - | 0 -> 61 - | 1 -> 51 + | 0 -> 62 + | 1 -> 52 | _ -> Lex_moon_rt.backtrack b) in Lex_moon_rt.start b; @@ -2220,29 +2066,34 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = Menhir_token.MULTILINE_INTERP (string ~env ~multiline_string:true lexbuf loca) in - loc ~env lexbuf tok + let locb = Lexing.lexeme_end b in + add_token ~env tok (make_pos ~env loca) (make_pos ~env locb) | 14 -> if env.is_interpolation then add_lexing_error ~env lexbuf Interp_invalid_multiline_string; loc ~env lexbuf (MULTILINE_STRING (sub_lexeme_to_end ~start:2 b)) - | 15 -> loc ~env lexbuf (PACKAGE_NAME (sub_lexeme_to_end ~start:1 b)) - | 16 -> + | 15 -> + if env.is_interpolation then + add_lexing_error ~env lexbuf Interp_invalid_attribute; + loc ~env lexbuf (ATTRIBUTE (sub_lexeme_to_end ~start:1 b)) + | 16 -> loc ~env lexbuf (PACKAGE_NAME (sub_lexeme_to_end ~start:1 b)) + | 17 -> let literal : byte_literal = { - byte_val = char_for_hex_escape b.buf (b.pos - 3) 2 |> Uchar.to_int; + byte_val = Uchar.to_int (char_for_hex_escape b.buf (b.pos - 3) 2); byte_repr = sub_lexeme_len b ~start:2 ~len:4; } in loc ~env lexbuf (BYTE literal) - | 17 -> + | 18 -> let literal : byte_literal = { - byte_val = char_for_oct_escape b.buf (b.pos - 4) 3 |> Uchar.to_int; + byte_val = Uchar.to_int (char_for_oct_escape b.buf (b.pos - 4) 3); byte_repr = sub_lexeme_len b ~start:2 ~len:5; } in loc ~env lexbuf (BYTE literal) - | 18 -> + | 19 -> let literal : byte_literal = { byte_val = b.Lexing.buf.(Lexing.lexeme_start b + 2); @@ -2250,35 +2101,69 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = } in loc ~env lexbuf (BYTE literal) - | 19 -> + | 20 -> let s = b.buf.(b.pos - 2) in let literal : byte_literal = { - byte_val = char_for_backslash s |> Uchar.to_int; + byte_val = Uchar.to_int (char_for_backslash s); byte_repr = sub_lexeme_len b ~start:2 ~len:2; } in loc ~env lexbuf (BYTE literal) - | 20 -> loc ~env lexbuf (INT (lexeme b)) | 21 -> + let buf = Buffer.create 10 in + let keep_going = ref true in + while !keep_going do + let __sedlex_state_0 = function + | b -> ( + match + __sedlex_partition_18 (Lex_moon_rt.__private__next_int b) + with + | 0 -> 0 + | 1 -> 1 + | 2 -> 0 + | _ -> Lex_moon_rt.backtrack b) + in + Lex_moon_rt.start b; + match __sedlex_state_0 b with + | 0 -> keep_going := false + | 1 -> + let c = Lexing.current_code_point lexbuf in + if is_common_ascii c then Buffer.add_char buf (Char.unsafe_chr c) + else if Unicode.is_valid_unicode_codepoint c then + Buffer.add_utf_8_uchar buf (Uchar.of_int c) + | _ -> assert false + done; + add_lexing_error ~env lexbuf + (Invalid_byte_literal (Buffer.contents buf)); + loc ~env lexbuf (BYTE { byte_val = 0; byte_repr = Buffer.contents buf }) + | 22 -> loc ~env lexbuf (INT (lexeme b)) + | 23 -> Lexing.backoff b 2; loc ~env lexbuf (INT (lexeme b)) - | 22 -> loc ~env lexbuf (FLOAT (lexeme b)) - | 23 -> loc ~env lexbuf AMPERAMPER - | 24 -> loc ~env lexbuf AMPER - | 25 -> loc ~env lexbuf CARET - | 26 -> loc ~env lexbuf LPAREN - | 27 -> loc ~env lexbuf RPAREN - | 28 -> loc ~env lexbuf (INFIX3 "*") - | 29 -> loc ~env lexbuf (INFIX3 "/") - | 30 -> loc ~env lexbuf (INFIX3 "%") - | 31 -> loc ~env lexbuf (INFIX2 "<<") - | 32 -> loc ~env lexbuf (INFIX2 ">>") - | 33 -> loc ~env lexbuf COMMA - | 34 -> - let idx = int_of_string (sub_lexeme_to_end b ~start:1) in + | 24 -> loc ~env lexbuf (FLOAT (lexeme b)) + | 25 -> loc ~env lexbuf AMPERAMPER + | 26 -> loc ~env lexbuf AMPER + | 27 -> loc ~env lexbuf CARET + | 28 -> loc ~env lexbuf LPAREN + | 29 -> loc ~env lexbuf RPAREN + | 30 -> loc ~env lexbuf (INFIX3 "*") + | 31 -> loc ~env lexbuf (INFIX3 "/") + | 32 -> loc ~env lexbuf (INFIX3 "%") + | 33 -> loc ~env lexbuf (INFIX2 "<<") + | 34 -> loc ~env lexbuf (INFIX2 ">>") + | 35 -> loc ~env lexbuf COMMA + | 36 -> + let idx = + let lexeme = sub_lexeme_to_end b ~start:1 in + match int_of_string_opt lexeme with + | Some idx -> idx + | None -> + add_lexing_error ~env b (Invalid_dot_int lexeme); + 0 + in loc ~env lexbuf (DOT_INT idx) ~start_offset:1 - | 35 -> + | 37 -> let buf = Buffer.create 10 in Lexing.set_start b (Lexing.lexeme_end b); lex_unicode_ident b buf; @@ -2286,54 +2171,36 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = if String.length name > 0 && 'A' <= name.[0] && name.[0] <= 'Z' then loc ~env lexbuf (DOT_UIDENT name) else loc ~env lexbuf (DOT_LIDENT name) - | 36 -> - let head = Lexing.peek_next_int b in - if is_common_ascii head || Unicode.is_valid_unicode_codepoint head then ( - let buf = Buffer.create 10 in - lex_unicode_ident b buf; - let raw = Buffer.contents buf in - if raw = "" then add_lexing_error ~env b Empty_label - else ( - if raw = "_" then add_lexing_error ~env b (Invalid_label_name "_"); - let c = raw.[0] in - if c > '0' && c < '9' then - add_lexing_error ~env b (Invalid_label_name raw)); - add_lexing_warning ~env b - (Warnings.Deprecated_prefix_label_syntax raw); - loc ~env lexbuf (LABEL raw)) - else ( - add_lexing_error ~env lexbuf Empty_label; - loc ~env lexbuf (LABEL "")) - | 37 -> loc ~env lexbuf COLONCOLON - | 38 -> loc ~env lexbuf COLON - | 39 -> loc ~env lexbuf Menhir_token.real_semi - | 40 -> loc ~env lexbuf EQUAL - | 41 -> loc ~env lexbuf (INFIX1 ">") - | 42 -> loc ~env lexbuf (INFIX1 "<") - | 43 -> loc ~env lexbuf (INFIX1 "==") - | 44 -> loc ~env lexbuf (INFIX1 "!=") - | 45 -> loc ~env lexbuf (INFIX1 (lexeme b)) - | 46 -> loc ~env lexbuf LBRACKET - | 47 -> loc ~env lexbuf LBRACE - | 48 -> loc ~env lexbuf RBRACKET - | 49 -> loc ~env lexbuf RBRACE - | 50 -> loc ~env lexbuf BAR - | 51 -> loc ~env lexbuf BARBAR - | 52 -> loc ~env lexbuf PLUS - | 53 -> loc ~env lexbuf MINUS - | 54 -> loc ~env lexbuf QUESTION - | 55 -> loc ~env lexbuf EXCLAMATION - | 56 -> loc ~env lexbuf DOTDOT - | 57 -> loc ~env lexbuf RANGE_INCLUSIVE - | 58 -> loc ~env lexbuf RANGE_EXCLUSIVE - | 59 -> loc ~env lexbuf ELLIPSIS - | 60 -> loc ~env lexbuf (AUGMENTED_ASSIGNMENT (String.sub (lexeme b) 0 1)) - | 61 -> loc ~env lexbuf PIPE - | 62 -> + | 38 -> loc ~env lexbuf COLONCOLON + | 39 -> loc ~env lexbuf COLON + | 40 -> loc ~env lexbuf Menhir_token.real_semi + | 41 -> loc ~env lexbuf EQUAL + | 42 -> loc ~env lexbuf (INFIX1 ">") + | 43 -> loc ~env lexbuf (INFIX1 "<") + | 44 -> loc ~env lexbuf (INFIX1 "==") + | 45 -> loc ~env lexbuf (INFIX1 "!=") + | 46 -> loc ~env lexbuf (INFIX1 (lexeme b)) + | 47 -> loc ~env lexbuf LBRACKET + | 48 -> loc ~env lexbuf LBRACE + | 49 -> loc ~env lexbuf RBRACKET + | 50 -> loc ~env lexbuf RBRACE + | 51 -> loc ~env lexbuf BAR + | 52 -> loc ~env lexbuf BARBAR + | 53 -> loc ~env lexbuf PLUS + | 54 -> loc ~env lexbuf MINUS + | 55 -> loc ~env lexbuf QUESTION + | 56 -> loc ~env lexbuf EXCLAMATION + | 57 -> loc ~env lexbuf DOTDOT + | 58 -> loc ~env lexbuf RANGE_INCLUSIVE + | 59 -> loc ~env lexbuf RANGE_EXCLUSIVE + | 60 -> loc ~env lexbuf ELLIPSIS + | 61 -> loc ~env lexbuf (AUGMENTED_ASSIGNMENT (String.sub (lexeme b) 0 1)) + | 62 -> loc ~env lexbuf PIPE + | 63 -> let loca = make_pos ~env (Lexing.lexeme_end b) in add_token ~env EOF loca loca; has_work := false - | 63 -> + | 64 -> let head = Lexing.current_code_point b in if is_common_ascii head || Unicode.is_valid_unicode_codepoint head then ( let buf = Buffer.create 10 in @@ -2365,12 +2232,52 @@ let main ~(env : Lex_env.t) ~preserve_comment lexbuf = Vec.reverse_in_place c); env.vec -let tokens_of_string ?(name = "") ?(start_pos = Stdlib.Lexing.dummy_pos) +let preserve_comment env lexbuf = + match env.Lex_env.docstrings with + | Some c when env.comment -> + fun (cmt : Comment.t) -> + if String.length cmt.content > 2 && cmt.content.![2] = '/' then + let loca = Lexing.lexeme_start lexbuf in + let locb = Lexing.lexeme_end lexbuf in + let l = Loc.of_menhir (make_pos ~env loca, make_pos ~env locb) in + if Vec.is_empty c then Vec.push c [ (l, cmt) ] + else + let last = Vec.last c in + if Loc.line_number l - Loc.line_number (fst (List.hd last)) > 1 then ( + Vec.set_last c (List.rev last); + Vec.push c [ (l, cmt) ]) + else Vec.set_last c ((l, cmt) :: last) + | _ -> ignore + +let tokens_of_segment ~diagnostics ~comment ?docstrings + (segment : Text_segment.t) = + let lexbuf = + Lexing.from_int_vec (Basic_utf8.from_string segment.text_segment_code) + in + let vec = Vec.make 100 ~dummy:Token_triple.null in + let env : Lex_env.t = + { + diagnostics; + docstrings; + comment; + name = segment.text_name; + vec; + current_line = segment.text_start_line; + current_bol = 0; + start_cnum = 0; + last_unhandled_comment = ref None; + asi_context = Semi_insertion.make_asi_context (); + is_interpolation = false; + } + in + main ~env ~preserve_comment:(preserve_comment env lexbuf) lexbuf + +let tokens_of_string ?(name = "") ?(start_pos = Basic_lexing.dummy_pos) ?(is_interpolation = false) ?docstrings ~diagnostics ~comment s = let lexbuf = Lexing.from_int_vec (Basic_utf8.from_string s) in let vec = Vec.make 100 ~dummy:Token_triple.null in let start_lnum, start_bol, start_cnum = - if Basic_prelude.phys_equal Stdlib.Lexing.dummy_pos start_pos then (1, 0, 0) + if Basic_prelude.phys_equal Basic_lexing.dummy_pos start_pos then (1, 0, 0) else (start_pos.pos_lnum, start_pos.pos_bol, start_pos.pos_cnum) in let env : Lex_env.t = @@ -2388,22 +2295,4 @@ let tokens_of_string ?(name = "") ?(start_pos = Stdlib.Lexing.dummy_pos) is_interpolation; } in - let preserve_comment = - match env.docstrings with - | Some c when env.comment -> - fun (cmt : Comment.t) -> - if String.length cmt.content > 2 && cmt.content.![2] = '/' then - let loca = Lexing.lexeme_start lexbuf in - let locb = Lexing.lexeme_end lexbuf in - let l = Loc.of_menhir (make_pos ~env loca, make_pos ~env locb) in - if Vec.is_empty c then Vec.push c [ (l, cmt) ] - else - let last = Vec.last c in - if Loc.line_number l - Loc.line_number (fst (List.hd last)) > 1 - then ( - Vec.set_last c (List.rev last); - Vec.push c [ (l, cmt) ]) - else Vec.set_last c ((l, cmt) :: last) - | _ -> ignore - in - main ~env ~preserve_comment lexbuf + main ~env ~preserve_comment:(preserve_comment env lexbuf) lexbuf diff --git a/src/lex_vec_comment.ml b/src/lex_vec_comment.ml index f7726b3..80ea618 100644 --- a/src/lex_vec_comment.ml +++ b/src/lex_vec_comment.ml @@ -18,29 +18,29 @@ module Comment = Lex_comment type t = Comment.with_loc Vec.t -let search ~last ~loc_ (t : Comment.with_loc Vec.t) : Comment.with_loc = - let line = Loc.line_number loc_ in - let rec go l r = - if l >= r then l - else - let m = l + ((r - l) / 2) in - let locs = Vec.get t m in - match locs with - | [] -> assert false - | (x, _) :: _ -> - if Loc.line_number x <= line then go l m else go (m + 1) r - in - let result = - let pos = go 0 (Vec.length t - 1) in - if pos >= Vec.length t then [] - else - match Vec.get t pos with - | [] -> assert false - | (x, _) :: _ as xs -> - let lx = Loc.line_number x in - if Loc.line_number_end last < lx && lx <= line then xs else [] - in - List.iter - (fun (_, (comment : Comment.t)) -> comment.consumed_by_docstring := true) - result; - result +let search ~last ~loc_ (t : Comment.with_loc Vec.t) = + (let line = Loc.line_number loc_ in + let rec go l r = + if l >= r then l + else + let m = l + ((r - l) / 2) in + let locs = Vec.get t m in + match locs with + | [] -> assert false + | (x, _) :: _ -> + if Loc.line_number x <= line then go l m else go (m + 1) r + in + let result = + let pos = go 0 (Vec.length t - 1) in + if pos >= Vec.length t then [] + else + match Vec.get t pos with + | [] -> assert false + | (x, _) :: _ as xs -> + let lx = Loc.line_number x in + if Loc.line_number_end last < lx && lx <= line then xs else [] + in + Basic_lst.iter result ~f:(fun (_, (comment : Comment.t)) -> + comment.consumed_by_docstring := true); + result + : Comment.with_loc) diff --git a/src/lexing.ml b/src/lexing.ml new file mode 100644 index 0000000..f78b641 --- /dev/null +++ b/src/lexing.ml @@ -0,0 +1,37 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +type position = { + pos_fname : string; + pos_lnum : int; + pos_bol : int; + pos_cnum : int; +} + +type lexbuf = { mutable lex_start_p : position; mutable lex_curr_p : position } + +let dummy_pos = { pos_fname = ""; pos_lnum = 0; pos_bol = 0; pos_cnum = -1 } + +let of_stdlib_position (pos : Stdlib.Lexing.position) = + ({ + pos_fname = pos.pos_fname; + pos_lnum = pos.pos_lnum; + pos_bol = pos.pos_bol; + pos_cnum = pos.pos_cnum; + } + : position) + +let from_string (_ : string) = + { lex_start_p = dummy_pos; lex_curr_p = dummy_pos } diff --git a/src/loc.ml b/src/loc.ml index d1a77e5..f851309 100644 --- a/src/loc.ml +++ b/src/loc.ml @@ -29,7 +29,8 @@ include struct pos_lnum = pos_lnum__004_; pos_bol = pos_bol__006_; pos_cnum = pos_cnum__008_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__009_ = Moon_sexp_conv.sexp_of_int pos_cnum__008_ in @@ -89,21 +90,23 @@ let filename loc = loc.start.pos_fname let get_start loc = loc.start let get_end loc = loc._end -let position_to_json (p : position) : Json.t = - `Assoc [ ("line", `Int p.pos_lnum); ("col", `Int (column_of_pos p)) ] - -let sexp_of_t (l : t) : S.t = - S.Atom - (Stdlib.String.concat "" - [ - Int.to_string l.start.pos_lnum; - ":"; - Int.to_string (column_of_pos l.start); - "-"; - Int.to_string l._end.pos_lnum; - ":"; - Int.to_string (column_of_pos l._end); - ]) +let position_to_json (p : position) = + (`Assoc [ ("line", `Int p.pos_lnum); ("col", `Int (column_of_pos p)) ] + : Json.t) + +let sexp_of_t (l : t) = + (S.Atom + (Stdlib.String.concat "" + [ + Int.to_string l.start.pos_lnum; + ":"; + Int.to_string (column_of_pos l.start); + "-"; + Int.to_string l._end.pos_lnum; + ":"; + Int.to_string (column_of_pos l._end); + ]) + : S.t) let hide_loc _ = not !Basic_config.show_loc @@ -114,20 +117,21 @@ include struct let sexp_of_loced : 'a. ('a -> S.t) -> 'a loced -> S.t = let (drop_if__022_ : t -> Stdlib.Bool.t) = hide_loc in - fun _of_a__017_ { v = v__019_; loc_ = loc___023_ } -> - let bnds__018_ = ([] : _ Stdlib.List.t) in - let bnds__018_ = - if drop_if__022_ loc___023_ then bnds__018_ - else - let arg__025_ = sexp_of_t loc___023_ in - let bnd__024_ = S.List [ S.Atom "loc_"; arg__025_ ] in - (bnd__024_ :: bnds__018_ : _ Stdlib.List.t) - in - let bnds__018_ = - let arg__020_ = _of_a__017_ v__019_ in - (S.List [ S.Atom "v"; arg__020_ ] :: bnds__018_ : _ Stdlib.List.t) - in - S.List bnds__018_ + fun _of_a__017_ -> + fun { v = v__019_; loc_ = loc___023_ } -> + let bnds__018_ = ([] : _ Stdlib.List.t) in + let bnds__018_ = + if drop_if__022_ loc___023_ then bnds__018_ + else + let arg__025_ = sexp_of_t loc___023_ in + let bnd__024_ = S.List [ S.Atom "loc_"; arg__025_ ] in + (bnd__024_ :: bnds__018_ : _ Stdlib.List.t) + in + let bnds__018_ = + let arg__020_ = _of_a__017_ v__019_ in + (S.List [ S.Atom "v"; arg__020_ ] :: bnds__018_ : _ Stdlib.List.t) + in + S.List bnds__018_ let _ = sexp_of_loced end @@ -142,28 +146,37 @@ let is_no_location loc = Basic_prelude.phys_equal loc no_location || (loc.pkg = "" && loc.start.pos_cnum = -1 && loc._end.pos_cnum = -1) -let merge (l1 : t) (l2 : t) : t = { l1 with _end = l2._end } -let collapse (loc : t) : t = { loc with _end = loc.start } - -let pos_compare (left : position) (right : position) : int = - if Basic_prelude.phys_equal left right then 0 - else if right.pos_lnum <> left.pos_lnum then - Int.compare left.pos_lnum right.pos_lnum - else - Int.compare (left.pos_cnum - left.pos_bol) (right.pos_cnum - right.pos_bol) - +let pos_compare (left : position) (right : position) = + (if Basic_prelude.phys_equal left right then 0 + else if right.pos_lnum <> left.pos_lnum then + Int.compare left.pos_lnum right.pos_lnum + else + Int.compare (left.pos_cnum - left.pos_bol) (right.pos_cnum - right.pos_bol) + : int) + +let merge (l1 : t) (l2 : t) = + (let { start = s1; _end = e1; pkg = pkg1 } = l1 in + let { start = s2; _end = e2; pkg = pkg2 } = l2 in + let start = if pos_compare s1 s2 < 0 then s1 else s2 in + assert (pkg1 = pkg2); + let _end = if pos_compare e1 e2 > 0 then e1 else e2 in + { pkg = pkg1; start; _end } + : t) + +let collapse (loc : t) = ({ loc with _end = loc.start } : t) let pkg_path_tbl = Pkg_path_tbl.create () -let t_to_json (l : t) : Json.t = - let path = - Pkg_path_tbl.resolve_source pkg_path_tbl ~pkg:l.pkg ~file:l.start.pos_fname - in - `Assoc - [ - ("path", `String path); - ("start", position_to_json l.start); - ("end", position_to_json l._end); - ] +let t_to_json (l : t) = + (let path = + Pkg_path_tbl.resolve_source pkg_path_tbl ~pkg:l.pkg ~file:l.start.pos_fname + in + `Assoc + [ + ("path", `String path); + ("start", position_to_json l.start); + ("end", position_to_json l._end); + ] + : Json.t) let to_string (loc : t) = let path = @@ -179,35 +192,37 @@ let to_string (loc : t) = Int.to_string (column_of_pos loc.start); ] -let loc_range_string (loc : t) : string = - let path = - Pkg_path_tbl.resolve_source pkg_path_tbl ~pkg:loc.pkg - ~file:loc.start.pos_fname - in - Stdlib.String.concat "" - [ - path; - ":"; - Int.to_string loc.start.pos_lnum; - ":"; - Int.to_string (column_of_pos loc.start); - "-"; - Int.to_string loc._end.pos_lnum; - ":"; - Int.to_string (column_of_pos loc._end); - ] - -let loc_range_string_no_filename (loc : t) : string = - Stdlib.String.concat "" - [ - Int.to_string loc.start.pos_lnum; - ":"; - Int.to_string (column_of_pos loc.start); - "-"; - Int.to_string loc._end.pos_lnum; - ":"; - Int.to_string (column_of_pos loc._end); - ] +let loc_range_string (loc : t) = + (let path = + Pkg_path_tbl.resolve_source pkg_path_tbl ~pkg:loc.pkg + ~file:loc.start.pos_fname + in + Stdlib.String.concat "" + [ + path; + ":"; + Int.to_string loc.start.pos_lnum; + ":"; + Int.to_string (column_of_pos loc.start); + "-"; + Int.to_string loc._end.pos_lnum; + ":"; + Int.to_string (column_of_pos loc._end); + ] + : string) + +let loc_range_string_no_filename (loc : t) = + (Stdlib.String.concat "" + [ + Int.to_string loc.start.pos_lnum; + ":"; + Int.to_string (column_of_pos loc.start); + "-"; + Int.to_string loc._end.pos_lnum; + ":"; + Int.to_string (column_of_pos loc._end); + ] + : string) let line_number l = l.start.pos_lnum let column_number l = column_of_pos l.start @@ -234,20 +249,21 @@ type loc_relation = | Overlap | Unrelated -let relation_of_loc (loc1 : t) (loc2 : t) : loc_relation = - let { start = s1; _end = e1; _ } = loc1 - and { start = s2; _end = e2; _ } = loc2 in - if s1.pos_fname <> s2.pos_fname then Unrelated - else if pos_compare s1 s2 = 0 && pos_compare e1 e2 = 0 then Equal - else if pos_compare e1 s2 <= 0 then Smaller - else if pos_compare s1 e2 >= 0 then Greater - else - let s1_vs_s2 = pos_compare s1 s2 in - let e2_vs_e1 = pos_compare e2 e1 in - match s1_vs_s2 + e2_vs_e1 with - | 0 -> if s1_vs_s2 = 0 && e2_vs_e1 = 0 then Equal else Overlap - | ord when ord < 0 -> Includes - | _ -> Included +let relation_of_loc (loc1 : t) (loc2 : t) = + (let { start = s1; _end = e1; _ } = loc1 + and { start = s2; _end = e2; _ } = loc2 in + if s1.pos_fname <> s2.pos_fname then Unrelated + else if pos_compare s1 s2 = 0 && pos_compare e1 e2 = 0 then Equal + else if pos_compare e1 s2 <= 0 then Smaller + else if pos_compare s1 e2 >= 0 then Greater + else + let s1_vs_s2 = pos_compare s1 s2 in + let e2_vs_e1 = pos_compare e2 e1 in + match s1_vs_s2 + e2_vs_e1 with + | 0 -> if s1_vs_s2 = 0 && e2_vs_e1 = 0 then Equal else Overlap + | ord when ord < 0 -> Includes + | _ -> Included + : loc_relation) let trim_first_char loc = let start' = { loc.start with pos_cnum = loc.start.pos_cnum + 1 } in @@ -258,4 +274,8 @@ let only_last_n_char loc n = let start' = { loc._end with pos_cnum = loc._end.pos_cnum - n } in { loc with start = start' } +let only_first_n_char loc n = + let _end' = { loc.start with pos_cnum = loc.start.pos_cnum + n } in + { loc with _end = _end' } + let length loc = loc._end.pos_cnum - loc.start.pos_cnum [@@dead "+length"] diff --git a/src/local_diagnostics.ml b/src/local_diagnostics.ml index 8a53d10..87d43f1 100644 --- a/src/local_diagnostics.ml +++ b/src/local_diagnostics.ml @@ -13,17 +13,20 @@ *) -type report = { loc : Rloc.t; message : string; error_code : Error_code.t } +module Lst = Basic_lst + +type error = { loc : Rloc.t; message : string; error_code : Error_code.t } include struct - let _ = fun (_ : report) -> () + let _ = fun (_ : error) -> () - let sexp_of_report = + let sexp_of_error = (fun { loc = loc__002_; message = message__004_; error_code = error_code__006_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__007_ = Error_code.sexp_of_t error_code__006_ in @@ -40,38 +43,40 @@ include struct (S.List [ S.Atom "loc"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) in S.List bnds__001_ - : report -> S.t) - - let _ = sexp_of_report - - let compare_report = - (fun a__008_ b__009_ -> - if Stdlib.( == ) a__008_ b__009_ then 0 - else - match Rloc.compare a__008_.loc b__009_.loc with - | 0 -> ( - match - Stdlib.compare (a__008_.message : string) b__009_.message - with - | 0 -> Error_code.compare a__008_.error_code b__009_.error_code - | n -> n) - | n -> n - : report -> report -> int) - - let _ = compare_report - - let equal_report = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then true - else - Stdlib.( && ) - (Rloc.equal a__010_.loc b__011_.loc) - (Stdlib.( && ) - (Stdlib.( = ) (a__010_.message : string) b__011_.message) - (Error_code.equal a__010_.error_code b__011_.error_code)) - : report -> report -> bool) - - let _ = equal_report + : error -> S.t) + + let _ = sexp_of_error + + let compare_error = + (fun a__008_ -> + fun b__009_ -> + if Stdlib.( == ) a__008_ b__009_ then 0 + else + match Rloc.compare a__008_.loc b__009_.loc with + | 0 -> ( + match + Stdlib.compare (a__008_.message : string) b__009_.message + with + | 0 -> Error_code.compare a__008_.error_code b__009_.error_code + | n -> n) + | n -> n + : error -> error -> int) + + let _ = compare_error + + let equal_error = + (fun a__010_ -> + fun b__011_ -> + if Stdlib.( == ) a__010_ b__011_ then true + else + Stdlib.( && ) + (Rloc.equal a__010_.loc b__011_.loc) + (Stdlib.( && ) + (Stdlib.( = ) (a__010_.message : string) b__011_.message) + (Error_code.equal a__010_.error_code b__011_.error_code)) + : error -> error -> bool) + + let _ = equal_error end type warning = { loc : Rloc.t; kind : Warnings.kind } @@ -96,23 +101,25 @@ include struct let _ = sexp_of_warning let compare_warning = - (fun a__017_ b__018_ -> - if Stdlib.( == ) a__017_ b__018_ then 0 - else - match Rloc.compare a__017_.loc b__018_.loc with - | 0 -> Warnings.compare_kind a__017_.kind b__018_.kind - | n -> n + (fun a__017_ -> + fun b__018_ -> + if Stdlib.( == ) a__017_ b__018_ then 0 + else + match Rloc.compare a__017_.loc b__018_.loc with + | 0 -> Warnings.compare_kind a__017_.kind b__018_.kind + | n -> n : warning -> warning -> int) let _ = compare_warning let equal_warning = - (fun a__019_ b__020_ -> - if Stdlib.( == ) a__019_ b__020_ then true - else - Stdlib.( && ) - (Rloc.equal a__019_.loc b__020_.loc) - (Warnings.equal_kind a__019_.kind b__020_.kind) + (fun a__019_ -> + fun b__020_ -> + if Stdlib.( == ) a__019_ b__020_ then true + else + Stdlib.( && ) + (Rloc.equal a__019_.loc b__020_.loc) + (Warnings.equal_kind a__019_.kind b__020_.kind) : warning -> warning -> bool) let _ = equal_warning @@ -120,16 +127,16 @@ end type alert = { loc : Rloc.t; category : string; message : string } -module Report_set = Basic_setf.Make (struct - type t = report +module Error_set = Basic_setf.Make (struct + type t = error include struct let _ = fun (_ : t) -> () - let sexp_of_t = (sexp_of_report : t -> S.t) + let sexp_of_t = (sexp_of_error : t -> S.t) let _ = sexp_of_t - let compare = (compare_report : t -> t -> int) + let compare = (compare_error : t -> t -> int) let _ = compare - let equal = (equal_report : t -> t -> bool) + let equal = (equal_error : t -> t -> bool) let _ = equal end end) @@ -150,15 +157,13 @@ end) type t = { base : Loc.t; - mutable errors : Report_set.t; + mutable errors : Error_set.t; mutable alerts : alert list; mutable warnings : Warning_set.t; } -type error_option = report option - let make ~base = - { base; errors = Report_set.empty; alerts = []; warnings = Warning_set.empty } + { base; errors = Error_set.empty; alerts = []; warnings = Warning_set.empty } let swallow_error = { @@ -168,14 +173,14 @@ let swallow_error = } let add_to_global t (diagnostics : Diagnostics.t) = - Report_set.iter t.errors (fun e -> + Error_set.iter t.errors (fun e -> let loc = Rloc.to_loc ~base:t.base e.loc in Diagnostics.add_error diagnostics { loc; message = e.message; error_code = e.error_code }); Warning_set.iter t.warnings (fun w -> let loc = Rloc.to_loc ~base:t.base w.loc in Diagnostics.add_warning diagnostics { loc; kind = w.kind }); - Basic_lst.iter t.alerts (fun a -> + Basic_lst.iter t.alerts ~f:(fun a -> let loc = Rloc.to_loc ~base:t.base a.loc in Diagnostics.add_alert diagnostics { loc; category = a.category; message = a.message }) @@ -183,20 +188,26 @@ let add_to_global t (diagnostics : Diagnostics.t) = let add_warning (x : t) (w : warning) = x.warnings <- Warning_set.add x.warnings w -let add_error (x : t) (w : report) = +let add_error (x : t) (w : error) = if not (Basic_prelude.phys_equal w swallow_error) then - x.errors <- Report_set.add x.errors w + x.errors <- Error_set.add x.errors w let add_alert (x : t) (a : alert) = x.alerts <- a :: x.alerts -let has_fatal_errors (x : t) = not (Report_set.is_empty x.errors) +let has_fatal_errors (x : t) = not (Error_set.is_empty x.errors) + +let merge (x : t) ~into = + Error_set.iter x.errors (add_error into); + Warning_set.iter x.warnings (add_warning into); + Lst.iter x.alerts ~f:(add_alert into) -type 'a partial_info = Ok of 'a | Partial of 'a * report list +type 'a partial_info = Ok of 'a | Partial of 'a * error list -let take_partial_info (x : 'a partial_info) ~(diagnostics : t) : 'a = - match x with - | Ok a -> a - | Partial (a, err) -> - List.iter (fun info -> add_error diagnostics info) err; - a +let take_partial_info (x : 'a partial_info) ~(diagnostics : t) = + (match x with + | Ok a -> a + | Partial (a, err) -> + Basic_lst.iter err ~f:(fun info -> add_error diagnostics info); + a + : 'a) -type 'a info = ('a, report) Result.t +type 'a info = ('a, error) Result.t diff --git a/src/local_env.ml b/src/local_env.ml index 13a476a..4686940 100644 --- a/src/local_env.ml +++ b/src/local_env.ml @@ -109,9 +109,11 @@ let add t id ~typ ~mut ~loc = (if mut then Local_mut { id; typ; loc_ = loc } else Local_imm { id; typ; loc_ = loc }) -let rec find_by_name_opt (env : t) (name : string) : Value_info.t option = - match env with - | Empty -> None - | Node (l, k, r, _) -> - let c = String.compare name k.key in - if c = 0 then Some k.v else find_by_name_opt (if c < 0 then l else r) name +let rec find_by_name_opt (env : t) (name : string) = + (match env with + | Empty -> None + | Node (l, k, r, _) -> + let c = String.compare name k.key in + if c = 0 then Some k.v + else find_by_name_opt (if c < 0 then l else r) name + : Value_info.t option) diff --git a/src/local_type.ml b/src/local_type.ml new file mode 100644 index 0000000..a97265a --- /dev/null +++ b/src/local_type.ml @@ -0,0 +1,317 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Type_path = Basic_type_path +module Hash_string = Basic_hash_string +module Lst = Basic_lst + +type location = Rloc.t + +include struct + let _ = fun (_ : location) -> () + let sexp_of_location = (Rloc.sexp_of_t : location -> S.t) + let _ = sexp_of_location +end + +type constructor = Typedecl_info.constructor + +include struct + let _ = fun (_ : constructor) -> () + + let sexp_of_constructor = + (Typedecl_info.sexp_of_constructor : constructor -> S.t) + + let _ = sexp_of_constructor +end + +type field = Typedecl_info.field + +include struct + let _ = fun (_ : field) -> () + let sexp_of_field = (Typedecl_info.sexp_of_field : field -> S.t) + let _ = sexp_of_field +end + +type newtype_info = Typedecl_info.newtype_info + +include struct + let _ = fun (_ : newtype_info) -> () + + let sexp_of_newtype_info = + (Typedecl_info.sexp_of_newtype_info : newtype_info -> S.t) + + let _ = sexp_of_newtype_info +end + +type local_type_kind = + | Enum of constructor list + | Struct of field list + | Newtype of newtype_info + | Placeholder + +include struct + let _ = fun (_ : local_type_kind) -> () + + let sexp_of_local_type_kind = + (function + | Enum arg0__001_ -> + let res0__002_ = + Moon_sexp_conv.sexp_of_list sexp_of_constructor arg0__001_ + in + S.List [ S.Atom "Enum"; res0__002_ ] + | Struct arg0__003_ -> + let res0__004_ = + Moon_sexp_conv.sexp_of_list sexp_of_field arg0__003_ + in + S.List [ S.Atom "Struct"; res0__004_ ] + | Newtype arg0__005_ -> + let res0__006_ = sexp_of_newtype_info arg0__005_ in + S.List [ S.Atom "Newtype"; res0__006_ ] + | Placeholder -> S.Atom "Placeholder" + : local_type_kind -> S.t) + + let _ = sexp_of_local_type_kind +end + +type t = { + name : string; + toplevel_id : Type_path.toplevel_id; + kind : local_type_kind; + loc_ : location; + is_only_tag_enum : bool; [@sexp_drop_if fun x -> x = false] + ty_params_ : Tvar_env.t; +} + +include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (let (drop_if__017_ : bool -> Stdlib.Bool.t) = fun x -> x = false in + fun { + name = name__008_; + toplevel_id = toplevel_id__010_; + kind = kind__012_; + loc_ = loc___014_; + is_only_tag_enum = is_only_tag_enum__018_; + ty_params_ = ty_params___021_; + } -> + let bnds__007_ = ([] : _ Stdlib.List.t) in + let bnds__007_ = + let arg__022_ = Tvar_env.sexp_of_t ty_params___021_ in + (S.List [ S.Atom "ty_params_"; arg__022_ ] :: bnds__007_ + : _ Stdlib.List.t) + in + let bnds__007_ = + if drop_if__017_ is_only_tag_enum__018_ then bnds__007_ + else + let arg__020_ = Moon_sexp_conv.sexp_of_bool is_only_tag_enum__018_ in + let bnd__019_ = S.List [ S.Atom "is_only_tag_enum"; arg__020_ ] in + (bnd__019_ :: bnds__007_ : _ Stdlib.List.t) + in + let bnds__007_ = + let arg__015_ = sexp_of_location loc___014_ in + (S.List [ S.Atom "loc_"; arg__015_ ] :: bnds__007_ : _ Stdlib.List.t) + in + let bnds__007_ = + let arg__013_ = sexp_of_local_type_kind kind__012_ in + (S.List [ S.Atom "kind"; arg__013_ ] :: bnds__007_ : _ Stdlib.List.t) + in + let bnds__007_ = + let arg__011_ = Type_path.sexp_of_toplevel_id toplevel_id__010_ in + (S.List [ S.Atom "toplevel_id"; arg__011_ ] :: bnds__007_ + : _ Stdlib.List.t) + in + let bnds__007_ = + let arg__009_ = Moon_sexp_conv.sexp_of_string name__008_ in + (S.List [ S.Atom "name"; arg__009_ ] :: bnds__007_ : _ Stdlib.List.t) + in + S.List bnds__007_ + : t -> S.t) + + let _ = sexp_of_t +end + +let mangle_name (toplevel_id : Type_path.toplevel_id) (name : string) = + let toplevel_id = Type_path.toplevel_id_to_string toplevel_id in + (toplevel_id ^ "." ^ name : Stdlib.String.t) + +let to_generic_typedecl_info base t = + (let make_type_generic ty = + (let rec go (ty : Stype.t) = + (let ty = Stype.type_repr ty in + match ty with + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> + let params_ty, generic1 = gos params_ty in + let ret_ty, generic2 = go ret_ty in + let err_ty, generic3 = + match err_ty with + | Some err_ty -> + let t, g = go err_ty in + (Some t, g) + | None -> (None, false) + in + let generic_ = generic1 || generic2 || generic3 in + (Tarrow { params_ty; ret_ty; err_ty; is_async; generic_ }, generic_) + | T_constr { type_constructor; tys; is_suberror_ } -> + let tys, generic_ = gos tys in + ( T_constr { type_constructor; tys; generic_; is_suberror_ }, + generic_ ) + | Tparam _ -> (ty, true) + | _ -> (ty, false) + : Stype.t * bool) + and gos (tys : Stype.t list) = + (Lst.fold_right tys ([], false) (fun ty -> + fun (tys, generic1) -> + let ty, generic2 = go ty in + (ty :: tys, generic1 || generic2)) + : Stype.t list * bool) + in + fst (go ty) + : Stype.t) + in + let make_field_generic (f : field) = + { + f with + ty_params_ = t.ty_params_; + ty_field = make_type_generic f.ty_field; + ty_record = make_type_generic f.ty_record; + } + in + let make_constr_generic (c : constructor) = + { + c with + cs_ty_params_ = t.ty_params_; + cs_res = make_type_generic c.cs_res; + cs_args = Lst.map c.cs_args make_type_generic; + } + in + let make_newtype_generic (n : newtype_info) = + { + n with + underlying_typ = make_type_generic n.underlying_typ; + newtype_constr = make_constr_generic n.newtype_constr; + } + in + let ty_desc : Typedecl_info.type_components = + if Tvar_env.is_empty t.ty_params_ then + match t.kind with + | Enum cs -> Variant_type cs + | Struct fs -> Record_type { fields = fs; has_private_field_ = false } + | Newtype n -> New_type n + | Placeholder -> assert false + else + match t.kind with + | Enum cs -> + let cs = Lst.map cs make_constr_generic in + Variant_type cs + | Struct fs -> + let fs = Lst.map fs make_field_generic in + Record_type { fields = fs; has_private_field_ = false } + | Newtype n -> New_type (make_newtype_generic n) + | Placeholder -> assert false + in + { + ty_constr = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + (mangle_name t.toplevel_id t.name); + ty_arity = 0; + ty_desc; + ty_vis = Vis_default; + ty_params_ = t.ty_params_; + ty_loc_ = Rloc.to_loc ~base t.loc_; + ty_doc_ = Docstring.empty; + ty_attrs = []; + ty_is_only_tag_enum_ = t.is_only_tag_enum; + ty_is_suberror_ = false; + } + : Typedecl_info.t) + +type env = { + types : t Hash_string.t; + fields : field Hash_string.t; + constructors : constructor Hash_string.t; + base : Loc.t; +} + +include struct + let _ = fun (_ : env) -> () + + let sexp_of_env = + (fun { + types = types__024_; + fields = fields__026_; + constructors = constructors__028_; + base = base__030_; + } + -> + let bnds__023_ = ([] : _ Stdlib.List.t) in + let bnds__023_ = + let arg__031_ = Loc.sexp_of_t base__030_ in + (S.List [ S.Atom "base"; arg__031_ ] :: bnds__023_ : _ Stdlib.List.t) + in + let bnds__023_ = + let arg__029_ = + Hash_string.sexp_of_t sexp_of_constructor constructors__028_ + in + (S.List [ S.Atom "constructors"; arg__029_ ] :: bnds__023_ + : _ Stdlib.List.t) + in + let bnds__023_ = + let arg__027_ = Hash_string.sexp_of_t sexp_of_field fields__026_ in + (S.List [ S.Atom "fields"; arg__027_ ] :: bnds__023_ : _ Stdlib.List.t) + in + let bnds__023_ = + let arg__025_ = Hash_string.sexp_of_t sexp_of_t types__024_ in + (S.List [ S.Atom "types"; arg__025_ ] :: bnds__023_ : _ Stdlib.List.t) + in + S.List bnds__023_ + : env -> S.t) + + let _ = sexp_of_env +end + +let empty_env base = + ({ + types = Hash_string.create 17; + fields = Hash_string.create 17; + constructors = Hash_string.create 17; + base; + } + : env) + +let find_type env name = Hash_string.find_opt env.types name +let add_type env type_ = Hash_string.add env.types type_.name type_ +let update_type env type_ = Hash_string.replace env.types type_.name type_ + +let add_field env (field : field) = + Hash_string.add env.fields field.field_name field + +let add_constr env (constructor : constructor) = + Hash_string.add env.constructors constructor.constr_name constructor + +let find_constr env name = Hash_string.find_all env.constructors name +let find_field env name = Hash_string.find_all env.fields name +let iter_types env f = Hash_string.iter2 env.types f +let get_base_loc env = env.base + +type derive_task = { + decl : Parsing_syntax.type_decl; + type_path : Type_path.t; + directive : Parsing_syntax.deriving_directive; + trait_path : Type_path.t; +} + +type derive_tasks = derive_task list diff --git a/src/local_typing_worklist.ml b/src/local_typing_worklist.ml new file mode 100644 index 0000000..26d8f70 --- /dev/null +++ b/src/local_typing_worklist.ml @@ -0,0 +1,90 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Qual_ident = Basic_qual_ident +module Type_path = Basic_type_path +module Syntax = Parsing_syntax + +type typed_fn_annotation = { + params_ty : (Stype.t * Typedtree.typ option) list; + ret_ty : Stype.t; + err_ty : Stype.t option; + is_async : bool; + ret_annotation : Typeutil.ret_annotation; +} + +type value = + | Wl_top_expr of { + expr : Syntax.expr; + is_main : bool; + id : Qual_ident.t; + loc_ : Loc.t; + local_types : Syntax.local_type_decl list; + } + | Wl_top_letdef of { + binder : Syntax.binder; + expr : Syntax.expr; + is_pub : bool; + loc_ : Loc.t; + doc_ : Docstring.t; + attrs : Checked_attributes.t; + konstraint : Typedtree.typ option; + id : Qual_ident.t; + typ : Stype.t; + } + | Wl_top_funcdef of { + fun_binder : Syntax.binder; + decl_params : Syntax.parameter list; + params_loc : Rloc.t; + is_pub : bool; + doc : Docstring.t; + attrs : Checked_attributes.t; + decl_body : Syntax.decl_body; + loc_ : Loc.t; + id : Qual_ident.t; + kind : Typedtree.fun_decl_kind; + arity : Fn_arity.t; + tvar_env : Tvar_env.t; + constraint_names : Typedtree.type_name list; + typed_fn_annotation : typed_fn_annotation; + } + | Wl_derive of { + ty_decl : Typedecl_info.t; + syn_decl : Syntax.type_decl; + directive : Syntax.deriving_directive; + trait_path : Type_path.t; + loc_ : Loc.t; + } + +type const_decl = { + binder : Syntax.binder; + expr : Syntax.expr; + is_pub : bool; + loc_ : Loc.t; + doc_ : Docstring.t; + attrs : Checked_attributes.t; + konstraint : Typedtree.typ option; + id : Qual_ident.t; + typ : Stype.t; +} + +type t = { + global_env : Global_env.t; + values : value Basic_vec.t; + const_decls : Typedtree.impl list; + type_decls : Typedtree.type_decl list; + trait_decls : Typedtree.trait_decl list; + trait_alias : Typedtree.trait_alias_decl list; +} diff --git a/src/ltype.ml b/src/ltype.ml index 729c20a..3c725b7 100644 --- a/src/ltype.ml +++ b/src/ltype.ml @@ -16,15 +16,39 @@ module Ty_ident = Basic_ty_ident module Hashf = Basic_hashf -type t = +type int_kind = | I32_Int - | U32 | I32_Char | I32_Bool | I32_Unit | I32_Byte + | I32_Int16 + | I32_UInt16 | I32_Tag | I32_Option_Char + +include struct + let _ = fun (_ : int_kind) -> () + + let sexp_of_int_kind = + (function + | I32_Int -> S.Atom "I32_Int" + | I32_Char -> S.Atom "I32_Char" + | I32_Bool -> S.Atom "I32_Bool" + | I32_Unit -> S.Atom "I32_Unit" + | I32_Byte -> S.Atom "I32_Byte" + | I32_Int16 -> S.Atom "I32_Int16" + | I32_UInt16 -> S.Atom "I32_UInt16" + | I32_Tag -> S.Atom "I32_Tag" + | I32_Option_Char -> S.Atom "I32_Option_Char" + : int_kind -> S.t) + + let _ = sexp_of_int_kind +end + +type t = + | I32 of { kind : int_kind [@ceh.ignore] } + | U32 | I64 | U64 | F32 @@ -37,156 +61,153 @@ type t = | Ref_bytes | Ref_func | Ref_any + | Raw_func of { tid : Ty_ident.t } include struct let _ = fun (_ : t) -> () let sexp_of_t = (function - | I32_Int -> S.Atom "I32_Int" + | I32 { kind = kind__002_ } -> + let bnds__001_ = ([] : _ Stdlib.List.t) in + let bnds__001_ = + let arg__003_ = sexp_of_int_kind kind__002_ in + (S.List [ S.Atom "kind"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) + in + S.List (S.Atom "I32" :: bnds__001_) | U32 -> S.Atom "U32" - | I32_Char -> S.Atom "I32_Char" - | I32_Bool -> S.Atom "I32_Bool" - | I32_Unit -> S.Atom "I32_Unit" - | I32_Byte -> S.Atom "I32_Byte" - | I32_Tag -> S.Atom "I32_Tag" - | I32_Option_Char -> S.Atom "I32_Option_Char" | I64 -> S.Atom "I64" | U64 -> S.Atom "U64" | F32 -> S.Atom "F32" | F64 -> S.Atom "F64" - | Ref { tid = tid__002_ } -> - let bnds__001_ = ([] : _ Stdlib.List.t) in - let bnds__001_ = - let arg__003_ = Ty_ident.sexp_of_t tid__002_ in - (S.List [ S.Atom "tid"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) - in - S.List (S.Atom "Ref" :: bnds__001_) - | Ref_lazy_init { tid = tid__005_ } -> + | Ref { tid = tid__005_ } -> let bnds__004_ = ([] : _ Stdlib.List.t) in let bnds__004_ = let arg__006_ = Ty_ident.sexp_of_t tid__005_ in (S.List [ S.Atom "tid"; arg__006_ ] :: bnds__004_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_lazy_init" :: bnds__004_) - | Ref_nullable { tid = tid__008_ } -> + S.List (S.Atom "Ref" :: bnds__004_) + | Ref_lazy_init { tid = tid__008_ } -> let bnds__007_ = ([] : _ Stdlib.List.t) in let bnds__007_ = let arg__009_ = Ty_ident.sexp_of_t tid__008_ in (S.List [ S.Atom "tid"; arg__009_ ] :: bnds__007_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_nullable" :: bnds__007_) + S.List (S.Atom "Ref_lazy_init" :: bnds__007_) + | Ref_nullable { tid = tid__011_ } -> + let bnds__010_ = ([] : _ Stdlib.List.t) in + let bnds__010_ = + let arg__012_ = Ty_ident.sexp_of_t tid__011_ in + (S.List [ S.Atom "tid"; arg__012_ ] :: bnds__010_ : _ Stdlib.List.t) + in + S.List (S.Atom "Ref_nullable" :: bnds__010_) | Ref_extern -> S.Atom "Ref_extern" | Ref_string -> S.Atom "Ref_string" | Ref_bytes -> S.Atom "Ref_bytes" | Ref_func -> S.Atom "Ref_func" | Ref_any -> S.Atom "Ref_any" + | Raw_func { tid = tid__014_ } -> + let bnds__013_ = ([] : _ Stdlib.List.t) in + let bnds__013_ = + let arg__015_ = Ty_ident.sexp_of_t tid__014_ in + (S.List [ S.Atom "tid"; arg__015_ ] :: bnds__013_ : _ Stdlib.List.t) + in + S.List (S.Atom "Raw_func" :: bnds__013_) : t -> S.t) let _ = sexp_of_t let equal = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then true - else - match (a__010_, b__011_) with - | I32_Int, I32_Int -> true - | I32_Int, _ -> false - | _, I32_Int -> false - | U32, U32 -> true - | U32, _ -> false - | _, U32 -> false - | I32_Char, I32_Char -> true - | I32_Char, _ -> false - | _, I32_Char -> false - | I32_Bool, I32_Bool -> true - | I32_Bool, _ -> false - | _, I32_Bool -> false - | I32_Unit, I32_Unit -> true - | I32_Unit, _ -> false - | _, I32_Unit -> false - | I32_Byte, I32_Byte -> true - | I32_Byte, _ -> false - | _, I32_Byte -> false - | I32_Tag, I32_Tag -> true - | I32_Tag, _ -> false - | _, I32_Tag -> false - | I32_Option_Char, I32_Option_Char -> true - | I32_Option_Char, _ -> false - | _, I32_Option_Char -> false - | I64, I64 -> true - | I64, _ -> false - | _, I64 -> false - | U64, U64 -> true - | U64, _ -> false - | _, U64 -> false - | F32, F32 -> true - | F32, _ -> false - | _, F32 -> false - | F64, F64 -> true - | F64, _ -> false - | _, F64 -> false - | Ref _a__012_, Ref _b__013_ -> - Ty_ident.equal _a__012_.tid _b__013_.tid - | Ref _, _ -> false - | _, Ref _ -> false - | Ref_lazy_init _a__014_, Ref_lazy_init _b__015_ -> - Ty_ident.equal _a__014_.tid _b__015_.tid - | Ref_lazy_init _, _ -> false - | _, Ref_lazy_init _ -> false - | Ref_nullable _a__016_, Ref_nullable _b__017_ -> - Ty_ident.equal _a__016_.tid _b__017_.tid - | Ref_nullable _, _ -> false - | _, Ref_nullable _ -> false - | Ref_extern, Ref_extern -> true - | Ref_extern, _ -> false - | _, Ref_extern -> false - | Ref_string, Ref_string -> true - | Ref_string, _ -> false - | _, Ref_string -> false - | Ref_bytes, Ref_bytes -> true - | Ref_bytes, _ -> false - | _, Ref_bytes -> false - | Ref_func, Ref_func -> true - | Ref_func, _ -> false - | _, Ref_func -> false - | Ref_any, Ref_any -> true + (fun a__016_ -> + fun b__017_ -> + if Stdlib.( == ) a__016_ b__017_ then true + else + match (a__016_, b__017_) with + | I32 _a__018_, I32 _b__019_ -> true + | I32 _, _ -> false + | _, I32 _ -> false + | U32, U32 -> true + | U32, _ -> false + | _, U32 -> false + | I64, I64 -> true + | I64, _ -> false + | _, I64 -> false + | U64, U64 -> true + | U64, _ -> false + | _, U64 -> false + | F32, F32 -> true + | F32, _ -> false + | _, F32 -> false + | F64, F64 -> true + | F64, _ -> false + | _, F64 -> false + | Ref _a__020_, Ref _b__021_ -> + Ty_ident.equal _a__020_.tid _b__021_.tid + | Ref _, _ -> false + | _, Ref _ -> false + | Ref_lazy_init _a__022_, Ref_lazy_init _b__023_ -> + Ty_ident.equal _a__022_.tid _b__023_.tid + | Ref_lazy_init _, _ -> false + | _, Ref_lazy_init _ -> false + | Ref_nullable _a__024_, Ref_nullable _b__025_ -> + Ty_ident.equal _a__024_.tid _b__025_.tid + | Ref_nullable _, _ -> false + | _, Ref_nullable _ -> false + | Ref_extern, Ref_extern -> true + | Ref_extern, _ -> false + | _, Ref_extern -> false + | Ref_string, Ref_string -> true + | Ref_string, _ -> false + | _, Ref_string -> false + | Ref_bytes, Ref_bytes -> true + | Ref_bytes, _ -> false + | _, Ref_bytes -> false + | Ref_func, Ref_func -> true + | Ref_func, _ -> false + | _, Ref_func -> false + | Ref_any, Ref_any -> true + | Ref_any, _ -> false + | _, Ref_any -> false + | Raw_func _a__026_, Raw_func _b__027_ -> + Ty_ident.equal _a__026_.tid _b__027_.tid : t -> t -> bool) let _ = equal let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | I32_Int -> Ppx_base.hash_fold_int hsv 0 - | U32 -> Ppx_base.hash_fold_int hsv 1 - | I32_Char -> Ppx_base.hash_fold_int hsv 2 - | I32_Bool -> Ppx_base.hash_fold_int hsv 3 - | I32_Unit -> Ppx_base.hash_fold_int hsv 4 - | I32_Byte -> Ppx_base.hash_fold_int hsv 5 - | I32_Tag -> Ppx_base.hash_fold_int hsv 6 - | I32_Option_Char -> Ppx_base.hash_fold_int hsv 7 - | I64 -> Ppx_base.hash_fold_int hsv 8 - | U64 -> Ppx_base.hash_fold_int hsv 9 - | F32 -> Ppx_base.hash_fold_int hsv 10 - | F64 -> Ppx_base.hash_fold_int hsv 11 - | Ref _ir -> - let hsv = Ppx_base.hash_fold_int hsv 12 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_lazy_init _ir -> - let hsv = Ppx_base.hash_fold_int hsv 13 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_nullable _ir -> - let hsv = Ppx_base.hash_fold_int hsv 14 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_extern -> Ppx_base.hash_fold_int hsv 15 - | Ref_string -> Ppx_base.hash_fold_int hsv 16 - | Ref_bytes -> Ppx_base.hash_fold_int hsv 17 - | Ref_func -> Ppx_base.hash_fold_int hsv 18 - | Ref_any -> Ppx_base.hash_fold_int hsv 19 + (fun hsv -> + fun arg -> + match arg with + | I32 _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hsv + | U32 -> Ppx_base.hash_fold_int hsv 1 + | I64 -> Ppx_base.hash_fold_int hsv 2 + | U64 -> Ppx_base.hash_fold_int hsv 3 + | F32 -> Ppx_base.hash_fold_int hsv 4 + | F64 -> Ppx_base.hash_fold_int hsv 5 + | Ref _ir -> + let hsv = Ppx_base.hash_fold_int hsv 6 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_lazy_init _ir -> + let hsv = Ppx_base.hash_fold_int hsv 7 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_nullable _ir -> + let hsv = Ppx_base.hash_fold_int hsv 8 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_extern -> Ppx_base.hash_fold_int hsv 9 + | Ref_string -> Ppx_base.hash_fold_int hsv 10 + | Ref_bytes -> Ppx_base.hash_fold_int hsv 11 + | Ref_func -> Ppx_base.hash_fold_int hsv 12 + | Ref_any -> Ppx_base.hash_fold_int hsv 13 + | Raw_func _ir -> + let hsv = Ppx_base.hash_fold_int hsv 14 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -202,64 +223,87 @@ include struct let _ = hash end -type return_type = Ret_single of t | Ret_error of { ok_ty : t; err_ty : t } +let sexp_of_t t = + match t with I32 { kind } -> sexp_of_int_kind kind | _ -> sexp_of_t t + +let i32_int = I32 { kind = I32_Int } +let i32_char = I32 { kind = I32_Char } +let i32_bool = I32 { kind = I32_Bool } +let i32_unit = I32 { kind = I32_Unit } +let i32_byte = I32 { kind = I32_Byte } +let i32_int16 = I32 { kind = I32_Int16 } +let i32_uint16 = I32 { kind = I32_UInt16 } +let i32_tag = I32 { kind = I32_Tag } +let i32_option_char = I32 { kind = I32_Option_Char } + +type return_type = + | Ret_nothing + | Ret_single of t + | Ret_error of { ok_ty : t; err_ty : t } include struct let _ = fun (_ : return_type) -> () let sexp_of_return_type = (function - | Ret_single arg0__018_ -> - let res0__019_ = sexp_of_t arg0__018_ in - S.List [ S.Atom "Ret_single"; res0__019_ ] - | Ret_error { ok_ty = ok_ty__021_; err_ty = err_ty__023_ } -> - let bnds__020_ = ([] : _ Stdlib.List.t) in - let bnds__020_ = - let arg__024_ = sexp_of_t err_ty__023_ in - (S.List [ S.Atom "err_ty"; arg__024_ ] :: bnds__020_ + | Ret_nothing -> S.Atom "Ret_nothing" + | Ret_single arg0__028_ -> + let res0__029_ = sexp_of_t arg0__028_ in + S.List [ S.Atom "Ret_single"; res0__029_ ] + | Ret_error { ok_ty = ok_ty__031_; err_ty = err_ty__033_ } -> + let bnds__030_ = ([] : _ Stdlib.List.t) in + let bnds__030_ = + let arg__034_ = sexp_of_t err_ty__033_ in + (S.List [ S.Atom "err_ty"; arg__034_ ] :: bnds__030_ : _ Stdlib.List.t) in - let bnds__020_ = - let arg__022_ = sexp_of_t ok_ty__021_ in - (S.List [ S.Atom "ok_ty"; arg__022_ ] :: bnds__020_ + let bnds__030_ = + let arg__032_ = sexp_of_t ok_ty__031_ in + (S.List [ S.Atom "ok_ty"; arg__032_ ] :: bnds__030_ : _ Stdlib.List.t) in - S.List (S.Atom "Ret_error" :: bnds__020_) + S.List (S.Atom "Ret_error" :: bnds__030_) : return_type -> S.t) let _ = sexp_of_return_type let equal_return_type = - (fun a__025_ b__026_ -> - if Stdlib.( == ) a__025_ b__026_ then true - else - match (a__025_, b__026_) with - | Ret_single _a__027_, Ret_single _b__028_ -> equal _a__027_ _b__028_ - | Ret_single _, _ -> false - | _, Ret_single _ -> false - | Ret_error _a__029_, Ret_error _b__030_ -> - Stdlib.( && ) - (equal _a__029_.ok_ty _b__030_.ok_ty) - (equal _a__029_.err_ty _b__030_.err_ty) + (fun a__035_ -> + fun b__036_ -> + if Stdlib.( == ) a__035_ b__036_ then true + else + match (a__035_, b__036_) with + | Ret_nothing, Ret_nothing -> true + | Ret_nothing, _ -> false + | _, Ret_nothing -> false + | Ret_single _a__037_, Ret_single _b__038_ -> equal _a__037_ _b__038_ + | Ret_single _, _ -> false + | _, Ret_single _ -> false + | Ret_error _a__039_, Ret_error _b__040_ -> + Stdlib.( && ) + (equal _a__039_.ok_ty _b__040_.ok_ty) + (equal _a__039_.err_ty _b__040_.err_ty) : return_type -> return_type -> bool) let _ = equal_return_type let (hash_fold_return_type : Ppx_base.state -> return_type -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Ret_single _a0 -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = hsv in - hash_fold_t hsv _a0 - | Ret_error _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = - let hsv = hsv in - hash_fold_t hsv _ir.ok_ty - in - hash_fold_t hsv _ir.err_ty + (fun hsv -> + fun arg -> + match arg with + | Ret_nothing -> Ppx_base.hash_fold_int hsv 0 + | Ret_single _a0 -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + hash_fold_t hsv _a0 + | Ret_error _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = hsv in + hash_fold_t hsv _ir.ok_ty + in + hash_fold_t hsv _ir.err_ty : Ppx_base.state -> return_type -> Ppx_base.state) let _ = hash_fold_return_type @@ -281,41 +325,43 @@ include struct let _ = fun (_ : fn_sig) -> () let sexp_of_fn_sig = - (fun { params = params__032_; ret = ret__034_ } -> - let bnds__031_ = ([] : _ Stdlib.List.t) in - let bnds__031_ = - let arg__035_ = sexp_of_return_type ret__034_ in - (S.List [ S.Atom "ret"; arg__035_ ] :: bnds__031_ : _ Stdlib.List.t) + (fun { params = params__042_; ret = ret__044_ } -> + let bnds__041_ = ([] : _ Stdlib.List.t) in + let bnds__041_ = + let arg__045_ = sexp_of_return_type ret__044_ in + (S.List [ S.Atom "ret"; arg__045_ ] :: bnds__041_ : _ Stdlib.List.t) in - let bnds__031_ = - let arg__033_ = Moon_sexp_conv.sexp_of_list sexp_of_t params__032_ in - (S.List [ S.Atom "params"; arg__033_ ] :: bnds__031_ : _ Stdlib.List.t) + let bnds__041_ = + let arg__043_ = Moon_sexp_conv.sexp_of_list sexp_of_t params__042_ in + (S.List [ S.Atom "params"; arg__043_ ] :: bnds__041_ : _ Stdlib.List.t) in - S.List bnds__031_ + S.List bnds__041_ : fn_sig -> S.t) let _ = sexp_of_fn_sig let equal_fn_sig = - (fun a__036_ b__037_ -> - if Stdlib.( == ) a__036_ b__037_ then true - else - Stdlib.( && ) - (Ppx_base.equal_list - (fun a__038_ b__039_ -> equal a__038_ b__039_) - a__036_.params b__037_.params) - (equal_return_type a__036_.ret b__037_.ret) + (fun a__046_ -> + fun b__047_ -> + if Stdlib.( == ) a__046_ b__047_ then true + else + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__048_ -> fun b__049_ -> equal a__048_ b__049_) + a__046_.params b__047_.params) + (equal_return_type a__046_.ret b__047_.ret) : fn_sig -> fn_sig -> bool) let _ = equal_fn_sig let (hash_fold_fn_sig : Ppx_base.state -> fn_sig -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_list hash_fold_t hsv arg.params - in - hash_fold_return_type hsv arg.ret + fun hsv -> + fun arg -> + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_list hash_fold_t hsv arg.params + in + hash_fold_return_type hsv arg.ret let _ = hash_fold_fn_sig @@ -354,6 +400,7 @@ type def = | Ref_constructor of { args : (t * bool) list [@list] } | Ref_closure_abstract of { fn_sig : fn_sig } | Ref_object of { methods : fn_sig list } + | Ref_concrete_object of { abstract_obj_tid : Ty_ident.t; self : t } | Ref_closure of { fn_sig_tid : Ty_ident.t; captures : t list } include struct @@ -361,86 +408,99 @@ include struct let sexp_of_def = (function - | Ref_array { elem = elem__041_ } -> - let bnds__040_ = ([] : _ Stdlib.List.t) in - let bnds__040_ = - let arg__042_ = sexp_of_t elem__041_ in - (S.List [ S.Atom "elem"; arg__042_ ] :: bnds__040_ : _ Stdlib.List.t) + | Ref_array { elem = elem__051_ } -> + let bnds__050_ = ([] : _ Stdlib.List.t) in + let bnds__050_ = + let arg__052_ = sexp_of_t elem__051_ in + (S.List [ S.Atom "elem"; arg__052_ ] :: bnds__050_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_array" :: bnds__040_) - | Ref_struct { fields = fields__044_ } -> - let bnds__043_ = ([] : _ Stdlib.List.t) in - let bnds__043_ = - let arg__045_ = + S.List (S.Atom "Ref_array" :: bnds__050_) + | Ref_struct { fields = fields__054_ } -> + let bnds__053_ = ([] : _ Stdlib.List.t) in + let bnds__053_ = + let arg__055_ = Moon_sexp_conv.sexp_of_list - (fun (arg0__046_, arg1__047_) -> - let res0__048_ = sexp_of_t arg0__046_ - and res1__049_ = Moon_sexp_conv.sexp_of_bool arg1__047_ in - S.List [ res0__048_; res1__049_ ]) - fields__044_ + (fun (arg0__056_, arg1__057_) -> + let res0__058_ = sexp_of_t arg0__056_ + and res1__059_ = Moon_sexp_conv.sexp_of_bool arg1__057_ in + S.List [ res0__058_; res1__059_ ]) + fields__054_ in - (S.List [ S.Atom "fields"; arg__045_ ] :: bnds__043_ + (S.List [ S.Atom "fields"; arg__055_ ] :: bnds__053_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_struct" :: bnds__043_) - | Ref_late_init_struct { fields = fields__051_ } -> - let bnds__050_ = ([] : _ Stdlib.List.t) in - let bnds__050_ = - let arg__052_ = Moon_sexp_conv.sexp_of_list sexp_of_t fields__051_ in - (S.List [ S.Atom "fields"; arg__052_ ] :: bnds__050_ + S.List (S.Atom "Ref_struct" :: bnds__053_) + | Ref_late_init_struct { fields = fields__061_ } -> + let bnds__060_ = ([] : _ Stdlib.List.t) in + let bnds__060_ = + let arg__062_ = Moon_sexp_conv.sexp_of_list sexp_of_t fields__061_ in + (S.List [ S.Atom "fields"; arg__062_ ] :: bnds__060_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_late_init_struct" :: bnds__050_) - | Ref_constructor { args = args__055_ } -> - let bnds__053_ = ([] : _ Stdlib.List.t) in - let bnds__053_ = - if match args__055_ with [] -> true | _ -> false then bnds__053_ + S.List (S.Atom "Ref_late_init_struct" :: bnds__060_) + | Ref_constructor { args = args__065_ } -> + let bnds__063_ = ([] : _ Stdlib.List.t) in + let bnds__063_ = + if match args__065_ with [] -> true | _ -> false then bnds__063_ else - let arg__061_ = - (Moon_sexp_conv.sexp_of_list (fun (arg0__056_, arg1__057_) -> - let res0__058_ = sexp_of_t arg0__056_ - and res1__059_ = Moon_sexp_conv.sexp_of_bool arg1__057_ in - S.List [ res0__058_; res1__059_ ])) - args__055_ + let arg__071_ = + (Moon_sexp_conv.sexp_of_list (fun (arg0__066_, arg1__067_) -> + let res0__068_ = sexp_of_t arg0__066_ + and res1__069_ = Moon_sexp_conv.sexp_of_bool arg1__067_ in + S.List [ res0__068_; res1__069_ ])) + args__065_ in - let bnd__060_ = S.List [ S.Atom "args"; arg__061_ ] in - (bnd__060_ :: bnds__053_ : _ Stdlib.List.t) + let bnd__070_ = S.List [ S.Atom "args"; arg__071_ ] in + (bnd__070_ :: bnds__063_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_constructor" :: bnds__053_) - | Ref_closure_abstract { fn_sig = fn_sig__063_ } -> - let bnds__062_ = ([] : _ Stdlib.List.t) in - let bnds__062_ = - let arg__064_ = sexp_of_fn_sig fn_sig__063_ in - (S.List [ S.Atom "fn_sig"; arg__064_ ] :: bnds__062_ + S.List (S.Atom "Ref_constructor" :: bnds__063_) + | Ref_closure_abstract { fn_sig = fn_sig__073_ } -> + let bnds__072_ = ([] : _ Stdlib.List.t) in + let bnds__072_ = + let arg__074_ = sexp_of_fn_sig fn_sig__073_ in + (S.List [ S.Atom "fn_sig"; arg__074_ ] :: bnds__072_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_closure_abstract" :: bnds__062_) - | Ref_object { methods = methods__066_ } -> - let bnds__065_ = ([] : _ Stdlib.List.t) in - let bnds__065_ = - let arg__067_ = - Moon_sexp_conv.sexp_of_list sexp_of_fn_sig methods__066_ + S.List (S.Atom "Ref_closure_abstract" :: bnds__072_) + | Ref_object { methods = methods__076_ } -> + let bnds__075_ = ([] : _ Stdlib.List.t) in + let bnds__075_ = + let arg__077_ = + Moon_sexp_conv.sexp_of_list sexp_of_fn_sig methods__076_ in - (S.List [ S.Atom "methods"; arg__067_ ] :: bnds__065_ + (S.List [ S.Atom "methods"; arg__077_ ] :: bnds__075_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Ref_object" :: bnds__075_) + | Ref_concrete_object + { abstract_obj_tid = abstract_obj_tid__079_; self = self__081_ } -> + let bnds__078_ = ([] : _ Stdlib.List.t) in + let bnds__078_ = + let arg__082_ = sexp_of_t self__081_ in + (S.List [ S.Atom "self"; arg__082_ ] :: bnds__078_ : _ Stdlib.List.t) + in + let bnds__078_ = + let arg__080_ = Ty_ident.sexp_of_t abstract_obj_tid__079_ in + (S.List [ S.Atom "abstract_obj_tid"; arg__080_ ] :: bnds__078_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_object" :: bnds__065_) - | Ref_closure { fn_sig_tid = fn_sig_tid__069_; captures = captures__071_ } + S.List (S.Atom "Ref_concrete_object" :: bnds__078_) + | Ref_closure { fn_sig_tid = fn_sig_tid__084_; captures = captures__086_ } -> - let bnds__068_ = ([] : _ Stdlib.List.t) in - let bnds__068_ = - let arg__072_ = - Moon_sexp_conv.sexp_of_list sexp_of_t captures__071_ + let bnds__083_ = ([] : _ Stdlib.List.t) in + let bnds__083_ = + let arg__087_ = + Moon_sexp_conv.sexp_of_list sexp_of_t captures__086_ in - (S.List [ S.Atom "captures"; arg__072_ ] :: bnds__068_ + (S.List [ S.Atom "captures"; arg__087_ ] :: bnds__083_ : _ Stdlib.List.t) in - let bnds__068_ = - let arg__070_ = Ty_ident.sexp_of_t fn_sig_tid__069_ in - (S.List [ S.Atom "fn_sig_tid"; arg__070_ ] :: bnds__068_ + let bnds__083_ = + let arg__085_ = Ty_ident.sexp_of_t fn_sig_tid__084_ in + (S.List [ S.Atom "fn_sig_tid"; arg__085_ ] :: bnds__083_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_closure" :: bnds__068_) + S.List (S.Atom "Ref_closure" :: bnds__083_) : def -> S.t) let _ = sexp_of_def @@ -457,7 +517,7 @@ let ref_enum = Ref { tid = tid_enum } let ref_array_i32 = Ref { tid = tid_array_i32 } let ref_array_i64 = Ref { tid = tid_array_i64 } let ref_array_f64 = Ref { tid = tid_array_f64 } -let def_array_i32 = Ref_array { elem = I32_Int } +let def_array_i32 = Ref_array { elem = I32 { kind = I32_Int } } let def_array_i64 = Ref_array { elem = I64 } let def_array_f64 = Ref_array { elem = F64 } @@ -503,7 +563,7 @@ include struct let _ = fun (_ : type_defs) -> () let sexp_of_type_defs = - (fun x__075_ -> Ty_ident.Hash.sexp_of_t sexp_of_def x__075_ + (fun x__090_ -> Ty_ident.Hash.sexp_of_t sexp_of_def x__090_ : type_defs -> S.t) let _ = sexp_of_type_defs @@ -518,20 +578,20 @@ include struct let _ = fun (_ : type_defs_with_context) -> () let sexp_of_type_defs_with_context = - (fun { defs = defs__077_; fn_sig_tbl = fn_sig_tbl__079_ } -> - let bnds__076_ = ([] : _ Stdlib.List.t) in - let bnds__076_ = - let arg__080_ = - FnSigHash.sexp_of_t Ty_ident.sexp_of_t fn_sig_tbl__079_ + (fun { defs = defs__092_; fn_sig_tbl = fn_sig_tbl__094_ } -> + let bnds__091_ = ([] : _ Stdlib.List.t) in + let bnds__091_ = + let arg__095_ = + FnSigHash.sexp_of_t Ty_ident.sexp_of_t fn_sig_tbl__094_ in - (S.List [ S.Atom "fn_sig_tbl"; arg__080_ ] :: bnds__076_ + (S.List [ S.Atom "fn_sig_tbl"; arg__095_ ] :: bnds__091_ : _ Stdlib.List.t) in - let bnds__076_ = - let arg__078_ = sexp_of_type_defs defs__077_ in - (S.List [ S.Atom "defs"; arg__078_ ] :: bnds__076_ : _ Stdlib.List.t) + let bnds__091_ = + let arg__093_ = sexp_of_type_defs defs__092_ in + (S.List [ S.Atom "defs"; arg__093_ ] :: bnds__091_ : _ Stdlib.List.t) in - S.List bnds__076_ + S.List bnds__091_ : type_defs_with_context -> S.t) let _ = sexp_of_type_defs_with_context diff --git a/src/ltype_gc.ml b/src/ltype_gc.ml index 8acb5d5..84117bc 100644 --- a/src/ltype_gc.ml +++ b/src/ltype_gc.ml @@ -16,14 +16,38 @@ module Ty_ident = Basic_ty_ident module Hashf = Basic_hashf -type t = +type int_kind = | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte + | I32_Int16 + | I32_UInt16 | I32_Tag | I32_Option_Char + +include struct + let _ = fun (_ : int_kind) -> () + + let sexp_of_int_kind = + (function + | I32_Int -> S.Atom "I32_Int" + | I32_Char -> S.Atom "I32_Char" + | I32_Bool -> S.Atom "I32_Bool" + | I32_Unit -> S.Atom "I32_Unit" + | I32_Byte -> S.Atom "I32_Byte" + | I32_Int16 -> S.Atom "I32_Int16" + | I32_UInt16 -> S.Atom "I32_UInt16" + | I32_Tag -> S.Atom "I32_Tag" + | I32_Option_Char -> S.Atom "I32_Option_Char" + : int_kind -> S.t) + + let _ = sexp_of_int_kind +end + +type t = + | I32 of { kind : int_kind [@ceh.ignore] } | I64 | F32 | F64 @@ -41,37 +65,37 @@ include struct let sexp_of_t = (function - | I32_Int -> S.Atom "I32_Int" - | I32_Char -> S.Atom "I32_Char" - | I32_Bool -> S.Atom "I32_Bool" - | I32_Unit -> S.Atom "I32_Unit" - | I32_Byte -> S.Atom "I32_Byte" - | I32_Tag -> S.Atom "I32_Tag" - | I32_Option_Char -> S.Atom "I32_Option_Char" - | I64 -> S.Atom "I64" - | F32 -> S.Atom "F32" - | F64 -> S.Atom "F64" - | Ref { tid = tid__002_ } -> + | I32 { kind = kind__002_ } -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = - let arg__003_ = Ty_ident.sexp_of_t tid__002_ in - (S.List [ S.Atom "tid"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) + let arg__003_ = sexp_of_int_kind kind__002_ in + (S.List [ S.Atom "kind"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref" :: bnds__001_) - | Ref_lazy_init { tid = tid__005_ } -> + S.List (S.Atom "I32" :: bnds__001_) + | I64 -> S.Atom "I64" + | F32 -> S.Atom "F32" + | F64 -> S.Atom "F64" + | Ref { tid = tid__005_ } -> let bnds__004_ = ([] : _ Stdlib.List.t) in let bnds__004_ = let arg__006_ = Ty_ident.sexp_of_t tid__005_ in (S.List [ S.Atom "tid"; arg__006_ ] :: bnds__004_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_lazy_init" :: bnds__004_) - | Ref_nullable { tid = tid__008_ } -> + S.List (S.Atom "Ref" :: bnds__004_) + | Ref_lazy_init { tid = tid__008_ } -> let bnds__007_ = ([] : _ Stdlib.List.t) in let bnds__007_ = let arg__009_ = Ty_ident.sexp_of_t tid__008_ in (S.List [ S.Atom "tid"; arg__009_ ] :: bnds__007_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_nullable" :: bnds__007_) + S.List (S.Atom "Ref_lazy_init" :: bnds__007_) + | Ref_nullable { tid = tid__011_ } -> + let bnds__010_ = ([] : _ Stdlib.List.t) in + let bnds__010_ = + let arg__012_ = Ty_ident.sexp_of_t tid__011_ in + (S.List [ S.Atom "tid"; arg__012_ ] :: bnds__010_ : _ Stdlib.List.t) + in + S.List (S.Atom "Ref_nullable" :: bnds__010_) | Ref_extern -> S.Atom "Ref_extern" | Ref_string -> S.Atom "Ref_string" | Ref_bytes -> S.Atom "Ref_bytes" @@ -82,99 +106,80 @@ include struct let _ = sexp_of_t let equal = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then true - else - match (a__010_, b__011_) with - | I32_Int, I32_Int -> true - | I32_Int, _ -> false - | _, I32_Int -> false - | I32_Char, I32_Char -> true - | I32_Char, _ -> false - | _, I32_Char -> false - | I32_Bool, I32_Bool -> true - | I32_Bool, _ -> false - | _, I32_Bool -> false - | I32_Unit, I32_Unit -> true - | I32_Unit, _ -> false - | _, I32_Unit -> false - | I32_Byte, I32_Byte -> true - | I32_Byte, _ -> false - | _, I32_Byte -> false - | I32_Tag, I32_Tag -> true - | I32_Tag, _ -> false - | _, I32_Tag -> false - | I32_Option_Char, I32_Option_Char -> true - | I32_Option_Char, _ -> false - | _, I32_Option_Char -> false - | I64, I64 -> true - | I64, _ -> false - | _, I64 -> false - | F32, F32 -> true - | F32, _ -> false - | _, F32 -> false - | F64, F64 -> true - | F64, _ -> false - | _, F64 -> false - | Ref _a__012_, Ref _b__013_ -> - Ty_ident.equal _a__012_.tid _b__013_.tid - | Ref _, _ -> false - | _, Ref _ -> false - | Ref_lazy_init _a__014_, Ref_lazy_init _b__015_ -> - Ty_ident.equal _a__014_.tid _b__015_.tid - | Ref_lazy_init _, _ -> false - | _, Ref_lazy_init _ -> false - | Ref_nullable _a__016_, Ref_nullable _b__017_ -> - Ty_ident.equal _a__016_.tid _b__017_.tid - | Ref_nullable _, _ -> false - | _, Ref_nullable _ -> false - | Ref_extern, Ref_extern -> true - | Ref_extern, _ -> false - | _, Ref_extern -> false - | Ref_string, Ref_string -> true - | Ref_string, _ -> false - | _, Ref_string -> false - | Ref_bytes, Ref_bytes -> true - | Ref_bytes, _ -> false - | _, Ref_bytes -> false - | Ref_func, Ref_func -> true - | Ref_func, _ -> false - | _, Ref_func -> false - | Ref_any, Ref_any -> true + (fun a__013_ -> + fun b__014_ -> + if Stdlib.( == ) a__013_ b__014_ then true + else + match (a__013_, b__014_) with + | I32 _a__015_, I32 _b__016_ -> true + | I32 _, _ -> false + | _, I32 _ -> false + | I64, I64 -> true + | I64, _ -> false + | _, I64 -> false + | F32, F32 -> true + | F32, _ -> false + | _, F32 -> false + | F64, F64 -> true + | F64, _ -> false + | _, F64 -> false + | Ref _a__017_, Ref _b__018_ -> + Ty_ident.equal _a__017_.tid _b__018_.tid + | Ref _, _ -> false + | _, Ref _ -> false + | Ref_lazy_init _a__019_, Ref_lazy_init _b__020_ -> + Ty_ident.equal _a__019_.tid _b__020_.tid + | Ref_lazy_init _, _ -> false + | _, Ref_lazy_init _ -> false + | Ref_nullable _a__021_, Ref_nullable _b__022_ -> + Ty_ident.equal _a__021_.tid _b__022_.tid + | Ref_nullable _, _ -> false + | _, Ref_nullable _ -> false + | Ref_extern, Ref_extern -> true + | Ref_extern, _ -> false + | _, Ref_extern -> false + | Ref_string, Ref_string -> true + | Ref_string, _ -> false + | _, Ref_string -> false + | Ref_bytes, Ref_bytes -> true + | Ref_bytes, _ -> false + | _, Ref_bytes -> false + | Ref_func, Ref_func -> true + | Ref_func, _ -> false + | _, Ref_func -> false + | Ref_any, Ref_any -> true : t -> t -> bool) let _ = equal let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | I32_Int -> Ppx_base.hash_fold_int hsv 0 - | I32_Char -> Ppx_base.hash_fold_int hsv 1 - | I32_Bool -> Ppx_base.hash_fold_int hsv 2 - | I32_Unit -> Ppx_base.hash_fold_int hsv 3 - | I32_Byte -> Ppx_base.hash_fold_int hsv 4 - | I32_Tag -> Ppx_base.hash_fold_int hsv 5 - | I32_Option_Char -> Ppx_base.hash_fold_int hsv 6 - | I64 -> Ppx_base.hash_fold_int hsv 7 - | F32 -> Ppx_base.hash_fold_int hsv 8 - | F64 -> Ppx_base.hash_fold_int hsv 9 - | Ref _ir -> - let hsv = Ppx_base.hash_fold_int hsv 10 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_lazy_init _ir -> - let hsv = Ppx_base.hash_fold_int hsv 11 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_nullable _ir -> - let hsv = Ppx_base.hash_fold_int hsv 12 in - let hsv = hsv in - Ty_ident.hash_fold_t hsv _ir.tid - | Ref_extern -> Ppx_base.hash_fold_int hsv 13 - | Ref_string -> Ppx_base.hash_fold_int hsv 14 - | Ref_bytes -> Ppx_base.hash_fold_int hsv 15 - | Ref_func -> Ppx_base.hash_fold_int hsv 16 - | Ref_any -> Ppx_base.hash_fold_int hsv 17 + (fun hsv -> + fun arg -> + match arg with + | I32 _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = hsv in + hsv + | I64 -> Ppx_base.hash_fold_int hsv 1 + | F32 -> Ppx_base.hash_fold_int hsv 2 + | F64 -> Ppx_base.hash_fold_int hsv 3 + | Ref _ir -> + let hsv = Ppx_base.hash_fold_int hsv 4 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_lazy_init _ir -> + let hsv = Ppx_base.hash_fold_int hsv 5 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_nullable _ir -> + let hsv = Ppx_base.hash_fold_int hsv 6 in + let hsv = hsv in + Ty_ident.hash_fold_t hsv _ir.tid + | Ref_extern -> Ppx_base.hash_fold_int hsv 7 + | Ref_string -> Ppx_base.hash_fold_int hsv 8 + | Ref_bytes -> Ppx_base.hash_fold_int hsv 9 + | Ref_func -> Ppx_base.hash_fold_int hsv 10 + | Ref_any -> Ppx_base.hash_fold_int hsv 11 : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -190,49 +195,54 @@ include struct let _ = hash end +let sexp_of_t t = + match t with I32 { kind } -> sexp_of_int_kind kind | _ -> sexp_of_t t + type fn_sig = { params : t list; ret : t list } include struct let _ = fun (_ : fn_sig) -> () let sexp_of_fn_sig = - (fun { params = params__019_; ret = ret__021_ } -> - let bnds__018_ = ([] : _ Stdlib.List.t) in - let bnds__018_ = - let arg__022_ = Moon_sexp_conv.sexp_of_list sexp_of_t ret__021_ in - (S.List [ S.Atom "ret"; arg__022_ ] :: bnds__018_ : _ Stdlib.List.t) + (fun { params = params__024_; ret = ret__026_ } -> + let bnds__023_ = ([] : _ Stdlib.List.t) in + let bnds__023_ = + let arg__027_ = Moon_sexp_conv.sexp_of_list sexp_of_t ret__026_ in + (S.List [ S.Atom "ret"; arg__027_ ] :: bnds__023_ : _ Stdlib.List.t) in - let bnds__018_ = - let arg__020_ = Moon_sexp_conv.sexp_of_list sexp_of_t params__019_ in - (S.List [ S.Atom "params"; arg__020_ ] :: bnds__018_ : _ Stdlib.List.t) + let bnds__023_ = + let arg__025_ = Moon_sexp_conv.sexp_of_list sexp_of_t params__024_ in + (S.List [ S.Atom "params"; arg__025_ ] :: bnds__023_ : _ Stdlib.List.t) in - S.List bnds__018_ + S.List bnds__023_ : fn_sig -> S.t) let _ = sexp_of_fn_sig let equal_fn_sig = - (fun a__023_ b__024_ -> - if Stdlib.( == ) a__023_ b__024_ then true - else - Stdlib.( && ) - (Ppx_base.equal_list - (fun a__025_ b__026_ -> equal a__025_ b__026_) - a__023_.params b__024_.params) - (Ppx_base.equal_list - (fun a__027_ b__028_ -> equal a__027_ b__028_) - a__023_.ret b__024_.ret) + (fun a__028_ -> + fun b__029_ -> + if Stdlib.( == ) a__028_ b__029_ then true + else + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__030_ -> fun b__031_ -> equal a__030_ b__031_) + a__028_.params b__029_.params) + (Ppx_base.equal_list + (fun a__032_ -> fun b__033_ -> equal a__032_ b__033_) + a__028_.ret b__029_.ret) : fn_sig -> fn_sig -> bool) let _ = equal_fn_sig let (hash_fold_fn_sig : Ppx_base.state -> fn_sig -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_list hash_fold_t hsv arg.params - in - Ppx_base.hash_fold_list hash_fold_t hsv arg.ret + fun hsv -> + fun arg -> + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_list hash_fold_t hsv arg.params + in + Ppx_base.hash_fold_list hash_fold_t hsv arg.ret let _ = hash_fold_fn_sig @@ -271,6 +281,7 @@ type def = | Ref_constructor of { args : (t * bool) list [@list] } | Ref_closure_abstract of { fn_sig : fn_sig } | Ref_object of { methods : fn_sig list } + | Ref_concrete_object of { abstract_obj_tid : Basic_ty_ident.t; self : t } | Ref_closure of { fn_sig_tid : Ty_ident.t; captures : t list } include struct @@ -278,91 +289,113 @@ include struct let sexp_of_def = (function - | Ref_array { elem = elem__030_ } -> - let bnds__029_ = ([] : _ Stdlib.List.t) in - let bnds__029_ = - let arg__031_ = sexp_of_t elem__030_ in - (S.List [ S.Atom "elem"; arg__031_ ] :: bnds__029_ : _ Stdlib.List.t) + | Ref_array { elem = elem__035_ } -> + let bnds__034_ = ([] : _ Stdlib.List.t) in + let bnds__034_ = + let arg__036_ = sexp_of_t elem__035_ in + (S.List [ S.Atom "elem"; arg__036_ ] :: bnds__034_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_array" :: bnds__029_) - | Ref_struct { fields = fields__033_ } -> - let bnds__032_ = ([] : _ Stdlib.List.t) in - let bnds__032_ = - let arg__034_ = + S.List (S.Atom "Ref_array" :: bnds__034_) + | Ref_struct { fields = fields__038_ } -> + let bnds__037_ = ([] : _ Stdlib.List.t) in + let bnds__037_ = + let arg__039_ = Moon_sexp_conv.sexp_of_list - (fun (arg0__035_, arg1__036_) -> - let res0__037_ = sexp_of_t arg0__035_ - and res1__038_ = Moon_sexp_conv.sexp_of_bool arg1__036_ in - S.List [ res0__037_; res1__038_ ]) - fields__033_ + (fun (arg0__040_, arg1__041_) -> + let res0__042_ = sexp_of_t arg0__040_ + and res1__043_ = Moon_sexp_conv.sexp_of_bool arg1__041_ in + S.List [ res0__042_; res1__043_ ]) + fields__038_ in - (S.List [ S.Atom "fields"; arg__034_ ] :: bnds__032_ + (S.List [ S.Atom "fields"; arg__039_ ] :: bnds__037_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_struct" :: bnds__032_) - | Ref_late_init_struct { fields = fields__040_ } -> - let bnds__039_ = ([] : _ Stdlib.List.t) in - let bnds__039_ = - let arg__041_ = Moon_sexp_conv.sexp_of_list sexp_of_t fields__040_ in - (S.List [ S.Atom "fields"; arg__041_ ] :: bnds__039_ + S.List (S.Atom "Ref_struct" :: bnds__037_) + | Ref_late_init_struct { fields = fields__045_ } -> + let bnds__044_ = ([] : _ Stdlib.List.t) in + let bnds__044_ = + let arg__046_ = Moon_sexp_conv.sexp_of_list sexp_of_t fields__045_ in + (S.List [ S.Atom "fields"; arg__046_ ] :: bnds__044_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_late_init_struct" :: bnds__039_) - | Ref_constructor { args = args__044_ } -> - let bnds__042_ = ([] : _ Stdlib.List.t) in - let bnds__042_ = - if match args__044_ with [] -> true | _ -> false then bnds__042_ + S.List (S.Atom "Ref_late_init_struct" :: bnds__044_) + | Ref_constructor { args = args__049_ } -> + let bnds__047_ = ([] : _ Stdlib.List.t) in + let bnds__047_ = + if match args__049_ with [] -> true | _ -> false then bnds__047_ else - let arg__050_ = - (Moon_sexp_conv.sexp_of_list (fun (arg0__045_, arg1__046_) -> - let res0__047_ = sexp_of_t arg0__045_ - and res1__048_ = Moon_sexp_conv.sexp_of_bool arg1__046_ in - S.List [ res0__047_; res1__048_ ])) - args__044_ + let arg__055_ = + (Moon_sexp_conv.sexp_of_list (fun (arg0__050_, arg1__051_) -> + let res0__052_ = sexp_of_t arg0__050_ + and res1__053_ = Moon_sexp_conv.sexp_of_bool arg1__051_ in + S.List [ res0__052_; res1__053_ ])) + args__049_ in - let bnd__049_ = S.List [ S.Atom "args"; arg__050_ ] in - (bnd__049_ :: bnds__042_ : _ Stdlib.List.t) + let bnd__054_ = S.List [ S.Atom "args"; arg__055_ ] in + (bnd__054_ :: bnds__047_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_constructor" :: bnds__042_) - | Ref_closure_abstract { fn_sig = fn_sig__052_ } -> - let bnds__051_ = ([] : _ Stdlib.List.t) in - let bnds__051_ = - let arg__053_ = sexp_of_fn_sig fn_sig__052_ in - (S.List [ S.Atom "fn_sig"; arg__053_ ] :: bnds__051_ + S.List (S.Atom "Ref_constructor" :: bnds__047_) + | Ref_closure_abstract { fn_sig = fn_sig__057_ } -> + let bnds__056_ = ([] : _ Stdlib.List.t) in + let bnds__056_ = + let arg__058_ = sexp_of_fn_sig fn_sig__057_ in + (S.List [ S.Atom "fn_sig"; arg__058_ ] :: bnds__056_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_closure_abstract" :: bnds__051_) - | Ref_object { methods = methods__055_ } -> - let bnds__054_ = ([] : _ Stdlib.List.t) in - let bnds__054_ = - let arg__056_ = - Moon_sexp_conv.sexp_of_list sexp_of_fn_sig methods__055_ + S.List (S.Atom "Ref_closure_abstract" :: bnds__056_) + | Ref_object { methods = methods__060_ } -> + let bnds__059_ = ([] : _ Stdlib.List.t) in + let bnds__059_ = + let arg__061_ = + Moon_sexp_conv.sexp_of_list sexp_of_fn_sig methods__060_ in - (S.List [ S.Atom "methods"; arg__056_ ] :: bnds__054_ + (S.List [ S.Atom "methods"; arg__061_ ] :: bnds__059_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_object" :: bnds__054_) - | Ref_closure { fn_sig_tid = fn_sig_tid__058_; captures = captures__060_ } + S.List (S.Atom "Ref_object" :: bnds__059_) + | Ref_concrete_object + { abstract_obj_tid = abstract_obj_tid__063_; self = self__065_ } -> + let bnds__062_ = ([] : _ Stdlib.List.t) in + let bnds__062_ = + let arg__066_ = sexp_of_t self__065_ in + (S.List [ S.Atom "self"; arg__066_ ] :: bnds__062_ : _ Stdlib.List.t) + in + let bnds__062_ = + let arg__064_ = Basic_ty_ident.sexp_of_t abstract_obj_tid__063_ in + (S.List [ S.Atom "abstract_obj_tid"; arg__064_ ] :: bnds__062_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Ref_concrete_object" :: bnds__062_) + | Ref_closure { fn_sig_tid = fn_sig_tid__068_; captures = captures__070_ } -> - let bnds__057_ = ([] : _ Stdlib.List.t) in - let bnds__057_ = - let arg__061_ = - Moon_sexp_conv.sexp_of_list sexp_of_t captures__060_ + let bnds__067_ = ([] : _ Stdlib.List.t) in + let bnds__067_ = + let arg__071_ = + Moon_sexp_conv.sexp_of_list sexp_of_t captures__070_ in - (S.List [ S.Atom "captures"; arg__061_ ] :: bnds__057_ + (S.List [ S.Atom "captures"; arg__071_ ] :: bnds__067_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__059_ = Ty_ident.sexp_of_t fn_sig_tid__058_ in - (S.List [ S.Atom "fn_sig_tid"; arg__059_ ] :: bnds__057_ + let bnds__067_ = + let arg__069_ = Ty_ident.sexp_of_t fn_sig_tid__068_ in + (S.List [ S.Atom "fn_sig_tid"; arg__069_ ] :: bnds__067_ : _ Stdlib.List.t) in - S.List (S.Atom "Ref_closure" :: bnds__057_) + S.List (S.Atom "Ref_closure" :: bnds__067_) : def -> S.t) let _ = sexp_of_def end +let i32_int = I32 { kind = I32_Int } +let i32_char = I32 { kind = I32_Char } +let i32_bool = I32 { kind = I32_Bool } +let i32_unit = I32 { kind = I32_Unit } +let i32_byte = I32 { kind = I32_Byte } +let i32_int16 = I32 { kind = I32_Int16 } +let i32_uint16 = I32 { kind = I32_UInt16 } +let i32_tag = I32 { kind = I32_Tag } +let i32_option_char = I32 { kind = I32_Option_Char } let tid_string = Ty_ident.of_string "moonbit.string" let tid_bytes = Ty_ident.of_string "moonbit.bytes" let tid_enum = Ty_ident.of_string "moonbit.enum" @@ -374,7 +407,7 @@ let ref_enum = Ref { tid = tid_enum } let ref_array_i32 = Ref { tid = tid_array_i32 } let ref_array_i64 = Ref { tid = tid_array_i64 } let ref_array_f64 = Ref { tid = tid_array_f64 } -let def_array_i32 = Ref_array { elem = I32_Int } +let def_array_i32 = Ref_array { elem = I32 { kind = I32_Int } } let def_array_i64 = Ref_array { elem = I64 } let def_array_f64 = Ref_array { elem = F64 } @@ -420,7 +453,7 @@ include struct let _ = fun (_ : type_defs) -> () let sexp_of_type_defs = - (fun x__064_ -> Ty_ident.Hash.sexp_of_t sexp_of_def x__064_ + (fun x__074_ -> Ty_ident.Hash.sexp_of_t sexp_of_def x__074_ : type_defs -> S.t) let _ = sexp_of_type_defs @@ -435,20 +468,20 @@ include struct let _ = fun (_ : type_defs_with_context) -> () let sexp_of_type_defs_with_context = - (fun { defs = defs__066_; fn_sig_tbl = fn_sig_tbl__068_ } -> - let bnds__065_ = ([] : _ Stdlib.List.t) in - let bnds__065_ = - let arg__069_ = - FnSigHash.sexp_of_t Ty_ident.sexp_of_t fn_sig_tbl__068_ + (fun { defs = defs__076_; fn_sig_tbl = fn_sig_tbl__078_ } -> + let bnds__075_ = ([] : _ Stdlib.List.t) in + let bnds__075_ = + let arg__079_ = + FnSigHash.sexp_of_t Ty_ident.sexp_of_t fn_sig_tbl__078_ in - (S.List [ S.Atom "fn_sig_tbl"; arg__069_ ] :: bnds__065_ + (S.List [ S.Atom "fn_sig_tbl"; arg__079_ ] :: bnds__075_ : _ Stdlib.List.t) in - let bnds__065_ = - let arg__067_ = sexp_of_type_defs defs__066_ in - (S.List [ S.Atom "defs"; arg__067_ ] :: bnds__065_ : _ Stdlib.List.t) + let bnds__075_ = + let arg__077_ = sexp_of_type_defs defs__076_ in + (S.List [ S.Atom "defs"; arg__077_ ] :: bnds__075_ : _ Stdlib.List.t) in - S.List bnds__065_ + S.List bnds__075_ : type_defs_with_context -> S.t) let _ = sexp_of_type_defs_with_context diff --git a/src/ltype_gc_util.ml b/src/ltype_gc_util.ml index 5f0259b..6ab28c5 100644 --- a/src/ltype_gc_util.ml +++ b/src/ltype_gc_util.ml @@ -17,20 +17,23 @@ module Ltype = Ltype_gc module Tid = Basic_ty_ident module Hash_tid = Basic_ty_ident.Hash -let get_arr_elem (tid : Tid.t) (type_defs : Ltype.type_defs) : Ltype.t = - if Tid.equal tid Ltype.tid_bytes then I32_Byte - else - match Hash_tid.find_exn type_defs tid with - | Ref_array { elem } -> elem - | Ref_struct _ | Ref_late_init_struct _ | Ref_closure _ - | Ref_closure_abstract _ | Ref_object _ | Ref_constructor _ -> - assert false +let get_arr_elem (tid : Tid.t) (type_defs : Ltype.type_defs) = + (if Tid.equal tid Ltype.tid_bytes then Ltype.i32_byte + else + match Hash_tid.find_exn type_defs tid with + | Ref_array { elem } -> elem + | Ref_concrete_object _ -> assert false + | Ref_closure_abstract _ -> assert false + | Ref_late_init_struct _ -> assert false + | Ref_struct _ -> assert false + | Ref_closure _ -> assert false + | Ref_object _ -> assert false + | Ref_constructor _ -> assert false + : Ltype.t) let is_non_nullable_ref_type (ty : Ltype.t) = match ty with - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char | I64 | F32 | F64 -> - false + | I32 _ | I64 | F32 | F64 -> false | Ref_nullable _ -> false | Ref_lazy_init _ | Ref _ | Ref_extern | Ref_string | Ref_bytes | Ref_func | Ref_any -> diff --git a/src/ltype_util.ml b/src/ltype_util.ml deleted file mode 100644 index dcb3375..0000000 --- a/src/ltype_util.ml +++ /dev/null @@ -1,73 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Lst = Basic_lst -module Tid = Basic_ty_ident -module Hash_tid = Basic_ty_ident.Hash - -let size_of (t : Ltype.t) = - match t with - | F64 | I64 | U64 -> 8 - | F32 | I32_Int | U32 | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char | Ref_extern | Ref _ | Ref_nullable _ | Ref_lazy_init _ - | Ref_string | Ref_bytes | Ref_func | Ref_any -> - 4 - -let get_fields (tid : Tid.t) (type_defs : Ltype.type_defs) = - match Hash_tid.find_exn type_defs tid with - | Ref_struct { fields } -> Lst.map fields fst - | Ref_late_init_struct { fields } -> fields - | Ref_constructor { args } -> Lst.map args fst - | Ref_closure { fn_sig_tid = _; captures } -> captures - | Ref_array _ | Ref_closure_abstract _ | Ref_object _ -> assert false - -let get_arr_elem (tid : Tid.t) (type_defs : Ltype.type_defs) : Ltype.t = - if Tid.equal tid Ltype.tid_bytes then I32_Byte - else - match Hash_tid.find_exn type_defs tid with - | Ref_array { elem } -> elem - | Ref_struct _ | Ref_late_init_struct _ | Ref_closure _ - | Ref_closure_abstract _ | Ref_object _ | Ref_constructor _ -> - assert false - -let result_payload_type (ok_ty : Ltype.t) : Ltype.t = - match ok_ty with F64 | I64 | U64 -> I64 | _ -> I32_Int - -let convert_prim ~(from : Ltype.t) ~(to_ : Ltype.t) : Primitive.prim = - let to_operand_ty (ty : Ltype.t) = - match ty with - | I64 -> Primitive.I64 - | U64 -> Primitive.U64 - | F64 -> Primitive.F64 - | F32 -> Primitive.F32 - | _ -> Primitive.I32 - in - let from = to_operand_ty from in - let to_ = to_operand_ty to_ in - if from = to_ then Primitive.Pidentity - else if - from = F64 || to_ = F64 || from = F32 || to_ = F32 || from = U64 - || to_ = U64 - then Pconvert { kind = Reinterpret; from; to_ } - else Pconvert { kind = Convert; from; to_ } - -let is_gc_ref (ty : Ltype.t) = - match ty with - | I32_Int | U32 | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char | I64 | U64 | F32 | F64 | Ref_extern | Ref_func -> - false - | Ref _ | Ref_nullable _ | Ref_lazy_init _ | Ref_string | Ref_bytes | Ref_any - -> - true diff --git a/src/mcore.ml b/src/mcore.ml index dcb623a..1b13a8e 100644 --- a/src/mcore.ml +++ b/src/mcore.ml @@ -134,7 +134,7 @@ and expr = | Cexpr_unit of { loc_ : location } | Cexpr_var of { id : var; prim : prim option; ty : typ; loc_ : location } | Cexpr_prim of { prim : prim; args : expr list; ty : typ; loc_ : location } - [@build fun p args ty loc -> prim ~loc ~ty p args] + [@build fun p -> fun args -> fun ty -> fun loc -> prim ~loc ~ty p args] | Cexpr_let of { name : binder; rhs : expr; @@ -150,7 +150,7 @@ and expr = kind : letfn_kind; loc_ : location; } - | Cexpr_function of { func : fn; ty : typ; loc_ : location } + | Cexpr_function of { func : fn; ty : typ; is_raw_ : bool; loc_ : location } | Cexpr_apply of { func : var; args : expr list; @@ -172,7 +172,6 @@ and expr = loc_ : location; } | Cexpr_constr of { - constr : constr; tag : constr_tag; args : expr list; ty : typ; @@ -204,14 +203,23 @@ and expr = } | Cexpr_array of { exprs : expr list; ty : typ; loc_ : location } | Cexpr_assign of { var : var; expr : expr; ty : typ; loc_ : location } - | Cexpr_sequence of { expr1 : expr; expr2 : expr; ty : typ; loc_ : location } + | Cexpr_sequence of { + exprs : expr list; + last_expr : expr; + ty : typ; + loc_ : location; + } | Cexpr_if of { cond : expr; ifso : expr; ifnot : expr option; ty : typ; loc_ : location; - } [@build fun cond ifso ifnot ty loc -> if_ ~loc cond ~ifso ?ifnot] + } + [@build + fun cond -> + fun ifso -> + fun ifnot -> fun ty -> fun loc -> if_ ~loc cond ~ifso ?ifnot] | Cexpr_switch_constr of { obj : expr; cases : (constr_tag * binder option * expr) list; @@ -220,7 +228,10 @@ and expr = loc_ : location; } [@build - fun obj cases default ty loc -> switch_constr ~loc obj cases ~default] + fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constr ~loc obj cases ~default] | Cexpr_switch_constant of { obj : expr; cases : (constant * expr) list; @@ -229,7 +240,10 @@ and expr = loc_ : location; } [@build - fun obj cases default ty loc -> switch_constant ~loc obj cases ~default] + fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constant ~loc obj cases ~default] | Cexpr_loop of { params : param list; body : expr; @@ -243,7 +257,9 @@ and expr = label : loop_label; ty : typ; loc_ : location; - } [@build fun arg label ty loc_ -> break arg label ty ~loc_] + } + [@build + fun arg -> fun label -> fun ty -> fun loc_ -> break arg label ty ~loc_] | Cexpr_continue of { args : expr list; label : loop_label; @@ -262,6 +278,8 @@ and expr = ty : typ; loc_ : location; } + | Cexpr_and of { lhs : expr; rhs : expr; loc_ : location } + | Cexpr_or of { lhs : expr; rhs : expr; loc_ : location } and fn = { params : param list; body : expr } and param = { binder : binder; ty : typ; loc_ : location } @@ -271,22 +289,27 @@ and field_def = { label : label; pos : int; is_mut : bool; expr : expr } module Iter = struct class virtual ['a] iterbase = object - method visit_prim : 'a -> Primitive.prim -> unit = fun _ _ -> () - method visit_constr_tag : 'a -> constr_tag -> unit = fun _ _ -> () - method visit_constr : 'a -> constr -> unit = fun _ _ -> () - method visit_label : 'a -> label -> unit = fun _ _ -> () - method visit_accessor : 'a -> accessor -> unit = fun _ _ -> () - method visit_location : 'a -> location -> unit = fun _ _ -> () - method visit_absolute_loc : 'a -> absolute_loc -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_loop_label : 'a -> loop_label -> unit = fun _ _ -> () - method visit_typ : 'a -> typ -> unit = fun _ _ -> () - method visit_func_stubs : 'a -> func_stubs -> unit = fun _ _ -> () - method visit_return_kind : 'a -> return_kind -> unit = fun _ _ -> () + method visit_prim : 'a -> Primitive.prim -> unit = fun _ -> fun _ -> () + method visit_constr_tag : 'a -> constr_tag -> unit = fun _ -> fun _ -> () + method visit_constr : 'a -> constr -> unit = fun _ -> fun _ -> () + method visit_label : 'a -> label -> unit = fun _ -> fun _ -> () + method visit_accessor : 'a -> accessor -> unit = fun _ -> fun _ -> () + method visit_location : 'a -> location -> unit = fun _ -> fun _ -> () + + method visit_absolute_loc : 'a -> absolute_loc -> unit = + fun _ -> fun _ -> () + + method visit_binder : 'a -> binder -> unit = fun _ -> fun _ -> () + method visit_var : 'a -> var -> unit = fun _ -> fun _ -> () + method visit_loop_label : 'a -> loop_label -> unit = fun _ -> fun _ -> () + method visit_typ : 'a -> typ -> unit = fun _ -> fun _ -> () + method visit_func_stubs : 'a -> func_stubs -> unit = fun _ -> fun _ -> () + + method visit_return_kind : 'a -> return_kind -> unit = + fun _ -> fun _ -> () method private visit_object_key : 'a -> Object_util.object_key -> unit = - fun _ _ -> () + fun _ -> fun _ -> () end type _unused @@ -300,817 +323,1002 @@ module Iter = struct inherit [_] iterbase method visit_Ctop_expr : _ -> expr -> absolute_loc -> unit = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in - () - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> unit = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pub_ in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in + () + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_pub_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + () method visit_Ctop_fn : _ -> top_fun_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - () - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - string option -> - absolute_loc -> - unit = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_freturn_ty - in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (fun _visitors_this -> ()) t - | None -> ()) - _visitors_fexport_info_ - in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + () + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + string option -> + absolute_loc -> + unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fexport_info_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_freturn_ty + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_fexport_info_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + () method visit_top_item : _ -> top_item -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - export_info_ = _visitors_fexport_info_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty - _visitors_fexport_info_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + export_info_ = _visitors_fexport_info_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ method visit_top_fun_decl : _ -> top_fun_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (fun _visitors_this -> ()) t - | None -> ()) - _visitors_this.export_info_ - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_this.export_info_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.loc_ + in + () method visit_To_result : _ -> unit = fun env -> () method visit_Joinapply : _ -> var -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + () method visit_Return_err : _ -> typ -> unit = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - () + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + () method visit_handle_kind : _ -> handle_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> unit = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_unit : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_var - : _ -> var -> prim option -> typ -> location -> unit = - fun env _visitors_fid _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_prim env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> unit = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> unit = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> unit - = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_function : _ -> fn -> typ -> location -> unit = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - prim option -> - typ -> - location -> - unit = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind - _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_prim env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_object - : _ -> Object_util.object_key -> expr -> typ -> location -> unit = - fun env _visitors_fmethods_key _visitors_fself _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_object_key env _visitors_fmethods_key - in - let _visitors_r1 = self#visit_expr env _visitors_fself in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> unit = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - ())) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_var : + _ -> var -> prim option -> typ -> location -> unit = + fun env -> + fun _visitors_fid -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_prim env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> unit = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> unit = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> unit + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> unit = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + prim option -> + typ -> + location -> + unit = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_prim env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_object : + _ -> Object_util.object_key -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fmethods_key -> + fun _visitors_fself -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_object_key env _visitors_fmethods_key + in + let _visitors_r1 = self#visit_expr env _visitors_fself in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + ())) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> unit = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> unit = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_ffields_num - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> unit = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> unit = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_ffields_num + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fpos + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_array : _ -> expr list -> typ -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> unit = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> unit = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_binder env) t - | None -> ()) - _visitors_c1 - in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - ())) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - unit = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - unit = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> unit = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> unit = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> unit = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> unit = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> unit = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_binder env) t + | None -> ()) + _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + ())) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + ())) + _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + unit = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> unit = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> unit = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> unit = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_and : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Cexpr_or : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_expr : _ -> expr -> unit = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fprim - _visitors_fty _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ - | Cexpr_object - { - methods_key = _visitors_fmethods_key; - self = _visitors_fself; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_object env _visitors_fmethods_key - _visitors_fself _visitors_fty _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fprim + _visitors_fty _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ + | Cexpr_object + { + methods_key = _visitors_fmethods_key; + self = _visitors_fself; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_object env _visitors_fmethods_key + _visitors_fself _visitors_fty _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + () method visit_param : _ -> param -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + () method visit_Normal : _ -> typ -> unit = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - () + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + () method visit_Join : _ -> unit = fun env -> () method visit_apply_kind : _ -> apply_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.is_mut - in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.is_mut + in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + () end [@@@VISITORS.END] @@ -1123,47 +1331,52 @@ open struct inherit [_] Sexp_visitors.sexp method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x + fun _ -> fun x -> sexp_of_constant x - method visit_prim : 'a -> prim -> S.t = fun _ x -> sexp_of_prim x + method visit_prim : 'a -> prim -> S.t = fun _ -> fun x -> sexp_of_prim x method visit_constr_tag : 'a -> constr_tag -> S.t = - fun _ x -> sexp_of_constr_tag x + fun _ -> fun x -> sexp_of_constr_tag x + + method visit_constr : 'a -> constr -> S.t = + fun _ -> fun x -> sexp_of_constr x - method visit_constr : 'a -> constr -> S.t = fun _ x -> sexp_of_constr x - method visit_label : 'a -> label -> S.t = fun _ x -> sexp_of_label x + method visit_label : 'a -> label -> S.t = + fun _ -> fun x -> sexp_of_label x method visit_accessor : 'a -> accessor -> S.t = - fun _ x -> sexp_of_accessor x + fun _ -> fun x -> sexp_of_accessor x method visit_location : 'a -> location -> S.t = - fun _ x -> sexp_of_location x + fun _ -> fun x -> sexp_of_location x method visit_absolute_loc : 'a -> absolute_loc -> S.t = - fun _ x -> sexp_of_absolute_loc x + fun _ -> fun x -> sexp_of_absolute_loc x - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x + method visit_binder : 'a -> binder -> S.t = + fun _ -> fun x -> sexp_of_binder x + + method visit_var : 'a -> var -> S.t = fun _ -> fun x -> sexp_of_var x method visit_loop_label : 'a -> loop_label -> S.t = - fun _ x -> sexp_of_loop_label x + fun _ -> fun x -> sexp_of_loop_label x - method visit_typ : 'a -> typ -> S.t = fun _ x -> sexp_of_typ x + method visit_typ : 'a -> typ -> S.t = fun _ -> fun x -> sexp_of_typ x method visit_func_stubs : 'a -> func_stubs -> S.t = - fun _ x -> sexp_of_func_stubs x + fun _ -> fun x -> sexp_of_func_stubs x method visit_letfn_kind : 'a -> letfn_kind -> S.t = - fun _ x -> sexp_of_letfn_kind x + fun _ -> fun x -> sexp_of_letfn_kind x method visit_return_kind : 'a -> return_kind -> S.t = - fun _ x -> sexp_of_return_kind x + fun _ -> fun x -> sexp_of_return_kind x method private visit_test_name : 'a -> Syntax.test_name -> S.t = - fun _ x -> Syntax.sexp_of_test_name x + fun _ -> fun x -> Syntax.sexp_of_test_name x method private visit_object_key : 'a -> Object_util.object_key -> S.t = - fun _ x -> Object_util.sexp_of_object_key x + fun _ -> fun x -> Object_util.sexp_of_object_key x end include struct @@ -1175,948 +1388,1145 @@ open struct inherit [_] sexpbase method visit_Ctop_expr : _ -> expr -> absolute_loc -> S.t = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_expr" - [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> S.t = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_bool env _visitors_fis_pub_ in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_let" - [ - ("binder", _visitors_r0); - ("expr", _visitors_r1); - ("is_pub_", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in + self#visit_inline_record env "Ctop_expr" + [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_bool env _visitors_fis_pub_ in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ctop_let" + [ + ("binder", _visitors_r0); + ("expr", _visitors_r1); + ("is_pub_", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Ctop_fn : _ -> top_fun_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - self#visit_inline_tuple env "Ctop_fn" [ _visitors_r0 ] - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - string option -> - absolute_loc -> - S.t = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - self#visit_list self#visit_typ env _visitors_fparams_ty - in - let _visitors_r3 = - self#visit_option self#visit_typ env _visitors_freturn_ty - in - let _visitors_r4 = - self#visit_option self#visit_string env _visitors_fexport_info_ - in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ctop_stub" - [ - ("binder", _visitors_r0); - ("func_stubs", _visitors_r1); - ("params_ty", _visitors_r2); - ("return_ty", _visitors_r3); - ("export_info_", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + self#visit_inline_tuple env "Ctop_fn" [ _visitors_r0 ] + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + string option -> + absolute_loc -> + S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fexport_info_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + self#visit_list self#visit_typ env _visitors_fparams_ty + in + let _visitors_r3 = + self#visit_option self#visit_typ env _visitors_freturn_ty + in + let _visitors_r4 = + self#visit_option self#visit_string env + _visitors_fexport_info_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ctop_stub" + [ + ("binder", _visitors_r0); + ("func_stubs", _visitors_r1); + ("params_ty", _visitors_r2); + ("return_ty", _visitors_r3); + ("export_info_", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_top_item : _ -> top_item -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - export_info_ = _visitors_fexport_info_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty - _visitors_fexport_info_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + export_info_ = _visitors_fexport_info_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ method visit_top_fun_decl : _ -> top_fun_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - self#visit_option self#visit_string env - _visitors_this.export_info_ - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.loc_ - in - self#visit_record env - [ - ("binder", _visitors_r0); - ("func", _visitors_r1); - ("export_info_", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + self#visit_option self#visit_string env + _visitors_this.export_info_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.loc_ + in + self#visit_record env + [ + ("binder", _visitors_r0); + ("func", _visitors_r1); + ("export_info_", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_To_result : _ -> S.t = fun env -> self#visit_inline_tuple env "To_result" [] method visit_Joinapply : _ -> var -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - self#visit_inline_tuple env "Joinapply" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + self#visit_inline_tuple env "Joinapply" [ _visitors_r0 ] method visit_Return_err : _ -> typ -> S.t = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - self#visit_inline_record env "Return_err" - [ ("ok_ty", _visitors_r0) ] + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + self#visit_inline_record env "Return_err" + [ ("ok_ty", _visitors_r0) ] method visit_handle_kind : _ -> handle_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> S.t = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_const" - [ - ("c", _visitors_r0); ("ty", _visitors_r1); ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_const" + [ + ("c", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Cexpr_unit : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_unit" [ ("loc_", _visitors_r0) ] - - method visit_Cexpr_var - : _ -> var -> prim option -> typ -> location -> S.t = - fun env _visitors_fid _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - self#visit_option self#visit_prim env _visitors_fprim - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_var" - [ - ("id", _visitors_r0); - ("prim", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> S.t = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_prim" - [ - ("prim", _visitors_r0); - ("args", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> S.t = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_let" - [ - ("name", _visitors_r0); - ("rhs", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> S.t + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_unit" + [ ("loc_", _visitors_r0) ] + + method visit_Cexpr_var : + _ -> var -> prim option -> typ -> location -> S.t = + fun env -> + fun _visitors_fid -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + self#visit_option self#visit_prim env _visitors_fprim + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_var" + [ + ("id", _visitors_r0); + ("prim", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> S.t = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_prim" + [ + ("prim", _visitors_r0); + ("args", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_let" + [ + ("name", _visitors_r0); + ("rhs", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + self#visit_letfn_kind env _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_letfn" + [ + ("name", _visitors_r0); + ("fn", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("kind", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> S.t = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_letfn_kind env _visitors_fkind in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_letfn" - [ - ("name", _visitors_r0); - ("fn", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("kind", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Cexpr_function : _ -> fn -> typ -> location -> S.t = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_function" - [ - ("func", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - prim option -> - typ -> - location -> - S.t = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind - _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = - self#visit_option self#visit_prim env _visitors_fprim - in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_apply" - [ - ("func", _visitors_r0); - ("args", _visitors_r1); - ("kind", _visitors_r2); - ("prim", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Cexpr_object - : _ -> Object_util.object_key -> expr -> typ -> location -> S.t = - fun env _visitors_fmethods_key _visitors_fself _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_object_key env _visitors_fmethods_key - in - let _visitors_r1 = self#visit_expr env _visitors_fself in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_object" - [ - ("methods_key", _visitors_r0); - ("self", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> S.t = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_letrec" - [ - ("bindings", _visitors_r0); - ("body", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> S.t = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_constr" - [ - ("constr", _visitors_r0); - ("tag", _visitors_r1); - ("args", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_bool env _visitors_fis_raw_ in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_function" + [ + ("func", _visitors_r0); + ("ty", _visitors_r1); + ("is_raw_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + prim option -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = + self#visit_option self#visit_prim env _visitors_fprim + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_apply" + [ + ("func", _visitors_r0); + ("args", _visitors_r1); + ("kind", _visitors_r2); + ("prim", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Cexpr_object : + _ -> Object_util.object_key -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fmethods_key -> + fun _visitors_fself -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_object_key env _visitors_fmethods_key + in + let _visitors_r1 = self#visit_expr env _visitors_fself in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_object" + [ + ("methods_key", _visitors_r0); + ("self", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_letrec" + [ + ("bindings", _visitors_r0); + ("body", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> S.t = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_constr" + [ + ("tag", _visitors_r0); + ("args", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_tuple" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> S.t = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_record" - [ - ("fields", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r2 = self#visit_int env _visitors_ffields_num in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_record_update" - [ - ("record", _visitors_r0); - ("fields", _visitors_r1); - ("fields_num", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_int env _visitors_fpos in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_field" - [ - ("record", _visitors_r0); - ("accessor", _visitors_r1); - ("pos", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> S.t = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = self#visit_int env _visitors_fpos in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_mutate" - [ - ("record", _visitors_r0); - ("label", _visitors_r1); - ("field", _visitors_r2); - ("pos", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_tuple" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> S.t = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_record" + [ + ("fields", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r2 = self#visit_int env _visitors_ffields_num in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_record_update" + [ + ("record", _visitors_r0); + ("fields", _visitors_r1); + ("fields_num", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = self#visit_int env _visitors_fpos in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_field" + [ + ("record", _visitors_r0); + ("accessor", _visitors_r1); + ("pos", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = self#visit_int env _visitors_fpos in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_mutate" + [ + ("record", _visitors_r0); + ("label", _visitors_r1); + ("field", _visitors_r2); + ("pos", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_Cexpr_array : _ -> expr list -> typ -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_array" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_array" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> S.t = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_assign" - [ - ("var", _visitors_r0); - ("expr", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_sequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> S.t = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_if" - [ - ("cond", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - self#visit_option self#visit_binder env _visitors_c1 + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_assign" + [ + ("var", _visitors_r0); + ("expr", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_sequence" + [ + ("exprs", _visitors_r0); + ("last_expr", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_if" + [ + ("cond", _visitors_r0); + ("ifso", _visitors_r1); + ("ifnot", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + self#visit_option self#visit_binder env _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + self#visit_tuple env + [ _visitors_r0; _visitors_r1; _visitors_r2 ]) + env _visitors_fcases + in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_switch_constr" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_constant env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_switch_constant" + [ + ("obj", _visitors_r0); + ("cases", _visitors_r1); + ("default", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + S.t = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_param env _visitors_fparams in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - self#visit_tuple env - [ _visitors_r0; _visitors_r1; _visitors_r2 ]) - env _visitors_fcases - in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_switch_constr" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - S.t = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_switch_constant" - [ - ("obj", _visitors_r0); - ("cases", _visitors_r1); - ("default", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - S.t = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_param env _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_loop" - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("args", _visitors_r2); - ("label", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> S.t = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_break" - [ - ("arg", _visitors_r0); - ("label", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> S.t = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_continue" - [ - ("args", _visitors_r0); - ("label", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> S.t = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_handle_error" - [ - ("obj", _visitors_r0); - ("handle_kind", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> S.t = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Cexpr_return" - [ - ("expr", _visitors_r0); - ("return_kind", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_loop" + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("args", _visitors_r2); + ("label", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> S.t = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_break" + [ + ("arg", _visitors_r0); + ("label", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> S.t = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_continue" + [ + ("args", _visitors_r0); + ("label", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> S.t = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_handle_error" + [ + ("obj", _visitors_r0); + ("handle_kind", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_return" + [ + ("expr", _visitors_r0); + ("return_kind", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Cexpr_and : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_and" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Cexpr_or : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Cexpr_or" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_expr : _ -> expr -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fprim - _visitors_fty _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ - | Cexpr_object - { - methods_key = _visitors_fmethods_key; - self = _visitors_fself; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_object env _visitors_fmethods_key - _visitors_fself _visitors_fty _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fprim + _visitors_fty _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ + | Cexpr_object + { + methods_key = _visitors_fmethods_key; + self = _visitors_fself; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_object env _visitors_fmethods_key + _visitors_fself _visitors_fty _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_list self#visit_param env _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - self#visit_record env - [ ("params", _visitors_r0); ("body", _visitors_r1) ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_param env _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + self#visit_record env + [ ("params", _visitors_r0); ("body", _visitors_r1) ] method visit_param : _ -> param -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - self#visit_record env - [ - ("binder", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + self#visit_record env + [ + ("binder", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Normal : _ -> typ -> S.t = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - self#visit_inline_record env "Normal" [ ("func_ty", _visitors_r0) ] + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + self#visit_inline_record env "Normal" [ ("func_ty", _visitors_r0) ] method visit_Join : _ -> S.t = fun env -> self#visit_inline_tuple env "Join" [] method visit_apply_kind : _ -> apply_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = self#visit_int env _visitors_this.pos in - let _visitors_r2 = self#visit_bool env _visitors_this.is_mut in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - self#visit_record env - [ - ("label", _visitors_r0); - ("pos", _visitors_r1); - ("is_mut", _visitors_r2); - ("expr", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = self#visit_int env _visitors_this.pos in + let _visitors_r2 = self#visit_bool env _visitors_this.is_mut in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + self#visit_record env + [ + ("label", _visitors_r0); + ("pos", _visitors_r1); + ("is_mut", _visitors_r2); + ("expr", _visitors_r3); + ] end [@@@VISITORS.END] @@ -2129,6 +2539,8 @@ open struct | "continue_block", S.List [] -> None | "prim", S.List [] -> None | "is_handle_error", S.Atom "false" -> None + | "is_raw_", Atom "false" -> None + | "is_raw_", Atom "true" -> Some ("is_raw_", S.List [ Atom "raw" ]) | _ -> Some field let compose f g x = match g x with None -> None | Some x -> f x @@ -2252,7 +2664,7 @@ open struct method! visit_location env loc = match env with - | Use_absolute_loc base -> Rloc.to_loc ~base loc |> sexp_of_absolute_loc + | Use_absolute_loc base -> sexp_of_absolute_loc (Rloc.to_loc ~base loc) | Use_relative_loc -> super#visit_location env loc end end @@ -2285,6 +2697,7 @@ let type_of_expr = function | Cexpr_return { ty; _ } | Cexpr_handle_error { ty; _ } -> ty + | Cexpr_and _ | Cexpr_or _ -> Mtype.T_bool | Cexpr_unit _ -> Mtype.T_unit let loc_of_expr = function @@ -2314,152 +2727,177 @@ let loc_of_expr = function | Cexpr_continue { loc_; _ } | Cexpr_loop { loc_; _ } | Cexpr_return { loc_; _ } + | Cexpr_and { loc_; _ } + | Cexpr_or { loc_; _ } | Cexpr_handle_error { loc_; _ } -> loc_ let ghost_loc_ = Rloc.no_location -let const ?(loc = ghost_loc_) (c : constant) : expr = - let ty = - match c with - | C_int _ -> Mtype.T_int - | C_int64 _ -> T_int64 - | C_uint _ -> T_uint - | C_uint64 _ -> T_uint64 - | C_float _ -> T_float - | C_double _ -> T_double - | C_char _ -> T_char - | C_bool _ -> T_bool - | C_string _ -> T_string - | C_bytes _ -> T_bytes - | C_bigint _ -> assert false - in - Cexpr_const { c; ty; loc_ = loc } - -let unit ?(loc = ghost_loc_) () : expr = Cexpr_unit { loc_ = loc } - -let prim ?(loc = ghost_loc_) ~ty (prim : Primitive.prim) args : expr = - match (prim, args) with - | ( Parith { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_arith operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | ( Pbitwise { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_bitwise operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | ( Pcomparison { operand_type; operator }, - [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( - match Constant.eval_comparison operand_type operator c1 c2 with - | Some c -> const ~loc c - | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) - | Psequand, [ (Cexpr_const { c = C_bool b; _ } as arg1); arg2 ] -> - if b then arg2 else arg1 - | Psequor, [ (Cexpr_const { c = C_bool b; _ } as arg1); arg2 ] -> - if b then arg1 else arg2 - | Pnot, Cexpr_const { c = C_bool b; _ } :: [] -> const ~loc (C_bool (not b)) - | Pcast { kind = Make_newtype }, arg :: [] -> arg - | _ -> Cexpr_prim { prim; args; ty; loc_ = loc } - -let eta_expand ~loc ~func_ty f : expr = - match func_ty with - | Mtype.T_func { params; return } as ty -> - let params, args = - Lst.map_split params (fun ty : (param * expr) -> - let id = Ident.fresh "x" in - ( { binder = id; ty; loc_ = ghost_loc_ }, - Cexpr_var { id; ty; loc_ = ghost_loc_; prim = None } )) - in - let body : expr = f ~return_ty:return args in - Cexpr_function { func = { params; body }; ty; loc_ = loc } - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_optimized_option _ | T_tuple _ - | T_fixedarray _ | T_constr _ | T_trait _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> - assert false +let const ?(loc = ghost_loc_) (c : constant) = + (let ty = + match c with + | C_int _ -> Mtype.T_int + | C_byte _ -> Mtype.T_byte + | C_int64 _ -> T_int64 + | C_uint _ -> T_uint + | C_uint64 _ -> T_uint64 + | C_float _ -> T_float + | C_double _ -> T_double + | C_char _ -> T_char + | C_bool _ -> T_bool + | C_string _ -> T_string + | C_bytes _ -> T_bytes + | C_bigint _ -> assert false + in + Cexpr_const { c; ty; loc_ = loc } + : expr) + +let unit ?(loc = ghost_loc_) () = (Cexpr_unit { loc_ = loc } : expr) + +let prim ?(loc = ghost_loc_) ~ty (prim : Primitive.prim) args = + (match (prim, args) with + | ( Parith { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_arith operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | ( Pbitwise { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_bitwise operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | ( Pcomparison { operand_type; operator }, + [ Cexpr_const { c = c1; _ }; Cexpr_const { c = c2; _ } ] ) -> ( + match Constant.eval_comparison operand_type operator c1 c2 with + | Some c -> const ~loc c + | None -> Cexpr_prim { prim; args; ty; loc_ = loc }) + | Pnot, Cexpr_const { c = C_bool b; _ } :: [] -> const ~loc (C_bool (not b)) + | Pcast { kind = Make_newtype }, arg :: [] -> arg + | _ -> Cexpr_prim { prim; args; ty; loc_ = loc } + : expr) + +let eta_expand ~loc ~func_ty f = + (match func_ty with + | Mtype.T_func { params; return } as ty -> + let params, args = + Lst.map_split params (fun ty -> + (let id = Ident.fresh "x" in + ( { binder = id; ty; loc_ = ghost_loc_ }, + Cexpr_var { id; ty; loc_ = ghost_loc_; prim = None } ) + : param * expr)) + in + let body : expr = f ~return_ty:return args in + Cexpr_function + { func = { params; body }; ty; is_raw_ = false; loc_ = loc } + | T_maybe_uninit _ -> assert false + | T_trait _ -> assert false + | T_fixedarray _ -> assert false + | T_optimized_option _ -> assert false + | T_string -> assert false + | T_float -> assert false + | T_uint -> assert false + | T_uint16 -> assert false + | T_byte -> assert false + | T_bool -> assert false + | T_int -> assert false + | T_raw_func _ -> assert false + | T_char -> assert false + | T_unit -> assert false + | T_int16 -> assert false + | T_int64 -> assert false + | T_uint64 -> assert false + | T_double -> assert false + | T_bytes -> assert false + | T_tuple _ -> assert false + | T_constr _ -> assert false + | T_any _ -> assert false + | T_error_value_result _ -> assert false + : expr) let unsaturated_prim ?(loc = ghost_loc_) ~ty prim = - eta_expand ~loc ~func_ty:ty (fun ~return_ty args -> - Cexpr_prim { prim; args; ty = return_ty; loc_ = ghost_loc_ }) - -let if_ ?(loc = ghost_loc_) ~ifso ?ifnot cond : expr = - match cond with - | Cexpr_const { c = C_bool true; _ } -> ifso - | Cexpr_const { c = C_bool false; _ } -> ( - match ifnot with Some ifnot -> ifnot | None -> unit ~loc ()) - | _ -> ( - match (ifso, ifnot) with - | ( Cexpr_const { c = C_bool true; _ }, - Some (Cexpr_const { c = C_bool false; _ }) ) -> - cond - | ( Cexpr_const { c = C_bool false; _ }, - Some (Cexpr_const { c = C_bool true; _ }) ) -> - prim ~loc ~ty:T_bool Pnot [ cond ] - | _ -> - let ty = type_of_expr ifso in - Cexpr_if { cond; ifso; ifnot; ty; loc_ = loc }) - -let let_ ~loc (name : Ident.t) (rhs : expr) (body : expr) : expr = - let ty = type_of_expr body in - match (rhs, name) with - | Cexpr_function { func; _ }, Pident _ -> - Cexpr_letfn { name; fn = func; kind = Nonrec; body; ty; loc_ = loc } - | _ -> Cexpr_let { name; rhs; body; ty; loc_ = loc } - -let switch_constr ~loc ~default obj cases : expr = - match obj with - | Cexpr_constr { constr = _; tag; args; ty = _ } -> - let rec select_case tag arg cases default = - match cases with - | [] -> ( - match default with Some default -> default | None -> assert false) - | (tag', param, action) :: rest -> - if Tag.equal tag' tag then - match param with - | None -> action - | Some param -> let_ ~loc param obj action - else select_case tag arg rest default - in - select_case tag args cases default - | _ -> - let ty = - match cases with - | (_, _, action0) :: _ -> type_of_expr action0 - | [] -> ( - match default with - | Some default -> type_of_expr default - | None -> assert false) - in - Cexpr_switch_constr { obj; cases; default; ty; loc_ = loc } - -let switch_constant ~loc ~default obj cases : expr = - match obj with - | Cexpr_const { c; _ } -> - let rec select_case c cases default = - match cases with - | [] -> default - | (c', action) :: rest -> - if Constant.equal c' c then action else select_case c rest default - in - select_case c cases default - | _ -> - let ty = type_of_expr default in - Cexpr_switch_constant { obj; cases; default; ty; loc_ = loc } - -let var ?(loc = ghost_loc_) ~(prim : Primitive.prim option) ~ty (id : Ident.t) : - expr = - Cexpr_var { id; prim; ty; loc_ = loc } - -let break ~loc_ arg label ty : expr = Cexpr_break { arg; label; ty; loc_ } + eta_expand ~loc ~func_ty:ty (fun ~return_ty -> + fun args -> Cexpr_prim { prim; args; ty = return_ty; loc_ = ghost_loc_ }) + +let if_ ?(loc = ghost_loc_) ~ifso ?ifnot cond = + (match cond with + | Cexpr_const { c = C_bool true; _ } -> ifso + | Cexpr_const { c = C_bool false; _ } -> ( + match ifnot with Some ifnot -> ifnot | None -> unit ~loc ()) + | _ -> ( + match (ifso, ifnot) with + | ( Cexpr_const { c = C_bool true; _ }, + Some (Cexpr_const { c = C_bool false; _ }) ) -> + cond + | ( Cexpr_const { c = C_bool false; _ }, + Some (Cexpr_const { c = C_bool true; _ }) ) -> + prim ~loc ~ty:T_bool Pnot [ cond ] + | _ -> + let ty = type_of_expr ifso in + Cexpr_if { cond; ifso; ifnot; ty; loc_ = loc }) + : expr) + +let let_ ~loc (name : Ident.t) (rhs : expr) (body : expr) = + (let ty = type_of_expr body in + match (rhs, name) with + | Cexpr_function { func; is_raw_ = false; _ }, Pident _ -> + Cexpr_letfn { name; fn = func; kind = Nonrec; body; ty; loc_ = loc } + | _ -> Cexpr_let { name; rhs; body; ty; loc_ = loc } + : expr) + +let switch_constr ~loc ~default obj cases = + (match obj with + | Cexpr_constr { tag; args; ty = _ } -> + let rec select_case tag arg cases default = + match cases with + | [] -> ( + match default with Some default -> default | None -> assert false) + | (tag', param, action) :: rest -> + if Tag.equal tag' tag then + match param with + | None -> action + | Some param -> let_ ~loc param obj action + else select_case tag arg rest default + in + select_case tag args cases default + | _ -> + let ty = + match cases with + | (_, _, action0) :: _ -> type_of_expr action0 + | [] -> ( + match default with + | Some default -> type_of_expr default + | None -> assert false) + in + Cexpr_switch_constr { obj; cases; default; ty; loc_ = loc } + : expr) + +let switch_constant ~loc ~default obj cases = + (match obj with + | Cexpr_const { c; _ } -> + let rec select_case c cases default = + match cases with + | [] -> default + | (c', action) :: rest -> + if Constant.equal c' c then action else select_case c rest default + in + select_case c cases default + | _ -> + let ty = type_of_expr default in + Cexpr_switch_constant { obj; cases; default; ty; loc_ = loc } + : expr) + +let var ?(loc = ghost_loc_) ~(prim : Primitive.prim option) ~ty (id : Ident.t) = + (Cexpr_var { id; prim; ty; loc_ = loc } : expr) + +let break ~loc_ arg label ty = (Cexpr_break { arg; label; ty; loc_ } : expr) let apply ?(loc = ghost_loc_) ~(prim : Primitive.prim option) ~ty ~kind - (func : Ident.t) (args : expr list) : expr = - Cexpr_apply { func; args; kind; prim; ty; loc_ = loc } + (func : Ident.t) (args : expr list) = + (Cexpr_apply { func; args; kind; prim; ty; loc_ = loc } : expr) -let make_object ?(loc = ghost_loc_) ~methods_key self ~ty : expr = - Cexpr_object { self; methods_key; ty; loc_ = loc } +let make_object ?(loc = ghost_loc_) ~methods_key self ~ty = + (Cexpr_object { self; methods_key; ty; loc_ = loc } : expr) let bind ?(loc = ghost_loc_) (rhs : expr) (cont : Ident.t -> expr) = match rhs with @@ -2468,109 +2906,125 @@ let bind ?(loc = ghost_loc_) (rhs : expr) (cont : Ident.t -> expr) = let id = Ident.fresh "bind" in let_ ~loc id rhs (cont id) -let field ~ty ~pos record accessor : expr = - Cexpr_field { record; accessor; pos; ty; loc_ = ghost_loc_ } +let field ~ty ~pos record accessor = + (Cexpr_field { record; accessor; pos; ty; loc_ = ghost_loc_ } : expr) -let return ?(loc = ghost_loc_) expr ~return_kind ~ty : expr = - Cexpr_return { expr; ty; return_kind; loc_ = loc } +let return ?(loc = ghost_loc_) expr ~return_kind ~ty = + (Cexpr_return { expr; ty; return_kind; loc_ = loc } : expr) -let sequence ~loc (expr1 : expr) (expr2 : expr) : expr = - let ty = type_of_expr expr2 in - Cexpr_sequence { expr1; expr2; ty; loc_ = loc } +let sequence ~loc (exprs : expr list) (last_expr : expr) = + (let ty = type_of_expr last_expr in + Cexpr_sequence { exprs; last_expr; ty; loc_ = loc } + : expr) let letfn ~loc ~kind name fn body = let ty = type_of_expr body in Cexpr_letfn { name; fn; kind; body; ty; loc_ = loc } -let letrec ~loc (bindings : (Ident.t * fn) list) body : expr = - let ty = type_of_expr body in - Cexpr_letrec { bindings; body; ty; loc_ = loc } - -let fn params body : fn = { params; body } - -let rec tail_map (e : expr) (f : expr -> expr) : expr = - let go e = tail_map e f [@@inline] in - let go_opt e = - match e with None -> None | Some e -> Some (go e) - [@@inline] - in - match e with - | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) - | Cexpr_letfn t -> ( - match t.kind with - | Tail_join | Nontail_join -> - letfn ~loc:t.loc_ ~kind:t.kind t.name - (fn t.fn.params (go t.fn.body)) - (go t.body) - | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) - | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) - | Cexpr_sequence t -> sequence ~loc:t.loc_ t.expr1 (go t.expr2) - | Cexpr_if t -> - if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond - | Cexpr_switch_constr t -> - let cases = - Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) - in - let default = go_opt t.default in - switch_constr ~loc:t.loc_ t.obj cases ~default - | Cexpr_switch_constant t -> - let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in - let default = go t.default in - switch_constant ~loc:t.loc_ ~default t.obj cases - | Cexpr_return { expr; _ } -> go expr - | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ | Cexpr_function _ - | Cexpr_apply _ | Cexpr_object _ | Cexpr_constr _ | Cexpr_tuple _ - | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ - | Cexpr_array _ | Cexpr_assign _ | Cexpr_loop _ | Cexpr_break _ - | Cexpr_continue _ | Cexpr_handle_error _ -> - f e +let letrec ~loc (bindings : (Ident.t * fn) list) body = + (let ty = type_of_expr body in + Cexpr_letrec { bindings; body; ty; loc_ = loc } + : expr) + +let fn params body = ({ params; body } : fn) + +let rec tail_map (e : expr) (f : expr -> expr) = + (let go e = tail_map e f [@@inline] in + let go_opt e = + match e with None -> None | Some e -> Some (go e) + [@@inline] + in + match e with + | Cexpr_let t -> let_ ~loc:t.loc_ t.name t.rhs (go t.body) + | Cexpr_letfn t -> ( + match t.kind with + | Tail_join | Nontail_join -> + letfn ~loc:t.loc_ ~kind:t.kind t.name + (fn t.fn.params (go t.fn.body)) + (go t.body) + | Rec | Nonrec -> letfn ~loc:t.loc_ ~kind:t.kind t.name t.fn (go t.body)) + | Cexpr_letrec t -> letrec ~loc:t.loc_ t.bindings (go t.body) + | Cexpr_sequence t -> sequence ~loc:t.loc_ t.exprs (go t.last_expr) + | Cexpr_if t -> + if_ ~loc:t.loc_ ~ifso:(go t.ifso) ?ifnot:(Option.map go t.ifnot) t.cond + | Cexpr_switch_constr t -> + let cases = + Lst.map t.cases (fun (tag, arg, action) -> (tag, arg, go action)) + in + let default = go_opt t.default in + switch_constr ~loc:t.loc_ t.obj cases ~default + | Cexpr_switch_constant t -> + let cases = Lst.map t.cases (fun (c, action) -> (c, go action)) in + let default = go t.default in + switch_constant ~loc:t.loc_ ~default t.obj cases + | Cexpr_return { expr; _ } -> go expr + | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_prim _ | Cexpr_and _ + | Cexpr_or _ | Cexpr_function _ | Cexpr_apply _ | Cexpr_object _ + | Cexpr_constr _ | Cexpr_tuple _ | Cexpr_record _ | Cexpr_record_update _ + | Cexpr_field _ | Cexpr_mutate _ | Cexpr_array _ | Cexpr_assign _ + | Cexpr_loop _ | Cexpr_break _ | Cexpr_continue _ | Cexpr_handle_error _ -> + f e + : expr) let joinlet_tail ~(loc : Rloc.t) (name : Ident.t) (params : param list) - (join_body : expr) (body : expr) : expr = - let default () : expr = - letfn ~loc name (fn params join_body) ~kind:Tail_join body - [@@inline] - in - match (body : expr) with - | Cexpr_apply { kind = Join; func; args; ty = _; _ } - when Ident.equal name func -> - Lst.fold_right2 params args join_body (fun param arg body -> - let_ ~loc:ghost_loc_ param.binder arg body) - | _ -> ( - match (params, join_body) with - | [], (Cexpr_const _ | Cexpr_unit _) -> - tail_map body (fun tail_expr -> - match tail_expr with - | Cexpr_apply { func; _ } when Ident.equal func name -> join_body - | _ -> tail_expr) - | _ -> default ()) - -let join_apply ~(loc : Rloc.t) ~ty join args : expr = - Cexpr_apply { func = join; args; kind = Join; ty; prim = None; loc_ = loc } + (join_body : expr) (body : expr) = + (let default () = + (letfn ~loc name (fn params join_body) ~kind:Tail_join body : expr) + [@@inline] + in + match (body : expr) with + | Cexpr_apply { kind = Join; func; args; ty = _; _ } + when Ident.equal name func -> + Lst.fold_right2 params args join_body (fun param -> + fun arg -> fun body -> let_ ~loc:ghost_loc_ param.binder arg body) + | _ -> ( + match (params, join_body) with + | [], (Cexpr_const _ | Cexpr_unit _) -> + tail_map body (fun tail_expr -> + match tail_expr with + | Cexpr_apply { func; _ } when Ident.equal func name -> join_body + | _ -> tail_expr) + | _ -> default ()) + : expr) + +let join_apply ~(loc : Rloc.t) ~ty join args = + (Cexpr_apply { func = join; args; kind = Join; ty; prim = None; loc_ = loc } + : expr) module Map = struct class virtual ['a] mapbase = object - method visit_prim : 'a -> Primitive.prim -> Primitive.prim = fun _ e -> e - method visit_constr_tag : 'a -> constr_tag -> constr_tag = fun _ e -> e - method visit_constr : 'a -> constr -> constr = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_accessor : 'a -> accessor -> accessor = fun _ e -> e - method visit_location : 'a -> location -> location = fun _ e -> e + method visit_prim : 'a -> Primitive.prim -> Primitive.prim = + fun _ -> fun e -> e + + method visit_constr_tag : 'a -> constr_tag -> constr_tag = + fun _ -> fun e -> e + + method visit_constr : 'a -> constr -> constr = fun _ -> fun e -> e + method visit_label : 'a -> label -> label = fun _ -> fun e -> e + method visit_accessor : 'a -> accessor -> accessor = fun _ -> fun e -> e + method visit_location : 'a -> location -> location = fun _ -> fun e -> e method visit_absolute_loc : 'a -> absolute_loc -> absolute_loc = - fun _ e -> e - - method visit_binder : 'a -> binder -> binder = fun _ e -> e - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_loop_label : 'a -> loop_label -> loop_label = fun _ e -> e - method visit_typ : 'a -> typ -> typ = fun _ e -> e - method visit_func_stubs : 'a -> func_stubs -> func_stubs = fun _ e -> e - method visit_return_kind : 'a -> return_kind -> return_kind = fun _ e -> e - - method private visit_object_key - : 'a -> Object_util.object_key -> Object_util.object_key = - fun _ e -> e + fun _ -> fun e -> e + + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + + method visit_loop_label : 'a -> loop_label -> loop_label = + fun _ -> fun e -> e + + method visit_typ : 'a -> typ -> typ = fun _ -> fun e -> e + + method visit_func_stubs : 'a -> func_stubs -> func_stubs = + fun _ -> fun e -> e + + method visit_return_kind : 'a -> return_kind -> return_kind = + fun _ -> fun e -> e + + method private visit_object_key : + 'a -> Object_util.object_key -> Object_util.object_key = + fun _ -> fun e -> e end type _unused @@ -2580,973 +3034,1182 @@ module Map = struct inherit [_] mapbase method visit_Ctop_expr : _ -> expr -> absolute_loc -> top_item = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_expr { expr = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Ctop_let - : _ -> binder -> expr -> bool -> absolute_loc -> top_item = - fun env _visitors_fbinder _visitors_fexpr _visitors_fis_pub_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ - in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_let - { - binder = _visitors_r0; - expr = _visitors_r1; - is_pub_ = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_absolute_loc env _visitors_floc_ in + Ctop_expr { expr = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Ctop_let : + _ -> binder -> expr -> bool -> absolute_loc -> top_item = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fexpr -> + fun _visitors_fis_pub_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pub_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + Ctop_let + { + binder = _visitors_r0; + expr = _visitors_r1; + is_pub_ = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Ctop_fn : _ -> top_fun_decl -> top_item = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in - Ctop_fn _visitors_r0 - - method visit_Ctop_stub - : _ -> - binder -> - func_stubs -> - typ list -> - typ option -> - string option -> - absolute_loc -> - top_item = - fun env _visitors_fbinder _visitors_ffunc_stubs _visitors_fparams_ty - _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_func_stubs env _visitors_ffunc_stubs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fparams_ty - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_freturn_ty - in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((fun _visitors_this -> _visitors_this) t) - | None -> None) - _visitors_fexport_info_ - in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - Ctop_stub - { - binder = _visitors_r0; - func_stubs = _visitors_r1; - params_ty = _visitors_r2; - return_ty = _visitors_r3; - export_info_ = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_top_fun_decl env _visitors_c0 in + Ctop_fn _visitors_r0 + + method visit_Ctop_stub : + _ -> + binder -> + func_stubs -> + typ list -> + typ option -> + string option -> + absolute_loc -> + top_item = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffunc_stubs -> + fun _visitors_fparams_ty -> + fun _visitors_freturn_ty -> + fun _visitors_fexport_info_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_func_stubs env _visitors_ffunc_stubs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fparams_ty + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_freturn_ty + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_fexport_info_ + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + Ctop_stub + { + binder = _visitors_r0; + func_stubs = _visitors_r1; + params_ty = _visitors_r2; + return_ty = _visitors_r3; + export_info_ = _visitors_r4; + loc_ = _visitors_r5; + } method visit_top_item : _ -> top_item -> top_item = - fun env _visitors_this -> - match _visitors_this with - | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ - | Ctop_let - { - binder = _visitors_fbinder; - expr = _visitors_fexpr; - is_pub_ = _visitors_fis_pub_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr - _visitors_fis_pub_ _visitors_floc_ - | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 - | Ctop_stub - { - binder = _visitors_fbinder; - func_stubs = _visitors_ffunc_stubs; - params_ty = _visitors_fparams_ty; - return_ty = _visitors_freturn_ty; - export_info_ = _visitors_fexport_info_; - loc_ = _visitors_floc_; - } -> - self#visit_Ctop_stub env _visitors_fbinder _visitors_ffunc_stubs - _visitors_fparams_ty _visitors_freturn_ty - _visitors_fexport_info_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ctop_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Ctop_expr env _visitors_fexpr _visitors_floc_ + | Ctop_let + { + binder = _visitors_fbinder; + expr = _visitors_fexpr; + is_pub_ = _visitors_fis_pub_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_let env _visitors_fbinder _visitors_fexpr + _visitors_fis_pub_ _visitors_floc_ + | Ctop_fn _visitors_c0 -> self#visit_Ctop_fn env _visitors_c0 + | Ctop_stub + { + binder = _visitors_fbinder; + func_stubs = _visitors_ffunc_stubs; + params_ty = _visitors_fparams_ty; + return_ty = _visitors_freturn_ty; + export_info_ = _visitors_fexport_info_; + loc_ = _visitors_floc_; + } -> + self#visit_Ctop_stub env _visitors_fbinder + _visitors_ffunc_stubs _visitors_fparams_ty + _visitors_freturn_ty _visitors_fexport_info_ _visitors_floc_ method visit_top_fun_decl : _ -> top_fun_decl -> top_fun_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_fn env _visitors_this.func in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((fun _visitors_this -> _visitors_this) t) - | None -> None) - _visitors_this.export_info_ - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.loc_ - in - { - binder = _visitors_r0; - func = _visitors_r1; - export_info_ = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_fn env _visitors_this.func in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_this.export_info_ + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.loc_ + in + { + binder = _visitors_r0; + func = _visitors_r1; + export_info_ = _visitors_r2; + loc_ = _visitors_r3; + } method visit_To_result : _ -> handle_kind = fun env -> To_result method visit_Joinapply : _ -> var -> handle_kind = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - Joinapply _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + Joinapply _visitors_r0 method visit_Return_err : _ -> typ -> handle_kind = - fun env _visitors_fok_ty -> - let _visitors_r0 = self#visit_typ env _visitors_fok_ty in - Return_err { ok_ty = _visitors_r0 } + fun env -> + fun _visitors_fok_ty -> + let _visitors_r0 = self#visit_typ env _visitors_fok_ty in + Return_err { ok_ty = _visitors_r0 } method visit_handle_kind : _ -> handle_kind -> handle_kind = - fun env _visitors_this -> - match _visitors_this with - | To_result -> self#visit_To_result env - | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 - | Return_err { ok_ty = _visitors_fok_ty } -> - self#visit_Return_err env _visitors_fok_ty + fun env -> + fun _visitors_this -> + match _visitors_this with + | To_result -> self#visit_To_result env + | Joinapply _visitors_c0 -> self#visit_Joinapply env _visitors_c0 + | Return_err { ok_ty = _visitors_fok_ty } -> + self#visit_Return_err env _visitors_fok_ty method visit_Cexpr_const : _ -> constant -> typ -> location -> expr = - fun env _visitors_fc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_const - { c = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_const + { c = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Cexpr_unit : _ -> location -> expr = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - Cexpr_unit { loc_ = _visitors_r0 } - - method visit_Cexpr_var - : _ -> var -> prim option -> typ -> location -> expr = - fun env _visitors_fid _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_prim env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_var - { - id = _visitors_r0; - prim = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_prim - : _ -> prim -> expr list -> typ -> location -> expr = - fun env _visitors_fprim _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_prim env _visitors_fprim in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - (fun p args ty loc -> prim ~loc ~ty p args) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 - - method visit_Cexpr_let - : _ -> binder -> expr -> expr -> typ -> location -> expr = - fun env _visitors_fname _visitors_frhs _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_let - { - name = _visitors_r0; - rhs = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_letfn - : _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> expr - = - fun env _visitors_fname _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fkind _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_letfn - { - name = _visitors_r0; - fn = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - kind = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Cexpr_function : _ -> fn -> typ -> location -> expr = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_function - { func = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_apply - : _ -> - var -> - expr list -> - apply_kind -> - prim option -> - typ -> - location -> - expr = - fun env _visitors_ffunc _visitors_fargs _visitors_fkind - _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_apply_kind env _visitors_fkind in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_prim env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_apply - { - func = _visitors_r0; - args = _visitors_r1; - kind = _visitors_r2; - prim = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Cexpr_object - : _ -> Object_util.object_key -> expr -> typ -> location -> expr = - fun env _visitors_fmethods_key _visitors_fself _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_object_key env _visitors_fmethods_key - in - let _visitors_r1 = self#visit_expr env _visitors_fself in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_object - { - methods_key = _visitors_r0; - self = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_letrec - : _ -> (binder * fn) list -> expr -> typ -> location -> expr = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_letrec - { - bindings = _visitors_r0; - body = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_constr - : _ -> constr -> constr_tag -> expr list -> typ -> location -> expr + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + Cexpr_unit { loc_ = _visitors_r0 } + + method visit_Cexpr_var : + _ -> var -> prim option -> typ -> location -> expr = + fun env -> + fun _visitors_fid -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_prim env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_var + { + id = _visitors_r0; + prim = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_prim : + _ -> prim -> expr list -> typ -> location -> expr = + fun env -> + fun _visitors_fprim -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_prim env _visitors_fprim in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + (fun p -> fun args -> fun ty -> fun loc -> prim ~loc ~ty p args) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + + method visit_Cexpr_let : + _ -> binder -> expr -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fname -> + fun _visitors_frhs -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_let + { + name = _visitors_r0; + rhs = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_letfn : + _ -> binder -> fn -> expr -> typ -> letfn_kind -> location -> expr = + fun env -> + fun _visitors_fname -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fkind -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_letfn + { + name = _visitors_r0; + fn = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + kind = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Cexpr_function : _ -> fn -> typ -> bool -> location -> expr = - fun env _visitors_fconstr _visitors_ftag _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_constr env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_constr - { - constr = _visitors_r0; - tag = _visitors_r1; - args = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_function + { + func = _visitors_r0; + ty = _visitors_r1; + is_raw_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_apply : + _ -> + var -> + expr list -> + apply_kind -> + prim option -> + typ -> + location -> + expr = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fkind -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = + self#visit_apply_kind env _visitors_fkind + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_prim env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_apply + { + func = _visitors_r0; + args = _visitors_r1; + kind = _visitors_r2; + prim = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Cexpr_object : + _ -> Object_util.object_key -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fmethods_key -> + fun _visitors_fself -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_object_key env _visitors_fmethods_key + in + let _visitors_r1 = self#visit_expr env _visitors_fself in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_object + { + methods_key = _visitors_r0; + self = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_letrec : + _ -> (binder * fn) list -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_letrec + { + bindings = _visitors_r0; + body = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_constr : + _ -> constr_tag -> expr list -> typ -> location -> expr = + fun env -> + fun _visitors_ftag -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_constr + { + tag = _visitors_r0; + args = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Cexpr_tuple : _ -> expr list -> typ -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_tuple - { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_record - : _ -> field_def list -> typ -> location -> expr = - fun env _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_record - { fields = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Cexpr_record_update - : _ -> expr -> field_def list -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_ffields _visitors_ffields_num - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ffields_num - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_record_update - { - record = _visitors_r0; - fields = _visitors_r1; - fields_num = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_field - : _ -> expr -> accessor -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Cexpr_field - { - record = _visitors_r0; - accessor = _visitors_r1; - pos = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Cexpr_mutate - : _ -> expr -> label -> expr -> int -> typ -> location -> expr = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_mutate - { - record = _visitors_r0; - label = _visitors_r1; - field = _visitors_r2; - pos = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_tuple + { + exprs = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Cexpr_record : + _ -> field_def list -> typ -> location -> expr = + fun env -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_record + { + fields = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Cexpr_record_update : + _ -> expr -> field_def list -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_ffields_num -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_ffields_num + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_record_update + { + record = _visitors_r0; + fields = _visitors_r1; + fields_num = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_field : + _ -> expr -> accessor -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Cexpr_field + { + record = _visitors_r0; + accessor = _visitors_r1; + pos = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Cexpr_mutate : + _ -> expr -> label -> expr -> int -> typ -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_mutate + { + record = _visitors_r0; + label = _visitors_r1; + field = _visitors_r2; + pos = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } method visit_Cexpr_array : _ -> expr list -> typ -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Cexpr_array - { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_array + { + exprs = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Cexpr_assign : _ -> var -> expr -> typ -> location -> expr = - fun env _visitors_fvar _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_assign - { - var = _visitors_r0; - expr = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_sequence - : _ -> expr -> expr -> typ -> location -> expr = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_sequence - { - expr1 = _visitors_r0; - expr2 = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_if - : _ -> expr -> expr -> expr option -> typ -> location -> expr = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fifnot - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun cond ifso ifnot ty loc -> if_ ~loc cond ~ifso ?ifnot) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_switch_constr - : _ -> - expr -> - (constr_tag * binder option * expr) list -> - expr option -> - typ -> - location -> - expr = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_constr_tag env _visitors_c0 in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_binder env) t) - | None -> None) - _visitors_c1 - in - let _visitors_r2 = self#visit_expr env _visitors_c2 in - (_visitors_r0, _visitors_r1, _visitors_r2))) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fdefault - in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun obj cases default ty loc -> - switch_constr ~loc obj cases ~default) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_switch_constant - : _ -> - expr -> - (constant * expr) list -> - expr -> - typ -> - location -> - expr = - fun env _visitors_fobj _visitors_fcases _visitors_fdefault - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = self#visit_expr env _visitors_fdefault in - let _visitors_r3 = self#visit_typ env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - (fun obj cases default ty loc -> - switch_constant ~loc obj cases ~default) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 _visitors_r4 - - method visit_Cexpr_loop - : _ -> - param list -> - expr -> - expr list -> - loop_label -> - typ -> - location -> - expr = - fun env _visitors_fparams _visitors_fbody _visitors_fargs - _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_loop_label env _visitors_flabel in - let _visitors_r4 = self#visit_typ env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Cexpr_loop - { - params = _visitors_r0; - body = _visitors_r1; - args = _visitors_r2; - label = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Cexpr_break - : _ -> expr option -> loop_label -> typ -> location -> expr = - fun env _visitors_farg _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - (fun arg label ty loc_ -> break arg label ty ~loc_) - _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 - - method visit_Cexpr_continue - : _ -> expr list -> loop_label -> typ -> location -> expr = - fun env _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_loop_label env _visitors_flabel in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_continue - { - args = _visitors_r0; - label = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_handle_error - : _ -> expr -> handle_kind -> typ -> location -> expr = - fun env _visitors_fobj _visitors_fhandle_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fobj in - let _visitors_r1 = - self#visit_handle_kind env _visitors_fhandle_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_handle_error - { - obj = _visitors_r0; - handle_kind = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Cexpr_return - : _ -> expr -> return_kind -> typ -> location -> expr = - fun env _visitors_fexpr _visitors_freturn_kind _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_return_kind env _visitors_freturn_kind - in - let _visitors_r2 = self#visit_typ env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Cexpr_return - { - expr = _visitors_r0; - return_kind = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_assign + { + var = _visitors_r0; + expr = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_sequence : + _ -> expr list -> expr -> typ -> location -> expr = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_sequence + { + exprs = _visitors_r0; + last_expr = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_if : + _ -> expr -> expr -> expr option -> typ -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fifnot + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun cond -> + fun ifso -> + fun ifnot -> fun ty -> fun loc -> if_ ~loc cond ~ifso ?ifnot) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_switch_constr : + _ -> + expr -> + (constr_tag * binder option * expr) list -> + expr option -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = + self#visit_constr_tag env _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_binder env) t) + | None -> None) + _visitors_c1 + in + let _visitors_r2 = self#visit_expr env _visitors_c2 in + (_visitors_r0, _visitors_r1, _visitors_r2))) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fdefault + in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun obj -> + fun cases -> + fun default -> + fun ty -> fun loc -> switch_constr ~loc obj cases ~default) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_switch_constant : + _ -> + expr -> + (constant * expr) list -> + expr -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fcases -> + fun _visitors_fdefault -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fcases + in + let _visitors_r2 = self#visit_expr env _visitors_fdefault in + let _visitors_r3 = self#visit_typ env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + (fun obj -> + fun cases -> + fun default -> + fun ty -> + fun loc -> switch_constant ~loc obj cases ~default) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + _visitors_r4 + + method visit_Cexpr_loop : + _ -> + param list -> + expr -> + expr list -> + loop_label -> + typ -> + location -> + expr = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = + self#visit_loop_label env _visitors_flabel + in + let _visitors_r4 = self#visit_typ env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Cexpr_loop + { + params = _visitors_r0; + body = _visitors_r1; + args = _visitors_r2; + label = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Cexpr_break : + _ -> expr option -> loop_label -> typ -> location -> expr = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_farg + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + (fun arg -> + fun label -> fun ty -> fun loc_ -> break arg label ty ~loc_) + _visitors_r0 _visitors_r1 _visitors_r2 _visitors_r3 + + method visit_Cexpr_continue : + _ -> expr list -> loop_label -> typ -> location -> expr = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_loop_label env _visitors_flabel in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_continue + { + args = _visitors_r0; + label = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_handle_error : + _ -> expr -> handle_kind -> typ -> location -> expr = + fun env -> + fun _visitors_fobj -> + fun _visitors_fhandle_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fobj in + let _visitors_r1 = + self#visit_handle_kind env _visitors_fhandle_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_handle_error + { + obj = _visitors_r0; + handle_kind = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_return : + _ -> expr -> return_kind -> typ -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_freturn_kind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_return_kind env _visitors_freturn_kind + in + let _visitors_r2 = self#visit_typ env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Cexpr_return + { + expr = _visitors_r0; + return_kind = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Cexpr_and : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_and + { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Cexpr_or : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Cexpr_or + { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } method visit_expr : _ -> expr -> expr = - fun env _visitors_this -> - match _visitors_this with - | Cexpr_const - { c = _visitors_fc; ty = _visitors_fty; loc_ = _visitors_floc_ } - -> - self#visit_Cexpr_const env _visitors_fc _visitors_fty - _visitors_floc_ - | Cexpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Cexpr_unit env _visitors_floc_ - | Cexpr_var - { - id = _visitors_fid; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_var env _visitors_fid _visitors_fprim - _visitors_fty _visitors_floc_ - | Cexpr_prim - { - prim = _visitors_fprim; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs - _visitors_fty _visitors_floc_ - | Cexpr_let - { - name = _visitors_fname; - rhs = _visitors_frhs; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_let env _visitors_fname _visitors_frhs - _visitors_fbody _visitors_fty _visitors_floc_ - | Cexpr_letfn - { - name = _visitors_fname; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - kind = _visitors_fkind; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ - | Cexpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Cexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - kind = _visitors_fkind; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ - | Cexpr_object - { - methods_key = _visitors_fmethods_key; - self = _visitors_fself; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_object env _visitors_fmethods_key - _visitors_fself _visitors_fty _visitors_floc_ - | Cexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Cexpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fargs _visitors_fty _visitors_floc_ - | Cexpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_record - { - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record env _visitors_ffields _visitors_fty - _visitors_floc_ - | Cexpr_record_update - { - record = _visitors_frecord; - fields = _visitors_ffields; - fields_num = _visitors_ffields_num; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_record_update env _visitors_frecord - _visitors_ffields _visitors_ffields_num _visitors_fty - _visitors_floc_ - | Cexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ - | Cexpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_array env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Cexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_fty _visitors_floc_ - | Cexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Cexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Cexpr_switch_constr - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constr env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_switch_constant - { - obj = _visitors_fobj; - cases = _visitors_fcases; - default = _visitors_fdefault; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_switch_constant env _visitors_fobj - _visitors_fcases _visitors_fdefault _visitors_fty - _visitors_floc_ - | Cexpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_flabel _visitors_fty _visitors_floc_ - | Cexpr_break - { - arg = _visitors_farg; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_break env _visitors_farg _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_continue - { - args = _visitors_fargs; - label = _visitors_flabel; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel - _visitors_fty _visitors_floc_ - | Cexpr_handle_error - { - obj = _visitors_fobj; - handle_kind = _visitors_fhandle_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_handle_error env _visitors_fobj - _visitors_fhandle_kind _visitors_fty _visitors_floc_ - | Cexpr_return - { - expr = _visitors_fexpr; - return_kind = _visitors_freturn_kind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Cexpr_return env _visitors_fexpr - _visitors_freturn_kind _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Cexpr_const + { + c = _visitors_fc; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_const env _visitors_fc _visitors_fty + _visitors_floc_ + | Cexpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Cexpr_unit env _visitors_floc_ + | Cexpr_var + { + id = _visitors_fid; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_var env _visitors_fid _visitors_fprim + _visitors_fty _visitors_floc_ + | Cexpr_prim + { + prim = _visitors_fprim; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_prim env _visitors_fprim _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_let + { + name = _visitors_fname; + rhs = _visitors_frhs; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_let env _visitors_fname _visitors_frhs + _visitors_fbody _visitors_fty _visitors_floc_ + | Cexpr_letfn + { + name = _visitors_fname; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + kind = _visitors_fkind; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letfn env _visitors_fname _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fkind _visitors_floc_ + | Cexpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Cexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + kind = _visitors_fkind; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fkind _visitors_fprim _visitors_fty _visitors_floc_ + | Cexpr_object + { + methods_key = _visitors_fmethods_key; + self = _visitors_fself; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_object env _visitors_fmethods_key + _visitors_fself _visitors_fty _visitors_floc_ + | Cexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Cexpr_constr + { + tag = _visitors_ftag; + args = _visitors_fargs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_constr env _visitors_ftag _visitors_fargs + _visitors_fty _visitors_floc_ + | Cexpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_record + { + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record env _visitors_ffields _visitors_fty + _visitors_floc_ + | Cexpr_record_update + { + record = _visitors_frecord; + fields = _visitors_ffields; + fields_num = _visitors_ffields_num; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_record_update env _visitors_frecord + _visitors_ffields _visitors_ffields_num _visitors_fty + _visitors_floc_ + | Cexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_field env _visitors_frecord + _visitors_faccessor _visitors_fpos _visitors_fty + _visitors_floc_ + | Cexpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_fty _visitors_floc_ + | Cexpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_array env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Cexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_fty _visitors_floc_ + | Cexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Cexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Cexpr_switch_constr + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constr env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_switch_constant + { + obj = _visitors_fobj; + cases = _visitors_fcases; + default = _visitors_fdefault; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_switch_constant env _visitors_fobj + _visitors_fcases _visitors_fdefault _visitors_fty + _visitors_floc_ + | Cexpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_flabel _visitors_fty + _visitors_floc_ + | Cexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_break env _visitors_farg _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_continue env _visitors_fargs _visitors_flabel + _visitors_fty _visitors_floc_ + | Cexpr_handle_error + { + obj = _visitors_fobj; + handle_kind = _visitors_fhandle_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_handle_error env _visitors_fobj + _visitors_fhandle_kind _visitors_fty _visitors_floc_ + | Cexpr_return + { + expr = _visitors_fexpr; + return_kind = _visitors_freturn_kind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_return env _visitors_fexpr + _visitors_freturn_kind _visitors_fty _visitors_floc_ + | Cexpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Cexpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Cexpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_fn : _ -> fn -> fn = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env)) - _visitors_this.params - in - let _visitors_r1 = self#visit_expr env _visitors_this.body in - { params = _visitors_r0; body = _visitors_r1 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env)) + _visitors_this.params + in + let _visitors_r1 = self#visit_expr env _visitors_this.body in + { params = _visitors_r0; body = _visitors_r1 } method visit_param : _ -> param -> param = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_typ env _visitors_this.ty in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_typ env _visitors_this.ty in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Normal : _ -> typ -> apply_kind = - fun env _visitors_ffunc_ty -> - let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in - Normal { func_ty = _visitors_r0 } + fun env -> + fun _visitors_ffunc_ty -> + let _visitors_r0 = self#visit_typ env _visitors_ffunc_ty in + Normal { func_ty = _visitors_r0 } method visit_Join : _ -> apply_kind = fun env -> Join method visit_apply_kind : _ -> apply_kind -> apply_kind = - fun env _visitors_this -> - match _visitors_this with - | Normal { func_ty = _visitors_ffunc_ty } -> - self#visit_Normal env _visitors_ffunc_ty - | Join -> self#visit_Join env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Normal { func_ty = _visitors_ffunc_ty } -> + self#visit_Normal env _visitors_ffunc_ty + | Join -> self#visit_Join env method visit_field_def : _ -> field_def -> field_def = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.label in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.pos - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_mut - in - let _visitors_r3 = self#visit_expr env _visitors_this.expr in - { - label = _visitors_r0; - pos = _visitors_r1; - is_mut = _visitors_r2; - expr = _visitors_r3; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.label in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.pos + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_mut + in + let _visitors_r3 = self#visit_expr env _visitors_this.expr in + { + label = _visitors_r0; + pos = _visitors_r1; + is_mut = _visitors_r2; + expr = _visitors_r3; + } end end @@ -3554,17 +4217,23 @@ module Map_core = struct include struct class virtual ['self] map = object (self : 'self) - method visit_binder : 'a -> binder -> binder = fun _ e -> e - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_loop_label : 'a -> loop_label -> loop_label = fun _ e -> e + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + + method visit_loop_label : 'a -> loop_label -> loop_label = + fun _ -> fun e -> e + method virtual visit_typ : 'a -> Stype.t -> typ method virtual visit_tag : 'a -> Constr_info.constr_tag -> constr_tag - method private visit_Cexpr_const - : _ -> constant -> Stype.t -> location -> expr = - fun env c ty loc_ -> - let ty = self#visit_typ env ty in - Cexpr_const { c; ty; loc_ } + method private visit_Cexpr_const : + _ -> constant -> Stype.t -> location -> expr = + fun env -> + fun c -> + fun ty -> + fun loc_ -> + let ty = self#visit_typ env ty in + Cexpr_const { c; ty; loc_ } method virtual visit_Cexpr_var : 'a -> @@ -3583,45 +4252,63 @@ module Map_core = struct location -> expr - method visit_Cexpr_prim - : 'a -> prim -> Core.expr list -> Stype.t -> location -> expr = - fun env p args ty loc_ -> - let args = Lst.map args (self#visit_expr env) in - let ty = self#visit_typ env ty in - prim p args ~ty ~loc:loc_ - - method private visit_Cexpr_let - : 'a -> var -> Core.expr -> Core.expr -> Stype.t -> location -> expr - = - fun env name rhs body ty loc_ -> - let name = self#visit_binder env name in - let rhs = self#visit_expr env rhs in - let body = self#visit_expr env body in - let ty = self#visit_typ env ty in - Cexpr_let { name; rhs; body; ty; loc_ } - - method private visit_Cexpr_letfn - : 'a -> - var -> - Core.fn -> - Core.expr -> - Stype.t -> - letfn_kind -> - location -> - expr = - fun env name (fn : Core.fn) body ty kind loc_ -> - let name = self#visit_binder env name in - let fn = self#visit_fn env fn in - let body = self#visit_expr env body in - let ty = self#visit_typ env ty in - Cexpr_letfn { name; fn; body; ty; kind; loc_ } - - method private visit_Cexpr_function - : 'a -> Core.fn -> Stype.t -> location -> expr = - fun env func ty loc_ -> - let func = self#visit_fn env func in - let ty = self#visit_typ env ty in - Cexpr_function { func; ty; loc_ } + method visit_Cexpr_prim : + 'a -> prim -> Core.expr list -> Stype.t -> location -> expr = + fun env -> + fun p -> + fun args -> + fun ty -> + fun loc_ -> + let args = Lst.map args (self#visit_expr env) in + let ty = self#visit_typ env ty in + prim p args ~ty ~loc:loc_ + + method private visit_Cexpr_let : + 'a -> var -> Core.expr -> Core.expr -> Stype.t -> location -> expr = + fun env -> + fun name -> + fun rhs -> + fun body -> + fun ty -> + fun loc_ -> + let name = self#visit_binder env name in + let rhs = self#visit_expr env rhs in + let body = self#visit_expr env body in + let ty = self#visit_typ env ty in + Cexpr_let { name; rhs; body; ty; loc_ } + + method private visit_Cexpr_letfn : + 'a -> + var -> + Core.fn -> + Core.expr -> + Stype.t -> + letfn_kind -> + location -> + expr = + fun env -> + fun name -> + fun (fn : Core.fn) -> + fun body -> + fun ty -> + fun kind -> + fun loc_ -> + let name = self#visit_binder env name in + let fn = self#visit_fn env fn in + let body = self#visit_expr env body in + let ty = self#visit_typ env ty in + Cexpr_letfn { name; fn; body; ty; kind; loc_ } + + method private visit_Cexpr_function : + 'a -> Core.fn -> Stype.t -> bool -> location -> expr = + fun env -> + fun func -> + fun ty -> + fun is_raw_ -> + fun loc_ -> + let func = self#visit_fn env func in + let ty = self#visit_typ env ty in + Cexpr_function { func; ty; is_raw_; loc_ } method virtual visit_Cexpr_apply : 'a -> @@ -3634,307 +4321,389 @@ module Map_core = struct location -> expr - method private visit_Cexpr_letrec - : 'a -> - (var * Core.fn) list -> - Core.expr -> - Stype.t -> - location -> - expr = - fun env bindings body ty loc_ -> - let bindings = - Lst.map bindings (fun (binder, fn) -> - let binder = self#visit_binder env binder in - let fn = self#visit_fn env fn in - (binder, fn)) - in - let body = self#visit_expr env body in - let ty = self#visit_typ env ty in - Cexpr_letrec { bindings; body; ty; loc_ } - - method private visit_Cexpr_constr - : 'a -> - constr -> - Constr_info.constr_tag -> - Core.expr list -> - Stype.t -> - location -> - expr = - fun env constr tag args ty loc_ -> - let args = Lst.map args (self#visit_expr env) in - let ty = self#visit_typ env ty in - let tag = self#visit_tag env tag in - Cexpr_constr { constr; tag; args; ty; loc_ } - - method private visit_Cexpr_tuple - : 'a -> Core.expr list -> Stype.t -> location -> expr = - fun env exprs ty loc_ -> - let exprs = Lst.map exprs (self#visit_expr env) in - let ty = self#visit_typ env ty in - Cexpr_tuple { exprs; ty; loc_ } - - method private visit_Cexpr_record - : 'a -> Core.field_def list -> Stype.t -> location -> expr = - fun env fields ty loc_ -> - let fields = Lst.map fields (self#visit_field_def env) in - let ty = self#visit_typ env ty in - Cexpr_record { fields; ty; loc_ } - - method private visit_Cexpr_record_update - : 'a -> - Core.expr -> - Core.field_def list -> - int -> - Stype.t -> - location -> - expr = - fun env record fields fields_num ty loc_ -> - let record = self#visit_expr env record in - let fields = Lst.map fields (self#visit_field_def env) in - let ty = self#visit_typ env ty in - Cexpr_record_update { record; fields; fields_num; ty; loc_ } - - method private visit_Cexpr_field - : 'a -> Core.expr -> accessor -> int -> Stype.t -> location -> expr - = - fun env record accessor pos ty loc_ -> - let record = self#visit_expr env record in - match accessor with - | Newtype -> record - | Index _ | Label _ -> + method private visit_Cexpr_letrec : + 'a -> + (var * Core.fn) list -> + Core.expr -> + Stype.t -> + location -> + expr = + fun env -> + fun bindings -> + fun body -> + fun ty -> + fun loc_ -> + let bindings = + Lst.map bindings (fun (binder, fn) -> + let binder = self#visit_binder env binder in + let fn = self#visit_fn env fn in + (binder, fn)) + in + let body = self#visit_expr env body in let ty = self#visit_typ env ty in - Cexpr_field { record; accessor; pos; ty; loc_ } - - method private visit_Cexpr_mutate - : 'a -> - Core.expr -> - label -> - Core.expr -> - int -> - Stype.t -> - location -> - expr = - fun env record label field pos ty loc_ -> - let record = self#visit_expr env record in - let field = self#visit_expr env field in - let ty = self#visit_typ env ty in - Cexpr_mutate { record; label; field; pos; ty; loc_ } - - method private visit_Cexpr_array - : 'a -> Core.expr list -> Stype.t -> location -> expr = - fun env exprs ty loc_ -> - let exprs = Lst.map exprs (self#visit_expr env) in - let ty = self#visit_typ env ty in - Cexpr_array { exprs; ty; loc_ } - - method private visit_Cexpr_assign - : 'a -> var -> Core.expr -> Stype.t -> location -> expr = - fun env var expr ty loc_ -> - let var = self#visit_var env var in - let expr = self#visit_expr env expr in - let ty = self#visit_typ env ty in - Cexpr_assign { var; expr; ty; loc_ } - - method private visit_Cexpr_sequence - : 'a -> Core.expr -> Core.expr -> Stype.t -> location -> expr = - fun env expr1 expr2 ty loc_ -> - let expr1 = self#visit_expr env expr1 in - let expr2 = self#visit_expr env expr2 in - let ty = self#visit_typ env ty in - Cexpr_sequence { expr1; expr2; ty; loc_ } - - method private visit_Cexpr_if - : 'a -> - Core.expr -> - Core.expr -> - Core.expr option -> - Stype.t -> - location -> - expr = - fun env cond ifso ifnot _ty loc_ -> - let cond = self#visit_expr env cond in - let ifso = self#visit_expr env ifso in - let ifnot = Option.map (self#visit_expr env) ifnot in - if_ ~loc:loc_ cond ~ifso ?ifnot - - method private visit_Cexpr_switch_constr - : 'a -> - Core.expr -> - (Constr_info.constr_tag * var option * Core.expr) list -> - Core.expr option -> - Stype.t -> - location -> - expr = - fun env obj cases default _ty loc_ -> - let obj = self#visit_expr env obj in - let cases = - Lst.map cases (fun (tag, binder, expr) -> - let binder = Option.map (self#visit_binder env) binder in - let expr = self#visit_expr env expr in - let tag = self#visit_tag env tag in - (tag, binder, expr)) - in - let default = Option.map (self#visit_expr env) default in - switch_constr ~loc:loc_ obj cases ~default - - method private visit_Cexpr_switch_constant - : 'a -> - Core.expr -> - (constant * Core.expr) list -> - Core.expr -> - Stype.t -> - location -> - expr = - fun env obj cases default _ty loc_ -> - let obj = self#visit_expr env obj in - let cases = - Lst.map cases (fun (c, expr) -> - let expr = self#visit_expr env expr in - (c, expr)) - in - let default = self#visit_expr env default in - switch_constant ~loc:loc_ obj cases ~default - - method private visit_Cexpr_loop - : 'a -> - Core.param list -> - Core.expr -> - Core.expr list -> - loop_label -> - Stype.t -> - location -> - expr = - fun env params body args label ty loc_ -> - let params = Lst.map params (self#visit_param env) in - let body = self#visit_expr env body in - let args = Lst.map args (self#visit_expr env) in - let ty = self#visit_typ env ty in - let label = self#visit_loop_label env label in - Cexpr_loop { params; body; args; label; ty; loc_ } + Cexpr_letrec { bindings; body; ty; loc_ } + + method private visit_Cexpr_constr : + 'a -> + Constr_info.constr_tag -> + Core.expr list -> + Stype.t -> + location -> + expr = + fun env -> + fun tag -> + fun args -> + fun ty -> + fun loc_ -> + let args = Lst.map args (self#visit_expr env) in + let ty = self#visit_typ env ty in + let tag = self#visit_tag env tag in + Cexpr_constr { tag; args; ty; loc_ } + + method private visit_Cexpr_tuple : + 'a -> Core.expr list -> Stype.t -> location -> expr = + fun env -> + fun exprs -> + fun ty -> + fun loc_ -> + let exprs = Lst.map exprs (self#visit_expr env) in + let ty = self#visit_typ env ty in + Cexpr_tuple { exprs; ty; loc_ } + + method private visit_Cexpr_record : + 'a -> Core.field_def list -> Stype.t -> location -> expr = + fun env -> + fun fields -> + fun ty -> + fun loc_ -> + let fields = Lst.map fields (self#visit_field_def env) in + let ty = self#visit_typ env ty in + Cexpr_record { fields; ty; loc_ } + + method private visit_Cexpr_record_update : + 'a -> + Core.expr -> + Core.field_def list -> + int -> + Stype.t -> + location -> + expr = + fun env -> + fun record -> + fun fields -> + fun fields_num -> + fun ty -> + fun loc_ -> + let record = self#visit_expr env record in + let fields = Lst.map fields (self#visit_field_def env) in + let ty = self#visit_typ env ty in + Cexpr_record_update { record; fields; fields_num; ty; loc_ } + + method private visit_Cexpr_field : + 'a -> Core.expr -> accessor -> int -> Stype.t -> location -> expr = + fun env -> + fun record -> + fun accessor -> + fun pos -> + fun ty -> + fun loc_ -> + let record = self#visit_expr env record in + match accessor with + | Newtype -> record + | Index _ | Label _ -> + let ty = self#visit_typ env ty in + Cexpr_field { record; accessor; pos; ty; loc_ } + + method private visit_Cexpr_mutate : + 'a -> + Core.expr -> + label -> + Core.expr -> + int -> + Stype.t -> + location -> + expr = + fun env -> + fun record -> + fun label -> + fun field -> + fun pos -> + fun ty -> + fun loc_ -> + let record = self#visit_expr env record in + let field = self#visit_expr env field in + let ty = self#visit_typ env ty in + Cexpr_mutate { record; label; field; pos; ty; loc_ } + + method private visit_Cexpr_array : + 'a -> Core.expr list -> Stype.t -> location -> expr = + fun env -> + fun exprs -> + fun ty -> + fun loc_ -> + let exprs = Lst.map exprs (self#visit_expr env) in + let ty = self#visit_typ env ty in + Cexpr_array { exprs; ty; loc_ } + + method private visit_Cexpr_assign : + 'a -> var -> Core.expr -> Stype.t -> location -> expr = + fun env -> + fun var -> + fun expr -> + fun ty -> + fun loc_ -> + let var = self#visit_var env var in + let expr = self#visit_expr env expr in + let ty = self#visit_typ env ty in + Cexpr_assign { var; expr; ty; loc_ } + + method private visit_Cexpr_sequence : + 'a -> Core.expr list -> Core.expr -> Stype.t -> location -> expr = + fun env -> + fun exprs -> + fun last_expr -> + fun ty -> + fun loc_ -> + let exprs = Lst.map exprs (self#visit_expr env) in + let last_expr = self#visit_expr env last_expr in + let ty = self#visit_typ env ty in + Cexpr_sequence { exprs; last_expr; ty; loc_ } + + method private visit_Cexpr_if : + 'a -> + Core.expr -> + Core.expr -> + Core.expr option -> + Stype.t -> + location -> + expr = + fun env -> + fun cond -> + fun ifso -> + fun ifnot -> + fun _ty -> + fun loc_ -> + let cond = self#visit_expr env cond in + let ifso = self#visit_expr env ifso in + let ifnot = Option.map (self#visit_expr env) ifnot in + if_ ~loc:loc_ cond ~ifso ?ifnot + + method private visit_Cexpr_switch_constr : + 'a -> + Core.expr -> + (Constr_info.constr_tag * var option * Core.expr) list -> + Core.expr option -> + Stype.t -> + location -> + expr = + fun env -> + fun obj -> + fun cases -> + fun default -> + fun _ty -> + fun loc_ -> + let obj = self#visit_expr env obj in + let cases = + Lst.map cases (fun (tag, binder, expr) -> + let binder = Option.map (self#visit_binder env) binder in + let expr = self#visit_expr env expr in + let tag = self#visit_tag env tag in + (tag, binder, expr)) + in + let default = Option.map (self#visit_expr env) default in + switch_constr ~loc:loc_ obj cases ~default + + method private visit_Cexpr_switch_constant : + 'a -> + Core.expr -> + (constant * Core.expr) list -> + Core.expr -> + Stype.t -> + location -> + expr = + fun env -> + fun obj -> + fun cases -> + fun default -> + fun _ty -> + fun loc_ -> + let obj = self#visit_expr env obj in + let cases = + Lst.map cases (fun (c, expr) -> + let expr = self#visit_expr env expr in + (c, expr)) + in + let default = self#visit_expr env default in + switch_constant ~loc:loc_ obj cases ~default + + method private visit_Cexpr_loop : + 'a -> + Core.param list -> + Core.expr -> + Core.expr list -> + loop_label -> + Stype.t -> + location -> + expr = + fun env -> + fun params -> + fun body -> + fun args -> + fun label -> + fun ty -> + fun loc_ -> + let params = Lst.map params (self#visit_param env) in + let body = self#visit_expr env body in + let args = Lst.map args (self#visit_expr env) in + let ty = self#visit_typ env ty in + let label = self#visit_loop_label env label in + Cexpr_loop { params; body; args; label; ty; loc_ } method private visit_handle_kind : 'a -> Core.handle_kind -> handle_kind = - fun env e -> - match e with - | To_result -> To_result - | Joinapply j -> Joinapply (self#visit_var env j) - | Return_err { ok_ty } -> - Return_err { ok_ty = self#visit_typ env ok_ty } - - method private visit_Cexpr_handle_error - : 'a -> Core.expr -> Core.handle_kind -> Stype.t -> location -> expr - = - fun env obj handle_kind ty loc_ -> - let obj = self#visit_expr env obj in - let ty = self#visit_typ env ty in - let handle_kind = self#visit_handle_kind env handle_kind in - Cexpr_handle_error { obj; handle_kind; ty; loc_ } + fun env -> + fun e -> + match e with + | To_result -> To_result + | Joinapply j -> Joinapply (self#visit_var env j) + | Return_err { ok_ty } -> + Return_err { ok_ty = self#visit_typ env ok_ty } + + method private visit_Cexpr_handle_error : + 'a -> Core.expr -> Core.handle_kind -> Stype.t -> location -> expr = + fun env -> + fun obj -> + fun handle_kind -> + fun ty -> + fun loc_ -> + let obj = self#visit_expr env obj in + let ty = self#visit_typ env ty in + let handle_kind = self#visit_handle_kind env handle_kind in + Cexpr_handle_error { obj; handle_kind; ty; loc_ } method private visit_return_kind : 'a -> Core.return_kind -> return_kind = - fun env e -> - match e with - | Single_value -> Single_value - | Error_result { is_error; return_ty } -> - Error_result - { is_error; return_ty = self#visit_typ env return_ty } - - method private visit_Cexpr_return - : 'a -> Core.expr -> Core.return_kind -> Stype.t -> location -> expr - = - fun env expr return_kind ty loc_ -> - let expr = self#visit_expr env expr in - let ty = self#visit_typ env ty in - let return_kind = self#visit_return_kind env return_kind in - Cexpr_return { expr; return_kind; ty; loc_ } + fun env -> + fun e -> + match e with + | Single_value -> Single_value + | Error_result { is_error; return_ty } -> + Error_result + { is_error; return_ty = self#visit_typ env return_ty } + + method private visit_Cexpr_return : + 'a -> Core.expr -> Core.return_kind -> Stype.t -> location -> expr = + fun env -> + fun expr -> + fun return_kind -> + fun ty -> + fun loc_ -> + let expr = self#visit_expr env expr in + let ty = self#visit_typ env ty in + let return_kind = self#visit_return_kind env return_kind in + Cexpr_return { expr; return_kind; ty; loc_ } method visit_expr : 'a -> Core.expr -> expr = - fun env (expr : Core.expr) -> - match expr with - | Cexpr_const { c; ty; loc_ } -> - self#visit_Cexpr_const env c ty loc_ - | Cexpr_unit { loc_ } -> Cexpr_unit { loc_ } - | Cexpr_var { id; ty; prim; ty_args_; loc_ } -> - self#visit_Cexpr_var env id ty ty_args_ prim loc_ - | Cexpr_as { expr; trait; obj_type; loc_ } -> - self#visit_Cexpr_as env expr trait obj_type loc_ - | Cexpr_prim { prim; args; ty; loc_ } -> - self#visit_Cexpr_prim env prim args ty loc_ - | Cexpr_let { name; rhs; body; ty; loc_ } -> - self#visit_Cexpr_let env name rhs body ty loc_ - | Cexpr_letfn { name; fn; body; ty; kind; loc_ } -> - self#visit_Cexpr_letfn env name fn body ty kind loc_ - | Cexpr_function { func; ty; loc_ } -> - self#visit_Cexpr_function env func ty loc_ - | Cexpr_apply { func; args; kind; ty; ty_args_; prim; loc_ } -> - self#visit_Cexpr_apply env func args kind ty ty_args_ prim loc_ - | Cexpr_letrec { bindings; body; ty; loc_ } -> - self#visit_Cexpr_letrec env bindings body ty loc_ - | Cexpr_constr { constr; tag; args; ty; loc_ } -> - self#visit_Cexpr_constr env constr tag args ty loc_ - | Cexpr_tuple { exprs; ty; loc_ } -> - self#visit_Cexpr_tuple env exprs ty loc_ - | Cexpr_record { fields; ty; loc_ } -> - self#visit_Cexpr_record env fields ty loc_ - | Cexpr_record_update { record; fields; fields_num; ty; loc_ } -> - self#visit_Cexpr_record_update env record fields fields_num ty - loc_ - | Cexpr_field { record; accessor; pos; ty; loc_ } -> - self#visit_Cexpr_field env record accessor pos ty loc_ - | Cexpr_mutate { record; label; field; pos; ty; loc_ } -> - self#visit_Cexpr_mutate env record label field pos ty loc_ - | Cexpr_array { exprs; ty; loc_ } -> - self#visit_Cexpr_array env exprs ty loc_ - | Cexpr_assign { var; expr; ty; loc_ } -> - self#visit_Cexpr_assign env var expr ty loc_ - | Cexpr_sequence { expr1; expr2; ty; loc_ } -> - self#visit_Cexpr_sequence env expr1 expr2 ty loc_ - | Cexpr_if { cond; ifso; ifnot; ty; loc_ } -> - self#visit_Cexpr_if env cond ifso ifnot ty loc_ - | Cexpr_switch_constr { obj; cases; default; ty; loc_ } -> - self#visit_Cexpr_switch_constr env obj cases default ty loc_ - | Cexpr_switch_constant { obj; cases; default; ty; loc_ } -> - self#visit_Cexpr_switch_constant env obj cases default ty loc_ - | Cexpr_loop { params; body; args; label; ty; loc_ } -> - self#visit_Cexpr_loop env params body args label ty loc_ - | Cexpr_break { arg; label; ty; loc_ } -> - let ty = self#visit_typ env ty in - let label = self#visit_loop_label env label in - let arg = Option.map (self#visit_expr env) arg in - Cexpr_break { arg; label; ty; loc_ } - | Cexpr_continue { args; label; ty; loc_ } -> - let ty = self#visit_typ env ty in - let label = self#visit_loop_label env label in - let args = Lst.map args (self#visit_expr env) in - Cexpr_continue { args; label; ty; loc_ } - | Cexpr_handle_error { obj; handle_kind; ty; loc_ } -> - self#visit_Cexpr_handle_error env obj handle_kind ty loc_ - | Cexpr_return { expr; return_kind; ty; loc_ } -> - self#visit_Cexpr_return env expr return_kind ty loc_ + fun env -> + fun (expr : Core.expr) -> + match expr with + | Cexpr_const { c; ty; loc_ } -> + self#visit_Cexpr_const env c ty loc_ + | Cexpr_unit { loc_ } -> Cexpr_unit { loc_ } + | Cexpr_var { id; ty; prim; ty_args_; loc_ } -> + self#visit_Cexpr_var env id ty ty_args_ prim loc_ + | Cexpr_as { expr; trait; obj_type; loc_ } -> + self#visit_Cexpr_as env expr trait obj_type loc_ + | Cexpr_prim { prim; args; ty; loc_ } -> + self#visit_Cexpr_prim env prim args ty loc_ + | Cexpr_let { name; rhs; body; ty; loc_ } -> + self#visit_Cexpr_let env name rhs body ty loc_ + | Cexpr_letfn { name; fn; body; ty; kind; loc_ } -> + self#visit_Cexpr_letfn env name fn body ty kind loc_ + | Cexpr_function { func; ty; is_raw_; loc_ } -> + self#visit_Cexpr_function env func ty is_raw_ loc_ + | Cexpr_apply { func; args; kind; ty; ty_args_; prim; loc_ } -> + self#visit_Cexpr_apply env func args kind ty ty_args_ prim loc_ + | Cexpr_letrec { bindings; body; ty; loc_ } -> + self#visit_Cexpr_letrec env bindings body ty loc_ + | Cexpr_constr { tag; args; ty; loc_ } -> + self#visit_Cexpr_constr env tag args ty loc_ + | Cexpr_tuple { exprs; ty; loc_ } -> + self#visit_Cexpr_tuple env exprs ty loc_ + | Cexpr_record { fields; ty; loc_ } -> + self#visit_Cexpr_record env fields ty loc_ + | Cexpr_record_update { record; fields; fields_num; ty; loc_ } -> + self#visit_Cexpr_record_update env record fields fields_num ty + loc_ + | Cexpr_field { record; accessor; pos; ty; loc_ } -> + self#visit_Cexpr_field env record accessor pos ty loc_ + | Cexpr_mutate { record; label; field; pos; ty; loc_ } -> + self#visit_Cexpr_mutate env record label field pos ty loc_ + | Cexpr_array { exprs; ty; loc_ } -> + self#visit_Cexpr_array env exprs ty loc_ + | Cexpr_assign { var; expr; ty; loc_ } -> + self#visit_Cexpr_assign env var expr ty loc_ + | Cexpr_sequence { exprs; last_expr; ty; loc_ } -> + self#visit_Cexpr_sequence env exprs last_expr ty loc_ + | Cexpr_if { cond; ifso; ifnot; ty; loc_ } -> + self#visit_Cexpr_if env cond ifso ifnot ty loc_ + | Cexpr_switch_constr { obj; cases; default; ty; loc_ } -> + self#visit_Cexpr_switch_constr env obj cases default ty loc_ + | Cexpr_switch_constant { obj; cases; default; ty; loc_ } -> + self#visit_Cexpr_switch_constant env obj cases default ty loc_ + | Cexpr_loop { params; body; args; label; ty; loc_ } -> + self#visit_Cexpr_loop env params body args label ty loc_ + | Cexpr_break { arg; label; ty; loc_ } -> + let ty = self#visit_typ env ty in + let label = self#visit_loop_label env label in + let arg = Option.map (self#visit_expr env) arg in + Cexpr_break { arg; label; ty; loc_ } + | Cexpr_continue { args; label; ty; loc_ } -> + let ty = self#visit_typ env ty in + let label = self#visit_loop_label env label in + let args = Lst.map args (self#visit_expr env) in + Cexpr_continue { args; label; ty; loc_ } + | Cexpr_handle_error { obj; handle_kind; ty; loc_ } -> + self#visit_Cexpr_handle_error env obj handle_kind ty loc_ + | Cexpr_return { expr; return_kind; ty; loc_ } -> + self#visit_Cexpr_return env expr return_kind ty loc_ + | Cexpr_and { lhs; rhs; loc_ } -> + let lhs = self#visit_expr env lhs in + let rhs = self#visit_expr env rhs in + Cexpr_and { lhs; rhs; loc_ } + | Cexpr_or { lhs; rhs; loc_ } -> + let lhs = self#visit_expr env lhs in + let rhs = self#visit_expr env rhs in + Cexpr_or { lhs; rhs; loc_ } method private visit_fn : 'a -> Core.fn -> fn = - fun env { params; body } -> - let params = Lst.map params (self#visit_param env) in - let body = self#visit_expr env body in - { params; body } + fun env -> + fun { params; body; is_async = _ } -> + let params = Lst.map params (self#visit_param env) in + let body = self#visit_expr env body in + { params; body } method private visit_param : 'a -> Core.param -> param = - fun env { binder; ty; loc_ } -> - let binder = self#visit_binder env binder in - let ty = self#visit_typ env ty in - { binder; ty; loc_ } + fun env -> + fun { binder; ty; loc_ } -> + let binder = self#visit_binder env binder in + let ty = self#visit_typ env ty in + { binder; ty; loc_ } method visit_apply_kind : 'a -> Core.apply_kind -> apply_kind = - fun env (_visitors_this : Core.apply_kind) -> - match _visitors_this with - | Normal { func_ty } -> - Normal { func_ty = self#visit_typ env func_ty } - | Join -> Join + fun env -> + fun (_visitors_this : Core.apply_kind) -> + match _visitors_this with + | Normal { func_ty } -> + Normal { func_ty = self#visit_typ env func_ty } + | Join -> Join + | Async _ -> assert false method private visit_field_def : 'a -> Core.field_def -> field_def = - fun env { label; pos; is_mut; expr } -> - let expr = self#visit_expr env expr in - { label; pos; is_mut; expr } + fun env -> + fun { label; pos; is_mut; expr } -> + let expr = self#visit_expr env expr in + { label; pos; is_mut; expr } end end end @@ -3946,37 +4715,78 @@ type t = { object_methods : Object_util.t; } -let sexp_of_expr e = sexp_visitor#visit_expr Use_relative_loc e - -let sexp_of_t prog : S.t = - let global_stamps = Hashtbl.create 20 in - let body = - S.List - (List.map (fun top_item -> - sexp_visitor#visit_top_item Use_relative_loc top_item - |> Basic_compress_stamp.normalize ~global_stamps) - prog.body) - in - let types = Mtype.sexp_of_defs prog.types in - let object_methods = Object_util.sexp_of_t prog.object_methods in - match prog.main with - | Some expr -> - let main = - (if !Basic_config.show_loc then - let (expr, loc) = expr in - List [ sexp_of_expr expr; sexp_of_absolute_loc loc ] - else sexp_of_expr (fst expr)) - |> Basic_compress_stamp.normalize ~global_stamps - in - S.List [ - S.List [ S.Atom "body"; body ]; - S.List [ S.Atom "main"; main ]; - S.List [ S.Atom "types"; types ]; - S.List ([ S.Atom "object_methods"; object_methods ]); - ] - | None -> - S.List [ - S.List [ S.Atom "body"; body ]; - S.List [ S.Atom "types"; types ]; - S.List ([ S.Atom "object_methods"; object_methods ]); - ] +let sexp_of_t ?(use_absolute_loc = false) prog = + (let global_stamps = Hashtbl.create 20 in + let body = + S.List + (Lst.map prog.body (fun top_item -> + let ctx = + if use_absolute_loc then + let base = + match top_item with + | Ctop_expr { loc_; _ } + | Ctop_let { loc_; _ } + | Ctop_fn { loc_; _ } + | Ctop_stub { loc_; _ } -> + loc_ + in + Use_absolute_loc base + else Use_relative_loc + in + Basic_compress_stamp.normalize ~global_stamps + (sexp_visitor#visit_top_item ctx top_item))) + in + let types = Mtype.sexp_of_defs prog.types in + let object_methods = Object_util.sexp_of_t prog.object_methods in + match prog.main with + | Some expr -> + let sexp_of_expr e = + if use_absolute_loc then + sexp_visitor#visit_expr (Use_absolute_loc (snd expr)) e + else sexp_visitor#visit_expr Use_relative_loc e + in + let main = + if !Basic_config.show_loc then + Basic_compress_stamp.normalize ~global_stamps + ((fun [@merlin.hide] (arg0__006_, arg1__007_) -> + let res0__008_ = sexp_of_expr arg0__006_ + and res1__009_ = sexp_of_absolute_loc arg1__007_ in + S.List [ res0__008_; res1__009_ ]) + expr) + else + Basic_compress_stamp.normalize ~global_stamps + ((sexp_of_expr [@merlin.hide]) (fst expr)) + in + (List + (List.cons + (List (List.cons (Atom "body" : S.t) ([ body ] : S.t list)) : S.t) + (List.cons + (List (List.cons (Atom "main" : S.t) ([ main ] : S.t list)) + : S.t) + (List.cons + (List (List.cons (Atom "types" : S.t) ([ types ] : S.t list)) + : S.t) + ([ + List + (List.cons + (Atom "object_methods" : S.t) + ([ object_methods ] : S.t list)); + ] + : S.t list)))) + : S.t) + | None -> + (List + (List.cons + (List (List.cons (Atom "body" : S.t) ([ body ] : S.t list)) : S.t) + (List.cons + (List (List.cons (Atom "types" : S.t) ([ types ] : S.t list)) + : S.t) + ([ + List + (List.cons + (Atom "object_methods" : S.t) + ([ object_methods ] : S.t list)); + ] + : S.t list))) + : S.t) + : S.t) diff --git a/src/mcore_util.ml b/src/mcore_util.ml index b9cf4c4..31720bb 100644 --- a/src/mcore_util.ml +++ b/src/mcore_util.ml @@ -15,113 +15,129 @@ module Ident = Basic_core_ident module Ident_set = Ident.Set +module Lst = Basic_lst -let free_vars ~(exclude : Ident.Set.t) (fn : Mcore.fn) : Mtype.t Ident.Map.t = - let go_ident ~env ~acc (id : Ident.t) ty = - match id with - | Pident _ | Pmutable_ident _ -> - if Ident_set.mem env id then acc else Ident.Map.add acc id ty - | Pdot _ | Plocal_method _ -> acc - in - let rec go_func ~env ~acc (func : Mcore.fn) = - let new_env = - List.fold_left (fun env (p: Mcore.param) -> Ident_set.add env p.binder) env func.params - in - go ~env:new_env ~acc func.body - and go ~env ~acc (expr : Mcore.expr) = - match expr with - | Cexpr_const _ -> acc - | Cexpr_unit _ -> acc - | Cexpr_var { id; ty; prim = _ } -> go_ident ~env ~acc id ty - | Cexpr_prim { prim = _; args; ty = _ } -> - List.fold_left (fun acc arg -> go ~env ~acc arg) acc args - | Cexpr_let { name; rhs; body; ty = _ } -> - let new_env = Ident_set.add env name in - let new_acc = go ~env ~acc rhs in - go ~env:new_env ~acc:new_acc body - | Cexpr_letfn { name; fn; body; ty = _; kind = _ } -> - let new_env = Ident_set.add env name in - let new_acc = go_func ~env:new_env ~acc fn in - go ~env:new_env ~acc:new_acc body - | Cexpr_function { func; ty = _ } -> go_func ~env ~acc func - | Cexpr_apply { func; args; kind; ty = _; prim = _ } -> - let new_acc = - match kind with - | Normal { func_ty } -> go_ident ~env ~acc func func_ty - | Join -> acc - in - List.fold_left (fun acc arg -> go ~env ~acc arg) new_acc args - | Cexpr_object { self; methods_key = _; ty = _ } -> go ~env ~acc self - | Cexpr_letrec { bindings; body; ty = _ } -> - let new_env = - List.fold_left (fun env (binder, _) -> Ident_set.add env binder) env bindings - in - let new_acc = - List.fold_left (fun acc (_, fn) -> go_func ~env:new_env ~acc fn) acc bindings - in - go ~env:new_env ~acc:new_acc body - | Cexpr_constr { constr = _; tag = _; args; ty = _ } -> - List.fold_left (fun acc arg -> go ~env ~acc arg) acc args - | Cexpr_tuple { exprs; ty = _ } -> - List.fold_left (fun acc expr -> go ~env ~acc expr) acc exprs - | Cexpr_record { fields; ty = _ } -> - List.fold_left (fun acc (field: Mcore.field_def) -> go ~env ~acc field.expr) acc fields - | Cexpr_record_update { record; fields; fields_num = _; ty = _ } -> - let new_acc = go ~env ~acc record in - List.fold_left (fun acc (field: Mcore.field_def) -> go ~env ~acc field.expr) new_acc fields - | Cexpr_field { record; accessor = _; pos = _; ty = _ } -> - go ~env ~acc record - | Cexpr_mutate { record; label = _; field; pos = _; ty = _ } -> - let new_acc = go ~env ~acc record in - go ~env ~acc:new_acc field - | Cexpr_array { exprs; ty = _ } -> - List.fold_left (fun acc expr -> go ~env ~acc expr) acc exprs - | Cexpr_assign { var; expr; ty = _ } -> - let new_acc = go_ident ~env ~acc var (Mcore.type_of_expr expr) in - go ~env ~acc:new_acc expr - | Cexpr_sequence { expr1; expr2; ty = _ } -> - let new_acc = go ~env ~acc expr1 in - go ~env ~acc:new_acc expr2 - | Cexpr_if { cond; ifso; ifnot; ty = _ } -> ( - let acc1 = go ~env ~acc cond in - let acc2 = go ~env ~acc:acc1 ifso in - match ifnot with Some ifnot -> go ~env ~acc:acc2 ifnot | None -> acc2) - | Cexpr_switch_constr { obj; cases; default; ty = _ } -> ( - let acc1 = go ~env ~acc obj in - let acc2 = - List.fold_left (fun acc (_tag, binder, case) -> - let new_env = - match binder with - | None -> env - | Some binder -> Ident_set.add env binder - in - go ~env:new_env ~acc case) acc1 cases - in - match default with - | Some default -> go ~env ~acc:acc2 default - | None -> acc2) - | Cexpr_switch_constant { obj; cases; default; ty = _ } -> - let acc1 = go ~env ~acc obj in - let acc2 = - List.fold_left (fun acc (_const, case) -> go ~env ~acc case) acc1 cases - in - go ~env ~acc:acc2 default - | Cexpr_loop { params; body; args; label = _; ty = _ } -> - let new_env = - List.fold_left (fun env (p: Mcore.param) -> Ident_set.add env p.binder) env params - in - let new_acc = - List.fold_left (fun acc arg -> go ~env ~acc arg) acc args - in - go ~env:new_env ~acc:new_acc body - | Cexpr_break { arg; label = _; ty = _ } -> ( - match arg with Some arg -> go ~env ~acc arg | None -> acc) - | Cexpr_continue { args; label = _; ty = _ } -> - List.fold_left (fun acc arg -> go ~env ~acc arg) acc args - | Cexpr_return { expr; _ } -> go ~env ~acc expr - | Cexpr_handle_error { obj; _ } -> go ~env ~acc obj - in - let init_env = - List.fold_left (fun env (p: Mcore.param) -> Ident_set.add env p.binder) exclude fn.params - in - go ~env:init_env ~acc:Ident.Map.empty fn.body +let free_vars ~(exclude : Ident.Set.t) (fn : Mcore.fn) = + (let go_ident ~env ~acc (id : Ident.t) ty = + match id with + | Pident _ | Pmutable_ident _ -> + if Ident_set.mem env id then acc else Ident.Map.add acc id ty + | Pdot _ | Plocal_method _ -> acc + in + let rec go_func ~env ~acc (func : Mcore.fn) = + let new_env = + Lst.fold_left func.params env (fun env -> + fun p -> Ident_set.add env p.binder) + in + go ~env:new_env ~acc func.body + and go ~env ~acc (expr : Mcore.expr) = + match expr with + | Cexpr_const _ -> acc + | Cexpr_unit _ -> acc + | Cexpr_var { id; ty; prim = _ } -> go_ident ~env ~acc id ty + | Cexpr_prim { prim = _; args; ty = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_and { lhs; rhs } | Cexpr_or { lhs; rhs } -> + let acc1 = go ~env ~acc lhs in + go ~env ~acc:acc1 rhs + | Cexpr_let { name; rhs; body; ty = _ } -> + let new_env = Ident_set.add env name in + let new_acc = go ~env ~acc rhs in + go ~env:new_env ~acc:new_acc body + | Cexpr_letfn { name; fn; body; ty = _; kind = _ } -> + let new_env = Ident_set.add env name in + let new_acc = go_func ~env:new_env ~acc fn in + go ~env:new_env ~acc:new_acc body + | Cexpr_function { func; ty = _ } -> go_func ~env ~acc func + | Cexpr_apply { func; args; kind; ty = _; prim = _ } -> + let new_acc = + match kind with + | Normal { func_ty } -> go_ident ~env ~acc func func_ty + | Join -> acc + in + Lst.fold_left args new_acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_object { self; methods_key = _; ty = _ } -> go ~env ~acc self + | Cexpr_letrec { bindings; body; ty = _ } -> + let new_env = + Lst.fold_left bindings env (fun env -> + fun (binder, _) -> Ident_set.add env binder) + in + let new_acc = + Lst.fold_left bindings acc (fun acc -> + fun (_, fn) -> go_func ~env:new_env ~acc fn) + in + go ~env:new_env ~acc:new_acc body + | Cexpr_constr { tag = _; args; ty = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_tuple { exprs; ty = _ } -> + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + | Cexpr_record { fields; ty = _ } -> + Lst.fold_left fields acc (fun acc -> + fun field -> go ~env ~acc field.expr) + | Cexpr_record_update { record; fields; fields_num = _; ty = _ } -> + let new_acc = go ~env ~acc record in + Lst.fold_left fields new_acc (fun acc -> + fun field -> go ~env ~acc field.expr) + | Cexpr_field { record; accessor = _; pos = _; ty = _ } -> + go ~env ~acc record + | Cexpr_mutate { record; label = _; field; pos = _; ty = _ } -> + let new_acc = go ~env ~acc record in + go ~env ~acc:new_acc field + | Cexpr_array { exprs; ty = _ } -> + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + | Cexpr_assign { var; expr; ty = _ } -> + let new_acc = go_ident ~env ~acc var (Mcore.type_of_expr expr) in + go ~env ~acc:new_acc expr + | Cexpr_sequence { exprs; last_expr; ty = _ } -> + let new_acc = + Lst.fold_left exprs acc (fun acc -> fun expr -> go ~env ~acc expr) + in + go ~env ~acc:new_acc last_expr + | Cexpr_if { cond; ifso; ifnot; ty = _ } -> ( + let acc1 = go ~env ~acc cond in + let acc2 = go ~env ~acc:acc1 ifso in + match ifnot with Some ifnot -> go ~env ~acc:acc2 ifnot | None -> acc2) + | Cexpr_switch_constr { obj; cases; default; ty = _ } -> ( + let acc1 = go ~env ~acc obj in + let acc2 = + Lst.fold_left cases acc1 (fun acc -> + fun (_tag, binder, case) -> + let new_env = + match binder with + | None -> env + | Some binder -> Ident_set.add env binder + in + go ~env:new_env ~acc case) + in + match default with + | Some default -> go ~env ~acc:acc2 default + | None -> acc2) + | Cexpr_switch_constant { obj; cases; default; ty = _ } -> + let acc1 = go ~env ~acc obj in + let acc2 = + Lst.fold_left cases acc1 (fun acc -> + fun (_const, case) -> go ~env ~acc case) + in + go ~env ~acc:acc2 default + | Cexpr_loop { params; body; args; label = _; ty = _ } -> + let new_env = + Lst.fold_left params env (fun env -> + fun p -> Ident_set.add env p.binder) + in + let new_acc = + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + in + go ~env:new_env ~acc:new_acc body + | Cexpr_break { arg; label = _; ty = _ } -> ( + match arg with Some arg -> go ~env ~acc arg | None -> acc) + | Cexpr_continue { args; label = _; ty = _ } -> + Lst.fold_left args acc (fun acc -> fun arg -> go ~env ~acc arg) + | Cexpr_return { expr; _ } -> go ~env ~acc expr + | Cexpr_handle_error { obj; _ } -> go ~env ~acc obj + in + let init_env = + Lst.fold_left fn.params exclude (fun env -> + fun p -> Ident_set.add env p.binder) + in + go ~env:init_env ~acc:Ident.Map.empty fn.body + : Mtype.t Ident.Map.t) diff --git a/src/method_env.ml b/src/method_env.ml index 0bb048f..c0765a4 100644 --- a/src/method_env.ml +++ b/src/method_env.ml @@ -66,6 +66,31 @@ include struct let _ = sexp_of_docstring end +type method_kind = + | Regular_method + | Regular_method_qualified + | Method_explicit_self of { self_ty : Stype.t } + +include struct + let _ = fun (_ : method_kind) -> () + + let sexp_of_method_kind = + (function + | Regular_method -> S.Atom "Regular_method" + | Regular_method_qualified -> S.Atom "Regular_method_qualified" + | Method_explicit_self { self_ty = self_ty__004_ } -> + let bnds__003_ = ([] : _ Stdlib.List.t) in + let bnds__003_ = + let arg__005_ = Stype.sexp_of_t self_ty__004_ in + (S.List [ S.Atom "self_ty"; arg__005_ ] :: bnds__003_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Method_explicit_self" :: bnds__003_) + : method_kind -> S.t) + + let _ = sexp_of_method_kind +end + type method_info = { id : Basic_qual_ident.t; prim : Primitive.prim option; @@ -73,7 +98,13 @@ type method_info = { pub : bool; loc : Loc.t; doc_ : docstring; [@sexp_drop_if Docstring.is_empty] + attrs : Checked_attributes.t; ty_params_ : Tvar_env.t; [@sexp_drop_if Tvar_env.is_empty] + kind_ : method_kind; + [@sexp_drop_if + function + | Regular_method | Regular_method_qualified -> true + | Method_explicit_self _ -> false] arity_ : Fn_arity.t; [@sexp_drop_if Fn_arity.is_simple] param_names_ : string list; } @@ -82,175 +113,197 @@ include struct let _ = fun (_ : method_info) -> () let sexp_of_method_info = - (let (drop_if__015_ : docstring -> Stdlib.Bool.t) = Docstring.is_empty - and (drop_if__020_ : Tvar_env.t -> Stdlib.Bool.t) = Tvar_env.is_empty - and (drop_if__025_ : Fn_arity.t -> Stdlib.Bool.t) = Fn_arity.is_simple in + (let (drop_if__018_ : docstring -> Stdlib.Bool.t) = Docstring.is_empty + and (drop_if__025_ : Tvar_env.t -> Stdlib.Bool.t) = Tvar_env.is_empty + and (drop_if__030_ : method_kind -> Stdlib.Bool.t) = function + | Regular_method | Regular_method_qualified -> true + | Method_explicit_self _ -> false + and (drop_if__035_ : Fn_arity.t -> Stdlib.Bool.t) = Fn_arity.is_simple in fun { - id = id__004_; - prim = prim__006_; - typ = typ__008_; - pub = pub__010_; - loc = loc__012_; - doc_ = doc___016_; - ty_params_ = ty_params___021_; - arity_ = arity___026_; - param_names_ = param_names___029_; + id = id__007_; + prim = prim__009_; + typ = typ__011_; + pub = pub__013_; + loc = loc__015_; + doc_ = doc___019_; + attrs = attrs__022_; + ty_params_ = ty_params___026_; + kind_ = kind___031_; + arity_ = arity___036_; + param_names_ = param_names___039_; } -> - let bnds__003_ = ([] : _ Stdlib.List.t) in - let bnds__003_ = - let arg__030_ = + let bnds__006_ = ([] : _ Stdlib.List.t) in + let bnds__006_ = + let arg__040_ = Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string - param_names___029_ + param_names___039_ in - (S.List [ S.Atom "param_names_"; arg__030_ ] :: bnds__003_ + (S.List [ S.Atom "param_names_"; arg__040_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - if drop_if__025_ arity___026_ then bnds__003_ + let bnds__006_ = + if drop_if__035_ arity___036_ then bnds__006_ + else + let arg__038_ = Fn_arity.sexp_of_t arity___036_ in + let bnd__037_ = S.List [ S.Atom "arity_"; arg__038_ ] in + (bnd__037_ :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + if drop_if__030_ kind___031_ then bnds__006_ else - let arg__028_ = Fn_arity.sexp_of_t arity___026_ in - let bnd__027_ = S.List [ S.Atom "arity_"; arg__028_ ] in - (bnd__027_ :: bnds__003_ : _ Stdlib.List.t) + let arg__033_ = sexp_of_method_kind kind___031_ in + let bnd__032_ = S.List [ S.Atom "kind_"; arg__033_ ] in + (bnd__032_ :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - if drop_if__020_ ty_params___021_ then bnds__003_ + let bnds__006_ = + if drop_if__025_ ty_params___026_ then bnds__006_ else - let arg__023_ = Tvar_env.sexp_of_t ty_params___021_ in - let bnd__022_ = S.List [ S.Atom "ty_params_"; arg__023_ ] in - (bnd__022_ :: bnds__003_ : _ Stdlib.List.t) + let arg__028_ = Tvar_env.sexp_of_t ty_params___026_ in + let bnd__027_ = S.List [ S.Atom "ty_params_"; arg__028_ ] in + (bnd__027_ :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__023_ = Checked_attributes.sexp_of_t attrs__022_ in + (S.List [ S.Atom "attrs"; arg__023_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - if drop_if__015_ doc___016_ then bnds__003_ + let bnds__006_ = + if drop_if__018_ doc___019_ then bnds__006_ else - let arg__018_ = sexp_of_docstring doc___016_ in - let bnd__017_ = S.List [ S.Atom "doc_"; arg__018_ ] in - (bnd__017_ :: bnds__003_ : _ Stdlib.List.t) + let arg__021_ = sexp_of_docstring doc___019_ in + let bnd__020_ = S.List [ S.Atom "doc_"; arg__021_ ] in + (bnd__020_ :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - let arg__013_ = Loc.sexp_of_t loc__012_ in - (S.List [ S.Atom "loc"; arg__013_ ] :: bnds__003_ : _ Stdlib.List.t) + let bnds__006_ = + let arg__016_ = Loc.sexp_of_t loc__015_ in + (S.List [ S.Atom "loc"; arg__016_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - let arg__011_ = Moon_sexp_conv.sexp_of_bool pub__010_ in - (S.List [ S.Atom "pub"; arg__011_ ] :: bnds__003_ : _ Stdlib.List.t) + let bnds__006_ = + let arg__014_ = Moon_sexp_conv.sexp_of_bool pub__013_ in + (S.List [ S.Atom "pub"; arg__014_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - let arg__009_ = Stype.sexp_of_t typ__008_ in - (S.List [ S.Atom "typ"; arg__009_ ] :: bnds__003_ : _ Stdlib.List.t) + let bnds__006_ = + let arg__012_ = Stype.sexp_of_t typ__011_ in + (S.List [ S.Atom "typ"; arg__012_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - let arg__007_ = - Moon_sexp_conv.sexp_of_option Primitive.sexp_of_prim prim__006_ + let bnds__006_ = + let arg__010_ = + Moon_sexp_conv.sexp_of_option Primitive.sexp_of_prim prim__009_ in - (S.List [ S.Atom "prim"; arg__007_ ] :: bnds__003_ : _ Stdlib.List.t) + (S.List [ S.Atom "prim"; arg__010_ ] :: bnds__006_ : _ Stdlib.List.t) in - let bnds__003_ = - let arg__005_ = Basic_qual_ident.sexp_of_t id__004_ in - (S.List [ S.Atom "id"; arg__005_ ] :: bnds__003_ : _ Stdlib.List.t) + let bnds__006_ = + let arg__008_ = Basic_qual_ident.sexp_of_t id__007_ in + (S.List [ S.Atom "id"; arg__008_ ] :: bnds__006_ : _ Stdlib.List.t) in - S.List bnds__003_ + S.List bnds__006_ : method_info -> S.t) let _ = sexp_of_method_info end -type method_table_entry = Regular of method_info | Impl of method_info list +type method_table_entry = + | Has_regular of { regular : method_info; impls : method_info list } + | Only_impl of method_info list let sexp_of_method_table_entry = function - | Regular mi | Impl (mi :: []) -> sexp_of_method_info mi - | Impl mis -> List (Atom "Ambiguous" :: List.map sexp_of_method_info mis) + | Has_regular { regular = mi; impls = _ } | Only_impl (mi :: []) -> + sexp_of_method_info mi + | Only_impl mis -> List (Atom "Ambiguous" :: Lst.map mis sexp_of_method_info) -type t = { - by_type : method_table_entry M.t H.t; - by_name : (type_name * method_info) list M.t; -} +type t = method_table_entry M.t H.t -let sexp_of_t t = H.sexp_of_t (M.sexp_of_t sexp_of_method_table_entry) t.by_type -let empty () : t = { by_type = H.create 17; by_name = M.create 17 } +let sexp_of_t t = H.sexp_of_t (M.sexp_of_t sexp_of_method_table_entry) t +let empty () = (H.create 17 : t) let find_regular_method (env : t) ~(type_name : type_name) - ~(method_name : method_name) : method_info option = - match H.find_opt env.by_type type_name with - | Some method_table -> ( - match M.find_opt method_table method_name with - | Some (Regular mi) -> Some mi - | Some (Impl _) | None -> None) - | None -> None + ~(method_name : method_name) = + (match H.find_opt env type_name with + | Some method_table -> ( + match M.find_opt method_table method_name with + | Some (Has_regular { regular; impls = _ }) -> Some regular + | Some (Only_impl _) | None -> None) + | None -> None + : method_info option) let find_method_opt (env : t) ~(type_name : type_name) - ~(method_name : method_name) : method_table_entry option = - match H.find_opt env.by_type type_name with - | Some method_table -> M.find_opt method_table method_name - | None -> None + ~(method_name : method_name) = + (match H.find_opt env type_name with + | Some method_table -> M.find_opt method_table method_name + | None -> None + : method_table_entry option) let iter_methods_by_type (env : t) ~(type_name : type_name) (f : method_name -> method_info -> unit) = - match H.find_opt env.by_type type_name with + match H.find_opt env type_name with | Some method_table -> - M.iter2 method_table (fun method_name entry -> - match entry with - | Regular mi | Impl (mi :: []) -> f method_name mi - | Impl _ -> ()) + M.iter2 method_table (fun method_name -> + fun entry -> + match entry with + | Has_regular { regular = mi; impls = _ } | Only_impl (mi :: []) -> + f method_name mi + | Only_impl _ -> ()) | None -> () -let find_methods_by_name (env : t) ~method_name : (type_name * method_info) list - = - M.find_default env.by_name method_name [] - let add_method (env : t) ~(type_name : type_name) ~(method_name : method_name) - ~(method_info : method_info) : unit = - (match H.find_opt env.by_type type_name with - | Some method_table -> - M.replace method_table method_name (Regular method_info) - | None -> - let method_table = M.create 17 in - M.add method_table method_name (Regular method_info); - H.add env.by_type type_name method_table); - M.add_or_update env.by_name method_name - [ (type_name, method_info) ] - ~update:(fun methods -> (type_name, method_info) :: methods) - |> ignore + ~(method_info : method_info) = + (match H.find_opt env type_name with + | Some method_table -> + ignore + (M.add_or_update method_table method_name + (Has_regular { regular = method_info; impls = [] }) + ~update:(fun + (Has_regular { regular = _; impls } | Only_impl impls) -> + Has_regular { regular = method_info; impls })) + | None -> + let method_table = M.create 17 in + M.add method_table method_name + (Has_regular { regular = method_info; impls = [] }); + H.add env type_name method_table + : unit) let add_impl (env : t) ~(type_name : type_name) ~(method_name : method_name) - ~(method_info : method_info) : unit = - match H.find_opt env.by_type type_name with - | Some method_table -> - M.add_or_update method_table method_name (Impl [ method_info ]) - ~update:(fun entry -> - match entry with - | Regular _ -> entry - | Impl mis -> Impl (method_info :: mis)) - |> ignore - | None -> - let method_table = M.create 17 in - M.add method_table method_name (Impl [ method_info ]); - H.add env.by_type type_name method_table - -let to_value_info (m : method_info) : Value_info.t = - Toplevel_value - { - id = m.id; - typ = m.typ; - pub = m.pub; - kind = (match m.prim with None -> Normal | Some prim -> Prim prim); - loc_ = m.loc; - doc_ = m.doc_; - ty_params_ = m.ty_params_; - arity_ = Some m.arity_; - param_names_ = m.param_names_; - direct_use_loc_ = Not_direct_use; - } + ~(method_info : method_info) = + (match H.find_opt env type_name with + | Some method_table -> + ignore + (M.add_or_update method_table method_name (Only_impl [ method_info ]) + ~update:(fun entry -> + match entry with + | Has_regular { regular; impls } -> + Has_regular { regular; impls = method_info :: impls } + | Only_impl mis -> Only_impl (method_info :: mis))) + | None -> + let method_table = M.create 17 in + M.add method_table method_name (Only_impl [ method_info ]); + H.add env type_name method_table + : unit) + +let to_value_info (m : method_info) = + (Toplevel_value + { + id = m.id; + typ = m.typ; + pub = m.pub; + kind = (match m.prim with None -> Normal | Some prim -> Prim prim); + loc_ = m.loc; + doc_ = m.doc_; + attrs = m.attrs; + ty_params_ = m.ty_params_; + arity_ = Some m.arity_; + param_names_ = m.param_names_; + direct_use_loc_ = Not_direct_use; + } + : Value_info.t) let iter (env : t) f = - H.iter2 env.by_type (fun type_name tbl -> - M.iter2 tbl (fun method_name entry -> - match entry with - | Regular mi | Impl (mi :: []) -> f type_name method_name mi - | Impl _ -> ())) - -let iter_by_name (env : t) - (f : method_name * (type_name * method_info) list -> unit) = - M.iter env.by_name f + H.iter2 env (fun type_name -> + fun tbl -> + M.iter2 tbl (fun method_name -> + fun entry -> + match entry with + | Has_regular { regular = mi; impls = _ } | Only_impl (mi :: []) -> + f type_name method_name mi + | Only_impl _ -> ())) type method_array = (type_name * (method_name * method_table_entry) array) array @@ -258,84 +311,69 @@ include struct let _ = fun (_ : method_array) -> () let sexp_of_method_array = - (fun x__039_ -> + (fun x__049_ -> Moon_sexp_conv.sexp_of_array - (fun (arg0__035_, arg1__036_) -> - let res0__037_ = sexp_of_type_name arg0__035_ - and res1__038_ = + (fun (arg0__045_, arg1__046_) -> + let res0__047_ = sexp_of_type_name arg0__045_ + and res1__048_ = Moon_sexp_conv.sexp_of_array - (fun (arg0__031_, arg1__032_) -> - let res0__033_ = sexp_of_method_name arg0__031_ - and res1__034_ = sexp_of_method_table_entry arg1__032_ in - S.List [ res0__033_; res1__034_ ]) - arg1__036_ + (fun (arg0__041_, arg1__042_) -> + let res0__043_ = sexp_of_method_name arg0__041_ + and res1__044_ = sexp_of_method_table_entry arg1__042_ in + S.List [ res0__043_; res1__044_ ]) + arg1__046_ in - S.List [ res0__037_; res1__038_ ]) - x__039_ + S.List [ res0__047_; res1__048_ ]) + x__049_ : method_array -> S.t) let _ = sexp_of_method_array end -let export (env : t) ~export_private : method_array = - let result = - Vec.make (H.length env.by_type) - ~dummy:(Type_path.Builtin.type_path_int, [||]) - in - H.iter2 env.by_type (fun self_type methods -> - if - export_private - || (not (Type_path_util.is_foreign self_type)) - || !Basic_config.current_package = Basic_config.builtin_package - then ( - let methods_vec = Vec.make (M.length methods) ~dummy:("", Impl []) in - M.iter2 methods (fun method_name entry -> - match entry with - | Regular method_info -> - if export_private || method_info.pub then - Vec.push methods_vec (method_name, entry) - | Impl mis -> ( - match Lst.filter mis (fun mi -> export_private || mi.pub) with - | [] -> () - | mis -> Vec.push methods_vec (method_name, Impl mis))); - if Vec.length methods_vec > 0 then - Vec.push result (self_type, Vec.to_array methods_vec))); - Vec.to_array result - -let export_regular_methods (env : t) : - (type_name * (method_name * method_info) array) array = - let result = - Vec.make (H.length env.by_type) - ~dummy:(Type_path.Builtin.type_path_int, [||]) - in - H.iter2 env.by_type (fun self_type methods -> - if - (not (Type_path_util.is_foreign self_type)) - || !Basic_config.current_package = Basic_config.builtin_package - then ( - let methods_vec = Vec.empty () in - M.iter2 methods (fun method_name entry -> - match entry with - | Regular method_info -> - Vec.push methods_vec (method_name, method_info) - | Impl _ -> ()); - if Vec.length methods_vec > 0 then - Vec.push result (self_type, Vec.to_array methods_vec))); - Vec.to_array result - -let import (methods_by_type : method_array) : t = - let by_name = M.create 17 in - let by_type = H.create (Array.length methods_by_type * 3 / 2) in - Arr.iter methods_by_type (fun (type_name, methods) -> - let tbl = M.create (Array.length methods * 3 / 2) in - Arr.iter methods (fun (method_name, entry) -> - (match entry with - | Regular method_info -> - M.add_or_update by_name method_name - [ (type_name, method_info) ] - ~update:(List.cons (type_name, method_info)) - |> ignore - | Impl _ -> ()); - M.add tbl method_name entry); - H.add by_type type_name tbl); - { by_type; by_name } +let export (env : t) ~export_private = + (let result = + Vec.make (H.length env) ~dummy:(Type_path.Builtin.type_path_int, [||]) + in + H.iter2 env (fun self_type -> + fun methods -> + if + export_private + || (not (Type_path_util.is_foreign self_type)) + || !Basic_config.current_package = Basic_config.builtin_package + then ( + let methods_vec = + Vec.make (M.length methods) ~dummy:("", Only_impl []) + in + M.iter2 methods (fun method_name -> + fun entry -> + match entry with + | Has_regular { regular; impls } -> ( + if export_private || regular.pub then + Vec.push methods_vec + (method_name, Has_regular { regular; impls = [] }) + else + match + Lst.filter impls (fun mi -> export_private || mi.pub) + with + | [] -> () + | mis -> Vec.push methods_vec (method_name, Only_impl mis)) + | Only_impl mis -> ( + match + Lst.filter mis (fun mi -> export_private || mi.pub) + with + | [] -> () + | mis -> Vec.push methods_vec (method_name, Only_impl mis))); + if Vec.length methods_vec > 0 then + Vec.push result (self_type, Vec.to_array methods_vec))); + Vec.to_array result + : method_array) + +let import (methods_by_type : method_array) = + (let env = H.create (Array.length methods_by_type * 3 / 2) in + Arr.iter methods_by_type (fun (type_name, methods) -> + let tbl = M.create (Array.length methods * 3 / 2) in + Arr.iter methods (fun (method_name, entry) -> + M.add tbl method_name entry); + H.add env type_name tbl); + env + : t) diff --git a/src/mi_format.ml b/src/mi_format.ml index f9b2107..64e213f 100644 --- a/src/mi_format.ml +++ b/src/mi_format.ml @@ -52,7 +52,7 @@ module Serialize = struct export_values : (string * Value_info.toplevel) array; export_types : (string * Typedecl_info.t) array; export_traits : (string * Trait_decl.t) array; - export_type_alias : (string * Typedecl_info.alias) array; + export_type_alias : (string * Type_alias.t) array; export_method_env : method_array; export_ext_method_env : ext_method_array; export_trait_impls : Trait_impl.impl array; @@ -72,7 +72,8 @@ module Serialize = struct export_ext_method_env = export_ext_method_env__033_; export_trait_impls = export_trait_impls__035_; name = name__037_; - } -> + } + -> let bnds__006_ = ([] : _ Stdlib.List.t) in let bnds__006_ = let arg__038_ = Moon_sexp_conv.sexp_of_string name__037_ in @@ -103,7 +104,7 @@ module Serialize = struct Moon_sexp_conv.sexp_of_array (fun (arg0__027_, arg1__028_) -> let res0__029_ = Moon_sexp_conv.sexp_of_string arg0__027_ - and res1__030_ = Typedecl_info.sexp_of_alias arg1__028_ in + and res1__030_ = Type_alias.sexp_of_t arg1__028_ in S.List [ res0__029_; res1__030_ ]) export_type_alias__025_ in @@ -153,17 +154,35 @@ module Serialize = struct end let magic_str = Basic_config.mi_magic_str + let digest_len = 16 - let output_mi (type t) (action : t Action.t) (mi_content : serialized) : t = - match action with - | Action.Write_file path -> - Stdlib.Out_channel.with_open_bin path (fun oc -> - output_string oc magic_str; - Marshal.to_channel oc (mi_content : serialized) []) - | Action.Return_bytes -> - let magic_bytes = Bytes.of_string magic_str in - let mi_bytes = Marshal.to_bytes mi_content [] in - Bytes.cat magic_bytes mi_bytes + let output_mi (type t) (action : t Action.t) (mi_content : serialized) = + (let content = Marshal.to_bytes mi_content [] in + let digest = Digest.bytes content in + match action with + | Write_file path -> + let same_file_exist = + if Sys.file_exists path then + In_channel.with_open_bin path (fun ic -> + let magic_len = String.length magic_str in + let header = Bytes.make (magic_len + digest_len) '\000' in + if In_channel.input ic header 0 (magic_len + digest_len) = 0 + then false + else + String.equal digest + (Bytes.sub_string header magic_len digest_len)) + else false + in + if not same_file_exist then + Out_channel.with_open_bin path (fun oc -> + output_string oc magic_str; + output_string oc digest; + output_bytes oc content) + | Return_bytes -> + let magic_bytes = Bytes.of_string magic_str in + let digest_bytes = Bytes.of_string digest in + Bytes.cat (Bytes.cat magic_bytes digest_bytes) content + : t) let dummy_mi ~(pkg_name : string) = let mi_content : serialized = @@ -187,7 +206,7 @@ module Serialize = struct let magic_len = String.length Basic_config.mi_magic_str in let magic = String.sub bin 0 magic_len in if String.equal magic Basic_config.mi_magic_str then - Ok (Marshal.from_string bin magic_len : serialized) + Ok (Marshal.from_string bin (magic_len + digest_len) : serialized) else if String.length magic <> magic_len then Error (Errors.pkg_wrong_format ~pkg:path) else Error (Errors.pkg_magic_mismatch ~pkg:path) @@ -195,82 +214,92 @@ module Serialize = struct end let export_mi (type t) ~(action : t Action.t) ~(pkg_name : string) - ~(types : Typing_info.types) - ~(type_alias : Typedecl_info.alias Hash_string.t) - ~(values : Typing_info.values) ~method_env ~ext_method_env ~trait_impls : t - = - let pub_values = Typing_info.get_pub_values values in - let pub_types = Typing_info.get_pub_types types in - let pub_type_alias = - Hash_string.to_array_filter_map type_alias (fun (name, alias) -> - if alias.is_pub then Some (name, alias) else None) - in - let pub_traits = Typing_info.get_pub_traits types in - let mi_content : Serialize.serialized = - { - export_values = pub_values; - export_types = pub_types; - export_type_alias = pub_type_alias; - export_traits = pub_traits; - export_method_env = Method_env.export ~export_private:false method_env; - export_ext_method_env = - ext_method_env |> Ext_method_env.iter_pub |> Iter_utils.to_array; - export_trait_impls = Trait_impl.get_pub_impls trait_impls; - name = pkg_name; - } - in - Serialize.output_mi action mi_content + ~(types : Typing_info.types) ~(type_alias : Type_alias.t Hash_string.t) + ~(values : Typing_info.values) ~method_env ~ext_method_env ~trait_impls = + (let pub_values = Typing_info.get_pub_values values in + let pub_types = Typing_info.get_pub_types types in + let pub_type_alias = + Hash_string.to_array_filter_map type_alias (fun (name, alias) -> + if alias.is_pub then Some (name, alias) else None) + in + let pub_traits = Typing_info.get_pub_traits types in + let mi_content : Serialize.serialized = + { + export_values = pub_values; + export_types = pub_types; + export_type_alias = pub_type_alias; + export_traits = pub_traits; + export_method_env = Method_env.export ~export_private:false method_env; + export_ext_method_env = + Iter_utils.to_array (Ext_method_env.iter_pub ext_method_env); + export_trait_impls = Trait_impl.get_pub_impls trait_impls; + name = pkg_name; + } + in + Serialize.output_mi action mi_content + : t) -let serialized_of_pkg_info (mi_view : Pkg_info.mi_view) : Serialize.serialized = - { - export_values = mi_view.values; - export_types = mi_view.external_types; - export_type_alias = Hash_string.to_array mi_view.external_type_alias; - export_traits = mi_view.external_traits; - export_method_env = - Method_env.export ~export_private:false mi_view.method_env; - export_ext_method_env = - mi_view.ext_method_env |> Ext_method_env.iter_pub |> Iter_utils.to_array; - export_trait_impls = Trait_impl.get_pub_impls mi_view.trait_impls; - name = mi_view.name; - } +let serialized_of_pkg_info (mi_view : Pkg_info.mi_view) = + ({ + export_values = Hash_string.to_array mi_view.values; + export_types = Hash_string.to_array mi_view.external_types; + export_type_alias = Hash_string.to_array mi_view.external_type_alias; + export_traits = Hash_string.to_array mi_view.external_traits; + export_method_env = + Method_env.export ~export_private:false mi_view.method_env; + export_ext_method_env = + Iter_utils.to_array (Ext_method_env.iter_pub mi_view.ext_method_env); + export_trait_impls = Trait_impl.get_pub_impls mi_view.trait_impls; + name = mi_view.name; + } + : Serialize.serialized) -let pkg_info_of_serialized (pkg_info: Serialize.serialized): Pkg_info.mi_view = - let external_constrs = Hash_string.create 17 in - Arr.iter pkg_info.export_types (fun (_, ty_decl) -> - match ty_decl.ty_desc with - | Variant_type constrs | ErrorEnum_type constrs -> - Lst.iter constrs (fun ({ constr_name; _ } as constr_info) -> - Hash_string.add_or_update external_constrs constr_name - [ constr_info ] ~update:(fun cs -> constr_info :: cs) - |> ignore) - | New_type { newtype_constr = { constr_name; _ } as constr_info; _ } - | Error_type ({ constr_name; _ } as constr_info) -> - Hash_string.add_or_update external_constrs constr_name [ constr_info ] - ~update:(fun cs -> constr_info :: cs) - |> ignore - | Abstract_type | Extern_type | Record_type _ -> ()); - let external_type_alias = Hash_string.create 17 in - Arr.iter pkg_info.export_type_alias (fun (name, alias) -> - Hash_string.add external_type_alias name alias); - let trait_impls = Trait_impl.make () in - Arr.iter pkg_info.export_trait_impls (fun impl -> - let type_name = Stype.extract_tpath_exn (Stype.type_repr impl.self_ty) in - Trait_impl.add_impl trait_impls ~trait:impl.trait ~type_name impl); - { - values = pkg_info.export_values; - external_types = pkg_info.export_types; - external_type_alias; - external_traits = pkg_info.export_traits; - external_constrs; - method_env = Method_env.import pkg_info.export_method_env; - ext_method_env = Ext_method_env.of_array pkg_info.export_ext_method_env; - trait_impls; - name = pkg_info.name; - } +let pkg_info_of_serialized (pkg_info : Serialize.serialized) = + (let values = Hash_string.create 17 in + Arr.iter pkg_info.export_values (fun (name, value) -> + Hash_string.add values name value); + let external_types = Hash_string.create 17 in + let external_constrs = Hash_string.create 17 in + Arr.iter pkg_info.export_types (fun (name, ty_decl) -> + Hash_string.add external_types name ty_decl; + match ty_decl.ty_desc with + | Variant_type constrs | ErrorEnum_type constrs -> + Lst.iter constrs ~f:(fun ({ constr_name; _ } as constr_info) -> + ignore + (Hash_string.add_or_update external_constrs constr_name + [ constr_info ] ~update:(fun cs -> constr_info :: cs))) + | New_type { newtype_constr = { constr_name; _ } as constr_info; _ } + | Error_type ({ constr_name; _ } as constr_info) -> + ignore + (Hash_string.add_or_update external_constrs constr_name + [ constr_info ] ~update:(fun cs -> constr_info :: cs)) + | Abstract_type | Extern_type | Record_type _ -> ()); + let external_traits = Hash_string.create 17 in + Arr.iter pkg_info.export_traits (fun (name, decl) -> + Hash_string.add external_traits name decl); + let external_type_alias = Hash_string.create 17 in + Arr.iter pkg_info.export_type_alias (fun (name, alias) -> + Hash_string.add external_type_alias name alias); + let trait_impls = Trait_impl.make () in + Arr.iter pkg_info.export_trait_impls (fun impl -> + let type_name = Stype.extract_tpath_exn (Stype.type_repr impl.self_ty) in + Trait_impl.add_impl trait_impls ~trait:impl.trait ~type_name impl); + { + values; + external_types; + external_type_alias; + external_traits; + external_constrs; + method_env = Method_env.import pkg_info.export_method_env; + ext_method_env = Ext_method_env.of_array pkg_info.export_ext_method_env; + trait_impls; + name = pkg_info.name; + } + : Pkg_info.mi_view) -let input_mi ~path bin : Pkg_info.mi_view Info.t = - Result.map pkg_info_of_serialized (Serialize.input_raw ~path bin) +let input_mi ~path bin = + (Result.map pkg_info_of_serialized (Serialize.input_raw ~path bin) + : Pkg_info.mi_view Info.t) let dummy_mi = Serialize.dummy_mi diff --git a/src/monofy.ml b/src/monofy.ml index 78502a8..c16d1d0 100644 --- a/src/monofy.ml +++ b/src/monofy.ml @@ -32,8 +32,9 @@ type rename_ctx = { label_table : Label.t Label.Hash.t; } -let create_rename_ctx () : rename_ctx = - { ident_table = H.create 17; label_table = Label.Hash.create 17 } +let create_rename_ctx () = + ({ ident_table = H.create 17; label_table = Label.Hash.create 17 } + : rename_ctx) type monofy_ctx = { subst_env : Type_subst.t; @@ -44,41 +45,40 @@ type monofy_ctx = { monofy_env : Monofy_env.t; } -let update_ident ident_table (b : Ident.t) : Ident.t = - match b with - | Pident _ | Pmutable_ident _ -> - H.find_or_update ident_table b ~update:Ident.rename - | Pdot _ -> b - | Plocal_method _ -> assert false +let update_ident ident_table (b : Ident.t) = + (match b with + | Pident _ | Pmutable_ident _ -> + H.find_or_update ident_table b ~update:Ident.rename + | Pdot _ -> b + | Plocal_method _ -> assert false + : Ident.t) let generate_trait_method (type_name : Type_path.t) (method_type : Stype.t) - (method_name : string) (env : Type_subst.t) ~(worklist : Worklist.t) - ~(monofy_env : Monofy_env.t) ~(stype_defs : Typing_info.stype_defs) - ~(trait : Type_path.t) = + (method_name : string) (env : Type_subst.t) ~tparam_index + ~(worklist : Worklist.t) ~(monofy_env : Monofy_env.t) ~(trait : Type_path.t) + = match Monofy_env.find_method_opt monofy_env ~type_name ~method_name ~trait with | Some { prim = Some p; _ } when not (Primitive.is_intrinsic p) -> `Prim p | Some meth -> if not (Tvar_env.is_empty meth.ty_params_) then ( - let method_type', ty_args = + let method_type', kind, ty_args = Poly_type.instantiate_method_no_constraint meth in - Ctype.unify_exn method_type method_type'; + (match kind with + | Regular_method | Regular_method_qualified -> + Ctype.unify_exn method_type method_type' + | Method_explicit_self { self_ty } -> + Ctype.unify_exn self_ty + (Type_subst.monofy_typ env + (Tparam { index = tparam_index; name_ = "" }))); let qual_name = meth.id in let tys = Arr.map ty_args (monofy_typ env) in let new_binder = Worklist.find_new_binder_exn worklist qual_name tys in `Method (new_binder, meth.prim)) else `Method (Ident.of_qual_ident meth.id, meth.prim) - | None -> - let trait_methods = - Object_util.get_trait_methods ~trait:type_name ~stype_defs - in - let method_index = - Lst.find_index_exn trait_methods (fun (_, method_decl) -> - method_decl.method_name = method_name) - in - `Prim (Pcall_object_method { method_index; method_name }) + | None -> assert false let monofy_obj = object (self) @@ -120,8 +120,8 @@ let monofy_obj = let type_name = Type_subst.monofy_param ctx.subst_env ~index in match generate_trait_method type_name stype method_name ctx.subst_env - ~trait ~worklist:ctx.worklist ~monofy_env:ctx.monofy_env - ~stype_defs:ctx.stype_defs + ~tparam_index:index ~trait ~worklist:ctx.worklist + ~monofy_env:ctx.monofy_env with | `Prim prim -> Mcore.unsaturated_prim ~ty:mtype ~loc:loc_ prim | `Method (meth, prim) -> Mcore.var ~loc:loc_ ~ty:mtype meth ~prim) @@ -142,7 +142,7 @@ let monofy_obj = | Pdot qual_name when Array.length ty_args > 0 -> ( let ty = self#visit_typ ctx ty in let tys = Arr.map ty_args (monofy_typ ctx.subst_env) in - let args = List.map (self#visit_expr ctx) args in + let args = Lst.map args (self#visit_expr ctx) in match Core_util.specialize qual_name tys with | Some prim -> Mcore.prim ~loc:loc_ ~ty prim args | None -> @@ -154,7 +154,7 @@ let monofy_obj = | Plocal_method { index; trait; method_name } -> ( let func_ty = match kind with - | Normal { func_ty } -> func_ty + | Normal { func_ty } | Async { func_ty } -> func_ty | Join -> assert false in let func_sty = monofy_typ ctx.subst_env func_ty in @@ -163,8 +163,8 @@ let monofy_obj = let type_name = monofy_param ctx.subst_env ~index in match generate_trait_method type_name func_sty method_name ctx.subst_env - ~trait ~worklist:ctx.worklist ~monofy_env:ctx.monofy_env - ~stype_defs:ctx.stype_defs + ~tparam_index:index ~trait ~worklist:ctx.worklist + ~monofy_env:ctx.monofy_env with | `Prim prim -> Mcore.prim ~loc:loc_ ~ty:ret_ty prim args | `Method (func, prim) -> @@ -180,11 +180,12 @@ let monofy_obj = method! visit_apply_kind ctx kind = match kind with | Join -> Join - | Normal { func_ty } -> Normal { func_ty = self#visit_typ ctx func_ty } + | Normal { func_ty } | Async { func_ty } -> + Normal { func_ty = self#visit_typ ctx func_ty } method! visit_Cexpr_prim ctx prim args ty loc_ = let core_args = args in - let args = List.map (self#visit_expr ctx) args in + let args = Lst.map args (self#visit_expr ctx) in let ty = self#visit_typ ctx ty in match prim with | Perror_to_string -> @@ -204,7 +205,10 @@ let monofy_obj = | None -> let ty_string = Printer.type_to_string arg_ty in Mcore.const ~loc:loc_ - (C_string ("" : Stdlib.String.t)) + (C_string + (("" + : Stdlib.String.t) + [@merlin.hide])) | Some (id, prim) -> let func_ty : Mtype.t = T_func @@ -220,18 +224,19 @@ let monofy_generate (prog : Core.program) (wl : Worklist.t) ~(mtype_defs : Mtype.defs) ~(stype_defs : stype_defs) ~(monofy_env : Monofy_env.t) ~(exported_functions : Exported_functions.t) = let generate_expr ~(rename_ctx : rename_ctx) (env : Type_subst.t) - (expr : Core.expr) : Mcore.expr = - let ctx = - { - subst_env = env; - stype_defs; - mtype_defs; - rename_ctx; - worklist = wl; - monofy_env; - } - in - monofy_obj#visit_expr ctx expr + (expr : Core.expr) = + (let ctx = + { + subst_env = env; + stype_defs; + mtype_defs; + rename_ctx; + worklist = wl; + monofy_env; + } + in + monofy_obj#visit_expr ctx expr + : Mcore.expr) in let setup_rename_table (subtops : Core.subtop_fun_decl list) rename_table ~(hint_binder : Ident.t) = @@ -241,7 +246,7 @@ let monofy_generate (prog : Core.program) (wl : Worklist.t) (Qual_ident.get_pkg qual_name, Qual_ident.base_name qual_name) | _ -> assert false in - Lst.iter subtops (fun subtop -> + Lst.iter subtops ~f:(fun subtop -> let name = (name_hint ^ "." ^ Ident.to_string (Ident.rename subtop.binder) : Stdlib.String.t) @@ -252,19 +257,21 @@ let monofy_generate (prog : Core.program) (wl : Worklist.t) H.add rename_table subtop.binder new_binder) in let generate_fn ~(rename_ctx : rename_ctx) (fn : Core.fn) (env : Type_subst.t) - : Mcore.fn = - { - params = - Lst.map fn.params (fun { binder; ty; loc_ } : Mcore.param -> - let stype = monofy_typ env ty in - let mtype = Mtype.from_stype stype ~stype_defs ~mtype_defs in - { - binder = update_ident rename_ctx.ident_table binder; - ty = mtype; - loc_; - }); - body = generate_expr env fn.body ~rename_ctx; - } + = + ({ + params = + Lst.map fn.params (fun { binder; ty; loc_ } -> + (let stype = monofy_typ env ty in + let mtype = Mtype.from_stype stype ~stype_defs ~mtype_defs in + { + binder = update_ident rename_ctx.ident_table binder; + ty = mtype; + loc_; + } + : Mcore.param)); + body = generate_expr env fn.body ~rename_ctx; + } + : Mcore.fn) in let generate_subtops (subtops : Core.subtop_fun_decl list) rename_ctx env = Lst.map subtops (fun subtop -> @@ -278,135 +285,153 @@ let monofy_generate (prog : Core.program) (wl : Worklist.t) loc_ = Loc.no_location; }) in - let generate_fun_decl (fd : Core.top_fun_decl) : Mcore.top_item list = - match fd.binder with - | Pident _ | Pmutable_ident _ | Plocal_method _ -> assert false - | Pdot qual_name -> ( - match Worklist.find_analyzed_items wl qual_name with - | [] -> [] - | items -> - Lst.concat_map items (fun item : Mcore.top_item list -> - let env = Type_subst.make item.types in - let rename_ctx = create_rename_ctx () in - setup_rename_table fd.subtops rename_ctx.ident_table - ~hint_binder:fd.binder; - let subtops = generate_subtops fd.subtops rename_ctx env in - let func = generate_fn fd.func env ~rename_ctx in - Ctop_fn - { - binder = item.binder; - func; - export_info_ = None; - loc_ = fd.loc_; - } - :: subtops)) + let generate_fun_decl (fd : Core.top_fun_decl) = + (match fd.binder with + | Pmutable_ident _ -> assert false + | Pident _ -> assert false + | Plocal_method _ -> assert false + | Pdot qual_name -> ( + match Worklist.find_analyzed_items wl qual_name with + | [] -> [] + | items -> + Lst.concat_map items (fun item -> + (let env = Type_subst.make item.types in + let rename_ctx = create_rename_ctx () in + setup_rename_table fd.subtops rename_ctx.ident_table + ~hint_binder:fd.binder; + let subtops = generate_subtops fd.subtops rename_ctx env in + let func = generate_fn fd.func env ~rename_ctx in + Ctop_fn + { + binder = item.binder; + func; + export_info_ = None; + loc_ = fd.loc_; + } + :: subtops + : Mcore.top_item list))) + : Mcore.top_item list) in let main = ref None in let globals = Vec.empty () in - let generate (item : Core.top_item) : Mcore.top_item list = - match item with - | Ctop_expr { expr; is_main; loc_ } -> - let rename_ctx = create_rename_ctx () in - let expr = generate_expr (Type_subst.empty ()) expr ~rename_ctx in - if is_main then ( - main := Some (expr, loc_); - []) - else [ Ctop_expr { expr; loc_ } ] - | Ctop_fn - ({ binder; func; ty_params_; is_pub_ = true; loc_; subtops } as fun_decl) - when Tvar_env.is_empty ty_params_ -> ( - match - Exported_functions.get_exported_name exported_functions binder - with - | Some export_name -> - assert (subtops = []); - let rename_ctx = create_rename_ctx () in - let func = generate_fn func (Type_subst.empty ()) ~rename_ctx in - [ Ctop_fn { binder; func; export_info_ = Some export_name; loc_ } ] - | None -> generate_fun_decl fun_decl) - | Ctop_let { binder; expr; is_pub_; loc_ } -> ( - match binder with - | Pdot qual_name -> ( - match Worklist.find_analyzed_items wl qual_name with - | [] -> [] - | _ -> - let rename_ctx = create_rename_ctx () in - let expr = - generate_expr (Type_subst.empty ()) expr ~rename_ctx - in - Vec.push globals (binder, expr, is_pub_, loc_); - []) - | _ -> assert false) - | Ctop_fn fun_decl -> generate_fun_decl fun_decl - | Ctop_stub { binder; func_stubs; params_ty; return_ty; is_pub_; loc_ } -> - let transl_type (env : Type_subst.t) (t : Stype.t) : Mtype.t = - let ty = monofy_typ env t in - Mtype.from_stype ~stype_defs ~mtype_defs ty - in - let add_if_used () = - match binder with - | Pdot qual_name -> ( - match Worklist.find_analyzed_items wl qual_name with - | [] -> [] - | instances -> - Lst.map instances (fun i : Mcore.top_item -> - let env = Type_subst.make i.types in - let params_ty = Lst.map params_ty (transl_type env) in - let return_ty = Option.map (transl_type env) return_ty in - Ctop_stub - { - binder = i.binder; - func_stubs; - params_ty; - return_ty; - export_info_ = None; - loc_; - })) - | _ -> assert false - [@@inline] - in - if is_pub_ then - let export_info_ = - Exported_functions.get_exported_name exported_functions binder - in - if export_info_ <> None then - let env = Type_subst.empty () in - let params_ty = Lst.map params_ty (transl_type env) in - let return_ty = Option.map (transl_type env) return_ty in - [ - Ctop_stub - { binder; func_stubs; export_info_; params_ty; return_ty; loc_ }; - ] - else add_if_used () - else add_if_used () + let generate (item : Core.top_item) = + (match item with + | Ctop_expr { expr; is_main; loc_ } -> + let rename_ctx = create_rename_ctx () in + let expr = generate_expr (Type_subst.empty ()) expr ~rename_ctx in + if is_main then ( + main := Some (expr, loc_); + []) + else [ Ctop_expr { expr; loc_ } ] + | Ctop_fn + ({ binder; func; ty_params_; is_pub_ = true; loc_; subtops } as + fun_decl) + when Tvar_env.is_empty ty_params_ -> ( + match + Exported_functions.get_exported_name exported_functions binder + with + | Some export_name -> + assert (subtops = []); + let rename_ctx = create_rename_ctx () in + let func = generate_fn func (Type_subst.empty ()) ~rename_ctx in + [ Ctop_fn { binder; func; export_info_ = Some export_name; loc_ } ] + | None -> generate_fun_decl fun_decl) + | Ctop_let { binder; expr; is_pub_; loc_ } -> ( + match binder with + | Pdot qual_name -> ( + match Worklist.find_analyzed_items wl qual_name with + | [] -> [] + | _ -> + let rename_ctx = create_rename_ctx () in + let expr = + generate_expr (Type_subst.empty ()) expr ~rename_ctx + in + Vec.push globals (binder, expr, is_pub_, loc_); + []) + | _ -> assert false) + | Ctop_fn fun_decl -> generate_fun_decl fun_decl + | Ctop_stub { binder; func_stubs; params_ty; return_ty; is_pub_; loc_ } -> + let transl_type (env : Type_subst.t) (t : Stype.t) = + (let ty = monofy_typ env t in + Mtype.from_stype ~stype_defs ~mtype_defs ty + : Mtype.t) + in + let add_if_used () = + match binder with + | Pdot qual_name -> ( + match Worklist.find_analyzed_items wl qual_name with + | [] -> [] + | instances -> + Lst.map instances (fun i -> + (let env = Type_subst.make i.types in + let params_ty = Lst.map params_ty (transl_type env) in + let return_ty = + Option.map (transl_type env) return_ty + in + Ctop_stub + { + binder = i.binder; + func_stubs; + params_ty; + return_ty; + export_info_ = None; + loc_; + } + : Mcore.top_item))) + | _ -> assert false + [@@inline] + in + if is_pub_ then + let export_info_ = + Exported_functions.get_exported_name exported_functions binder + in + if export_info_ <> None then + let env = Type_subst.empty () in + let params_ty = Lst.map params_ty (transl_type env) in + let return_ty = Option.map (transl_type env) return_ty in + [ + Ctop_stub + { + binder; + func_stubs; + export_info_; + params_ty; + return_ty; + loc_; + }; + ] + else add_if_used () + else add_if_used () + : Mcore.top_item list) in let result = Lst.flat_map_append prog ~init:[] ~f:generate in let toplevels = Vec.map_into_list_and_append (Worklist.order_globals wl globals) - ~f:(fun (binder, expr, is_pub_, loc_) : Mcore.top_item -> - Ctop_let { binder; expr; is_pub_; loc_ }) + ~f:(fun (binder, expr, is_pub_, loc_) -> + (Ctop_let { binder; expr; is_pub_; loc_ } : Mcore.top_item)) result in (toplevels, !main) let monofy (prog : Core.program) ~(monofy_env : Monofy_env.t) - ~(stype_defs : stype_defs) ~exported_functions : Mcore.t = - let mtype_defs : Mtype.defs = - { defs = Mtype.Id_hash.create 17; ext_tags = Basic_hash_string.create 17 } - in - let wl = - Monofy_analyze.monofy_analyze prog monofy_env ~stype_defs ~mtype_defs - ~exported_functions - in - let body, main = - monofy_generate prog wl ~monofy_env ~mtype_defs ~stype_defs - ~exported_functions - in - let body = - if Worklist.get_used_error_to_string wl then - Worklist.make_error_to_string wl ~tags:mtype_defs.ext_tags :: body - else body - in - let object_methods = Monofy_worklist.get_all_object_methods wl in - { body; main; types = mtype_defs; object_methods } + ~(stype_defs : stype_defs) ~exported_functions = + (let mtype_defs : Mtype.defs = + { defs = Mtype.Id_hash.create 17; ext_tags = Basic_hash_string.create 17 } + in + let wl = + Monofy_analyze.monofy_analyze prog monofy_env ~stype_defs ~mtype_defs + ~exported_functions + in + let body, main = + monofy_generate prog wl ~monofy_env ~mtype_defs ~stype_defs + ~exported_functions + in + let body = + if Worklist.get_used_error_to_string wl then + Worklist.make_error_to_string wl ~tags:mtype_defs.ext_tags :: body + else body + in + let object_methods = Monofy_worklist.get_all_object_methods wl in + { body; main; types = mtype_defs; object_methods } + : Mcore.t) diff --git a/src/monofy_analyze.ml b/src/monofy_analyze.ml index 07b88a5..81b7c92 100644 --- a/src/monofy_analyze.ml +++ b/src/monofy_analyze.ml @@ -16,7 +16,6 @@ module Lst = Basic_lst module Arr = Basic_arr module Ident = Basic_core_ident -module Qual_ident = Basic_qual_ident module Worklist = Monofy_worklist module Q = Qual_ident_tbl module Type_path = Basic_type_path @@ -25,218 +24,188 @@ let add_dependency (wl : Worklist.t) (src : Ident.t option) (tgt : Ident.t) = match src with None -> () | Some src -> Worklist.add_dependency wl src tgt let monofy_analyze (prog : Core.program) (monofy_env : Monofy_env.t) ~stype_defs - ~mtype_defs ~exported_functions : Worklist.t = - let (wl : Worklist.t) = Monofy_worklist.make () in - let analyze_ident ~(binder : Ident.t option) (env : Type_subst.t) - (ty_args : Type_args.t) (ty : Stype.t) (id : Ident.t) : unit = - match id with - | Pident _ | Pmutable_ident _ -> () - | Pdot qual_name -> - let tys = Arr.map ty_args (Type_subst.monofy_typ env) in - if not (Core_util.specializable qual_name tys) then - let new_id = Worklist.add_value_if_not_exist wl qual_name tys in - add_dependency wl binder new_id - | Plocal_method { index; trait; method_name } -> ( - let type_name = Type_subst.monofy_param env ~index in - let method_type = Type_subst.monofy_typ env ty in - match - Monofy_env.find_method_opt monofy_env ~type_name ~method_name ~trait - with - | None -> () - | Some meth -> - let method_type', ty_args = - Poly_type.instantiate_method_no_constraint meth - in - Ctype.unify_exn method_type method_type'; - let qual_name = meth.id in - let tys = Arr.map ty_args (Type_subst.monofy_typ env) in + ~mtype_defs ~exported_functions = + (let (wl : Worklist.t) = Monofy_worklist.make () in + let analyze_ident ~(binder : Ident.t option) (env : Type_subst.t) + (ty_args : Type_args.t) (ty : Stype.t) (id : Ident.t) = + (match id with + | Pident _ | Pmutable_ident _ -> () + | Pdot qual_name -> + let tys = Arr.map ty_args (Type_subst.monofy_typ env) in + if not (Core_util.specializable qual_name tys) then let new_id = Worklist.add_value_if_not_exist wl qual_name tys in - add_dependency wl binder new_id) - in - let analyze_object ~(binder : Ident.t option) ~(self_typ : Stype.t) - ~(trait : Type_path.t) : unit = - let self_typ = Stype.type_repr self_typ in - let type_name = Stype.extract_tpath_exn self_typ in - let type_ = Type_args.mangle_ty self_typ in - if not (Worklist.has_object wl ~trait ~type_) then - let trait_def = - match trait with - | Toplevel { pkg; id } -> - let types = Basic_hash_string.find_exn stype_defs pkg in - Typing_info.find_trait_exn types id - | _ -> assert false - in - let methods = - Lst.map trait_def.closure_methods - (fun (actual_trait, meth_decl) : Object_util.object_method_item -> - let method_name = meth_decl.method_name in - let method_type = - Poly_type.instantiate_method_decl meth_decl ~self:self_typ - in - let method_mty = - Mtype.from_stype method_type ~stype_defs ~mtype_defs - in - let resolve_method () : Object_util.object_method_item = - match[@warning "-fragile-match"] - Monofy_env.find_method_opt monofy_env ~type_name - ~trait:actual_trait ~method_name - with - | Some method_info -> - let method_type', ty_args = - Poly_type.instantiate_method_no_constraint method_info - in - Ctype.unify_exn method_type method_type'; - let method_id = - match method_info.prim with - | Some (Pintrinsic _) | None -> - let method_id = - Worklist.add_value_if_not_exist wl method_info.id - ty_args - in - add_dependency wl binder method_id; - method_id - | Some _ -> Ident.of_qual_ident method_info.id - in - { - method_id; - method_prim = method_info.prim; - method_ty = method_mty; - } - | _ -> assert false - in - match self_typ with - | T_trait self -> ( - let self_trait_def = - match self with - | Toplevel { pkg; id } -> - let types = Basic_hash_string.find_exn stype_defs pkg in - Typing_info.find_trait_exn types id - | _ -> assert false - in - match - Lst.find_first_with_index self_trait_def.closure_methods - (fun (actual_trait', meth_decl') -> - Type_path.equal actual_trait' actual_trait - && meth_decl'.method_name = method_name) - with - | Some (method_index, (actual_trait, _)) -> - { - method_id = - Ident.of_qual_ident - (Qual_ident.meth ~self_typ:actual_trait - ~name:method_name); - method_prim = - Some (Pcall_object_method { method_index; method_name }); - method_ty = method_mty; - } - | None -> ( - match - Lst.find_first_with_index self_trait_def.methods - (fun meth_decl' -> meth_decl'.method_name = method_name) - with - | Some (method_index, _) -> - { - method_id = - Ident.of_qual_ident - (Qual_ident.meth ~self_typ:self ~name:method_name); - method_prim = - Some - (Pcall_object_method { method_index; method_name }); - method_ty = method_mty; - } - | None -> resolve_method ())) - | _ -> resolve_method ()) - in - let self_ty = Mtype.from_stype self_typ ~stype_defs ~mtype_defs in - Worklist.add_object_methods wl ~trait ~type_ ~self_ty ~methods - in - let analyze_expr ~(binder : Ident.t option) (env : Type_subst.t) - (e : Core.expr) = - let obj = - object (self) - inherit [_] Core.Iter.iter as super + add_dependency wl binder new_id + | Plocal_method { index; name_; trait; method_name } -> ( + let type_name = Type_subst.monofy_param env ~index in + let method_type = Type_subst.monofy_typ env ty in + match + Monofy_env.find_method_opt monofy_env ~type_name ~method_name ~trait + with + | None -> () + | Some meth -> + let method_type', kind, ty_args = + Poly_type.instantiate_method_no_constraint meth + in + (match kind with + | Regular_method | Regular_method_qualified -> + Ctype.unify_exn method_type method_type' + | Method_explicit_self { self_ty } -> + Ctype.unify_exn self_ty + (Type_subst.monofy_typ env (Tparam { index; name_ }))); + let qual_name = meth.id in + let tys = Arr.map ty_args (Type_subst.monofy_typ env) in + let new_id = Worklist.add_value_if_not_exist wl qual_name tys in + add_dependency wl binder new_id) + : unit) + in + let analyze_object ~(binder : Ident.t option) ~(self_typ : Stype.t) + ~(trait : Type_path.t) = + (let self_typ = Stype.type_repr self_typ in + let type_name = Stype.extract_tpath_exn self_typ in + let type_ = Type_args.mangle_ty self_typ in + if not (Worklist.has_object wl ~trait ~type_) then + let trait_def = + match trait with + | Toplevel { pkg; id } -> + let types = Basic_hash_string.find_exn stype_defs pkg in + Typing_info.find_trait_exn types id + | _ -> assert false + in + let methods = + Lst.map trait_def.closure_methods (fun (actual_trait, meth_decl) -> + (let method_name = meth_decl.method_name in + let method_type = + Poly_type.instantiate_method_decl meth_decl ~self:self_typ + in + let method_mty = + Mtype.from_stype method_type ~stype_defs ~mtype_defs + in + match[@warning "-fragile-match"] + Monofy_env.find_method_opt monofy_env ~type_name + ~trait:actual_trait ~method_name + with + | Some method_info -> + let method_type', kind, ty_args = + Poly_type.instantiate_method_no_constraint method_info + in + (match kind with + | Regular_method | Regular_method_qualified -> + Ctype.unify_exn method_type method_type' + | Method_explicit_self { self_ty } -> + Ctype.unify_exn self_ty self_typ); + Ctype.unify_exn method_type method_type'; + let method_id = + match method_info.prim with + | Some (Pintrinsic _) | None -> + let method_id = + Worklist.add_value_if_not_exist wl method_info.id + ty_args + in + add_dependency wl binder method_id; + method_id + | Some _ -> Ident.of_qual_ident method_info.id + in + { + method_id; + method_prim = method_info.prim; + method_ty = method_mty; + } + | _ -> assert false + : Object_util.object_method_item)) + in + let self_ty = Mtype.from_stype self_typ ~stype_defs ~mtype_defs in + Worklist.add_object_methods wl ~trait ~type_ ~self_ty ~methods + : unit) + in + let analyze_expr ~(binder : Ident.t option) (env : Type_subst.t) + (e : Core.expr) = + let obj = + object (self) + inherit [_] Core.Iter.iter as super - method! visit_Cexpr_var () id ty ty_args _prim _loc_ = - analyze_ident ~binder env ty_args ty id + method! visit_Cexpr_var () id ty ty_args _prim _loc_ = + analyze_ident ~binder env ty_args ty id - method! visit_Cexpr_apply () func args kind ty ty_args prim loc_ = - (match kind with - | Normal { func_ty } -> analyze_ident ~binder env ty_args func_ty func - | Join -> ()); - super#visit_Cexpr_apply () func args kind ty ty_args prim loc_ + method! visit_Cexpr_apply () func args kind ty ty_args prim loc_ = + (match kind with + | Normal { func_ty } | Async { func_ty } -> + analyze_ident ~binder env ty_args func_ty func + | Join -> ()); + super#visit_Cexpr_apply () func args kind ty ty_args prim loc_ - method! visit_Cexpr_as () expr trait obj_ty _loc_ = - self#visit_expr () expr; - let monofied_obj_ty = Type_subst.monofy_typ env obj_ty in - analyze_object ~binder ~self_typ:monofied_obj_ty ~trait + method! visit_Cexpr_as () expr trait obj_ty _loc_ = + self#visit_expr () expr; + let monofied_obj_ty = Type_subst.monofy_typ env obj_ty in + analyze_object ~binder ~self_typ:monofied_obj_ty ~trait - method! visit_Cexpr_prim () prim args ty loc_ = - (match prim with - | Perror_to_string -> Worklist.set_used_error_to_string wl - | Pany_to_string -> ( - match[@warning "-fragile-match"] args with - | arg :: [] -> - let arg_ty = - Type_subst.monofy_typ env (Core.type_of_expr arg) - in - Worklist.add_any_to_string wl monofy_env arg_ty - | _ -> assert false) - | _ -> ()); - super#visit_Cexpr_prim () prim args ty loc_ + method! visit_Cexpr_prim () prim args ty loc_ = + (match prim with + | Perror_to_string -> Worklist.set_used_error_to_string wl + | Pany_to_string -> ( + match[@warning "-fragile-match"] args with + | arg :: [] -> + let arg_ty = + Type_subst.monofy_typ env (Core.type_of_expr arg) + in + Worklist.add_any_to_string wl monofy_env arg_ty + | _ -> assert false) + | _ -> ()); + super#visit_Cexpr_prim () prim args ty loc_ - method! visit_constr_tag () tag = - match tag with - | Constr_tag_regular _ -> () - | Extensible_tag _ -> Worklist.add_error_type wl tag - end - in - obj#visit_expr () e - in - let def_tbl : Core.expr list Q.t = Q.create 17 in - let rec analyze_loop () = - let todo_items = Worklist.get_todo_items_and_mark_as_analyzed wl in - match todo_items with - | [] -> () - | items -> - Lst.iter items (fun { types; binder; old_binder } -> - match Q.find_opt def_tbl old_binder with - | Some expr -> - let env = Type_subst.make types in - Lst.iter expr (analyze_expr ~binder:(Some binder) env) - | None -> ()); - analyze_loop () - in - let collect (item : Core.top_item) = - match item with - | Ctop_expr { expr; is_main = _ } -> - analyze_expr ~binder:None (Type_subst.empty ()) expr - | Ctop_fn - { - binder; - func = { body = expr; _ }; - ty_params_; - is_pub_ = true; - subtops; - } - when Exported_functions.is_exported_ident exported_functions binder - && Tvar_env.is_empty ty_params_ -> - assert (subtops = []); - analyze_expr ~binder:(Some binder) (Type_subst.empty ()) expr - | Ctop_let { binder; expr } -> ( - match binder with - | Pdot qual_name -> Q.add def_tbl qual_name [ expr ] - | _ -> assert false) - | Ctop_fn { binder; func = { body = expr; _ }; subtops } -> ( - match binder with - | Pdot qual_name -> - Q.add def_tbl qual_name - (expr :: Lst.map subtops (fun subtop -> subtop.fn.body)) - | _ -> assert false) - | Ctop_stub _ -> () - in - Lst.iter prog collect; - analyze_loop (); - if Worklist.get_used_error_to_string wl then ( - Worklist.add_error_to_string wl ~monofy_env; - analyze_loop ()); - wl + method! visit_constr_tag () tag = + match tag with + | Constr_tag_regular _ -> () + | Extensible_tag _ -> Worklist.add_error_type wl tag + end + in + obj#visit_expr () e + in + let def_tbl : Core.expr list Q.t = Q.create 17 in + let rec analyze_loop () = + let todo_items = Worklist.get_todo_items_and_mark_as_analyzed wl in + match todo_items with + | [] -> () + | items -> + Lst.iter items ~f:(fun { types; binder; old_binder } -> + match Q.find_opt def_tbl old_binder with + | Some expr -> + let env = Type_subst.make types in + Lst.iter expr ~f:(analyze_expr ~binder:(Some binder) env) + | None -> ()); + analyze_loop () + in + let collect (item : Core.top_item) = + match item with + | Ctop_expr { expr; is_main = _ } -> + analyze_expr ~binder:None (Type_subst.empty ()) expr + | Ctop_fn + { + binder; + func = { body = expr; _ }; + ty_params_; + is_pub_ = true; + subtops; + } + when Exported_functions.is_exported_ident exported_functions binder + && Tvar_env.is_empty ty_params_ -> + assert (subtops = []); + analyze_expr ~binder:(Some binder) (Type_subst.empty ()) expr + | Ctop_let { binder; expr } -> ( + match binder with + | Pdot qual_name -> Q.add def_tbl qual_name [ expr ] + | _ -> assert false) + | Ctop_fn { binder; func = { body = expr; _ }; subtops } -> ( + match binder with + | Pdot qual_name -> + Q.add def_tbl qual_name + (expr :: Lst.map subtops (fun subtop -> subtop.fn.body)) + | _ -> assert false) + | Ctop_stub _ -> () + in + Lst.iter prog ~f:collect; + analyze_loop (); + if Worklist.get_used_error_to_string wl then ( + Worklist.add_error_to_string wl ~monofy_env; + analyze_loop ()); + wl + : Worklist.t) diff --git a/src/monofy_env.ml b/src/monofy_env.ml index d2fe346..047c4cb 100644 --- a/src/monofy_env.ml +++ b/src/monofy_env.ml @@ -21,8 +21,8 @@ type t = { extension_methods : Ext_method_env.t Hash_string.t; } -let make ~regular_methods ~extension_methods : t = - { regular_methods; extension_methods } +let make ~regular_methods ~extension_methods = + ({ regular_methods; extension_methods } : t) let find_method_opt (env : t) ~(type_name : Method_env.type_name) ~(method_name : Method_env.method_name) ~(trait : Type_path.t) = diff --git a/src/monofy_instances.ml b/src/monofy_instances.ml index 3e789c5..9bc668f 100644 --- a/src/monofy_instances.ml +++ b/src/monofy_instances.ml @@ -33,7 +33,8 @@ include struct types = types__002_; binder = binder__004_; old_binder = old_binder__006_; - } -> + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = let arg__007_ = Basic_qual_ident.sexp_of_t old_binder__006_ in @@ -59,9 +60,10 @@ include struct and _ = sexp_of_t end -let find_item (items : t) (tys : Type_args.t) : Ident.t option = - Lst.find_opt items (fun item -> - if Type_args.equal tys item.types then Some item.binder else None) +let find_item (items : t) (tys : Type_args.t) = + (Lst.find_opt items (fun item -> + if Type_args.equal tys item.types then Some item.binder else None) + : Ident.t option) -let has_type_args (items : t) (tys : Type_args.t) : bool = - Lst.exists items (fun item -> Type_args.equal tys item.types) +let has_type_args (items : t) (tys : Type_args.t) = + (Lst.exists items (fun item -> Type_args.equal tys item.types) : bool) diff --git a/src/monofy_worklist.ml b/src/monofy_worklist.ml index c41ebb0..eef7da1 100644 --- a/src/monofy_worklist.ml +++ b/src/monofy_worklist.ml @@ -32,44 +32,47 @@ type t = { obj_to_string : Method_env.method_info option Type_path.Hash.t; } -let make () : t = - { - todo = Q.create 17; - complete = Q.create 17; - objects = Object_hash.create 17; - used_error_to_string = ref false; - error_types = Type_path.Hash.create 17; - dependency = Ident.Hash.create 17; - obj_to_string = Type_path.Hash.create 17; - } +let make () = + ({ + todo = Q.create 17; + complete = Q.create 17; + objects = Object_hash.create 17; + used_error_to_string = ref false; + error_types = Type_path.Hash.create 17; + dependency = Ident.Hash.create 17; + obj_to_string = Type_path.Hash.create 17; + } + : t) let add_value_if_not_exist (worklist : t) (qual_name : Q.key) - (tys : Type_args.t) : Ident.t = - let monofy_ident (qual_name : Qual_ident.t) (tys : Type_args.t) : Ident.t = - let q : Basic_qual_ident.t = - if Arr.is_empty tys then qual_name - else - Basic_qual_ident.map qual_name ~f:(fun s -> - Stdlib.String.concat "" [ s; "|"; Type_args.mangle tys; "|" ]) - in - Ident.of_qual_ident q - in - let complete_item = - match Q.find_opt worklist.complete qual_name with - | Some items -> Monofy_instances.has_type_args items tys - | None -> false - in - let id = monofy_ident qual_name tys in - (if not complete_item then - match Q.find_opt worklist.todo qual_name with - | Some items -> - if not (Monofy_instances.has_type_args items tys) then - Q.replace worklist.todo qual_name - ({ binder = id; types = tys; old_binder = qual_name } :: items) - | None -> - Q.add worklist.todo qual_name - [ { binder = id; types = tys; old_binder = qual_name } ]); - id + (tys : Type_args.t) = + (let monofy_ident (qual_name : Qual_ident.t) (tys : Type_args.t) = + (let q : Basic_qual_ident.t = + if Arr.is_empty tys then qual_name + else + Basic_qual_ident.map qual_name ~f:(fun s -> + Stdlib.String.concat "" [ s; "|"; Type_args.mangle tys; "|" ]) + in + Ident.of_qual_ident q + : Ident.t) + in + let complete_item = + match Q.find_opt worklist.complete qual_name with + | Some items -> Monofy_instances.has_type_args items tys + | None -> false + in + let id = monofy_ident qual_name tys in + (if not complete_item then + match Q.find_opt worklist.todo qual_name with + | Some items -> + if not (Monofy_instances.has_type_args items tys) then + Q.replace worklist.todo qual_name + ({ binder = id; types = tys; old_binder = qual_name } :: items) + | None -> + Q.add worklist.todo qual_name + [ { binder = id; types = tys; old_binder = qual_name } ]); + id + : Ident.t) let add_to_complete (wl : t) (qual_name : Q.key) (new_items : Monofy_instances.t) = @@ -78,48 +81,50 @@ let add_to_complete (wl : t) (qual_name : Q.key) Q.replace wl.complete qual_name (new_items @ complete_items) | None -> Q.add wl.complete qual_name new_items -let get_todo_items_and_mark_as_analyzed (wl : t) : Monofy_instances.t = - let items = ref [] in - Q.iter2 wl.todo (fun qual_name item -> - add_to_complete wl qual_name item; - items := item @ !items); - Q.clear wl.todo; - !items +let get_todo_items_and_mark_as_analyzed (wl : t) = + (let items = ref [] in + Q.iter2 wl.todo (fun qual_name -> + fun item -> + add_to_complete wl qual_name item; + items := item @ !items); + Q.clear wl.todo; + !items + : Monofy_instances.t) -let find_analyzed_items (wl : t) (qual_name : Q.key) : Monofy_instances.t = - Q.find_default wl.complete qual_name [] +let find_analyzed_items (wl : t) (qual_name : Q.key) = + (Q.find_default wl.complete qual_name [] : Monofy_instances.t) -let find_new_binder_exn (wl : t) (qual_name : Q.key) (tys : Type_args.t) : - Ident.t = - let complete_item = - match Q.find_opt wl.complete qual_name with - | Some items -> Monofy_instances.find_item items tys - | None -> None - in - match complete_item with - | Some item -> item - | None -> ( - let items = Q.find_exn wl.todo qual_name in - match Monofy_instances.find_item items tys with - | Some item -> item - | None -> assert false) +let find_new_binder_exn (wl : t) (qual_name : Q.key) (tys : Type_args.t) = + (let complete_item = + match Q.find_opt wl.complete qual_name with + | Some items -> Monofy_instances.find_item items tys + | None -> None + in + match complete_item with + | Some item -> item + | None -> ( + let items = Q.find_exn wl.todo qual_name in + match Monofy_instances.find_item items tys with + | Some item -> item + | None -> assert false) + : Ident.t) -let find_new_binder_opt (wl : t) (qual_name : Q.key) (tys : Type_args.t) : - Ident.t option = - let complete_item = - match Q.find_opt wl.complete qual_name with - | Some items -> Monofy_instances.find_item items tys - | None -> None - in - match complete_item with - | Some item -> Some item - | None -> ( - match Q.find_opt wl.todo qual_name with - | Some items -> Monofy_instances.find_item items tys - | None -> None) +let find_new_binder_opt (wl : t) (qual_name : Q.key) (tys : Type_args.t) = + (let complete_item = + match Q.find_opt wl.complete qual_name with + | Some items -> Monofy_instances.find_item items tys + | None -> None + in + match complete_item with + | Some item -> Some item + | None -> ( + match Q.find_opt wl.todo qual_name with + | Some items -> Monofy_instances.find_item items tys + | None -> None) + : Ident.t option) -let has_object (worklist : t) ~(trait : Type_path.t) ~(type_ : string) : bool = - Object_hash.mem worklist.objects { trait; type_ } +let has_object (worklist : t) ~(trait : Type_path.t) ~(type_ : string) = + (Object_hash.mem worklist.objects { trait; type_ } : bool) let add_object_methods (worklist : t) ~(trait : Type_path.t) ~(type_ : string) ~self_ty ~(methods : Object_util.object_method_item list) = @@ -134,10 +139,10 @@ let add_error_type (worklist : t) (tag : Basic_constr_info.constr_tag) = Type_path.toplevel_type ~pkg type_name | _ -> assert false in - Type_path.Hash.add_or_update worklist.error_types type_path - ~update:(fun t -> t) - None - |> ignore + ignore + (Type_path.Hash.add_or_update worklist.error_types type_path + ~update:(fun t -> t) + None) let check_impl_show_trait ~(monofy_env : Monofy_env.t) ~type_name = if @@ -157,7 +162,6 @@ let add_error_to_string (worklist : t) ~(monofy_env : Monofy_env.t) = type_constructor = type_name; tys = []; generic_ = false; - only_tag_enum_ = false; is_suberror_ = true; } in @@ -169,11 +173,11 @@ let add_error_to_string (worklist : t) ~(monofy_env : Monofy_env.t) = Type_path.Hash.replace worklist.error_types type_name (Some new_ident) | None -> ()) -let get_used_error_to_string (worklist : t) : bool = - !(worklist.used_error_to_string) +let get_used_error_to_string (worklist : t) = + (!(worklist.used_error_to_string) : bool) -let set_used_error_to_string (worklist : t) : unit = - worklist.used_error_to_string := true +let set_used_error_to_string (worklist : t) = + (worklist.used_error_to_string := true : unit) let error_to_string_binder = Ident.of_qual_ident (Basic_qual_ident.make ~pkg:"Error" ~name:"to_string") @@ -184,97 +188,100 @@ let decode_type_from_tag_str (s : string) = | [ type_name; _ ] -> Some (Type_path.toplevel_type ~pkg:"" type_name) | _ -> None -let make_error_to_string (worklist : t) ~(tags : int Basic_hash_string.t) : - Mcore.top_item = - let err_ty : Mtype.t = T_constr Mtype.error_mid in - let e_id = Ident.fresh "*e" in - let param : Mcore.param = - { binder = e_id; ty = err_ty; loc_ = Rloc.no_location } - in - if Basic_hash_string.length tags = 0 then - Ctop_fn - { - binder = error_to_string_binder; - func = { params = [ param ]; body = Mcore.prim ~ty:T_string Ppanic [] }; - export_info_ = None; - loc_ = Loc.no_location; - } - else - let match_obj = Mcore.var e_id ~ty:err_ty ~prim:None in - let cases = Basic_vec.empty () in - let make_case (tag_name : string) (index : int) = - let tag : Tag.t = { index; is_constant_ = false; name_ = tag_name } in - let default () = - let str = Mcore.const (C_string tag_name) in - Basic_vec.push cases (tag, None, str) - [@@local] - in - match decode_type_from_tag_str tag_name with - | Some type_name -> ( - match Type_path.Hash.find_opt worklist.error_types type_name with - | Some (Some func) -> - let method_ty : Mtype.t = - T_func - { params = [ T_constr Mtype.error_mid ]; return = T_string } - in - let kind = Mcore.Normal { func_ty = method_ty } in - let args = [ match_obj ] in - let action = - Mcore.apply ~prim:None ~ty:T_string ~kind func args - in - Basic_vec.push cases (tag, None, action) - | _ -> default ()) - | None -> default () - in - Basic_hash_string.iter tags (fun (tag, idx) -> make_case tag idx); - let cases = Basic_vec.to_list cases in - let body = - Mcore.switch_constr ~loc:Rloc.no_location ~default:None match_obj cases - in - let func : Mcore.fn = { params = [ param ]; body } in - Ctop_fn - { - binder = error_to_string_binder; - func; - export_info_ = None; - loc_ = Loc.no_location; - } +let make_error_to_string (worklist : t) ~(tags : int Basic_hash_string.t) = + (let err_ty : Mtype.t = T_constr Mtype.error_mid in + let e_id = Ident.fresh "*e" in + let param : Mcore.param = + { binder = e_id; ty = err_ty; loc_ = Rloc.no_location } + in + if Basic_hash_string.length tags = 0 then + Ctop_fn + { + binder = error_to_string_binder; + func = { params = [ param ]; body = Mcore.prim ~ty:T_string Ppanic [] }; + export_info_ = None; + loc_ = Loc.no_location; + } + else + let match_obj = Mcore.var e_id ~ty:err_ty ~prim:None in + let cases = Basic_vec.empty () in + let make_case (tag_name : string) (index : int) = + let tag : Tag.t = { index; is_constant_ = false; name_ = tag_name } in + let default () = + let str = Mcore.const (C_string tag_name) in + Basic_vec.push cases (tag, None, str) + [@@local] + in + match decode_type_from_tag_str tag_name with + | Some type_name -> ( + match Type_path.Hash.find_opt worklist.error_types type_name with + | Some (Some func) -> + let method_ty : Mtype.t = + T_func + { params = [ T_constr Mtype.error_mid ]; return = T_string } + in + let kind = Mcore.Normal { func_ty = method_ty } in + let args = [ match_obj ] in + let action = + Mcore.apply ~prim:None ~ty:T_string ~kind func args + in + Basic_vec.push cases (tag, None, action) + | _ -> default ()) + | None -> default () + in + Basic_hash_string.iter tags (fun (tag, idx) -> make_case tag idx); + let cases = Basic_vec.to_list cases in + let body = + Mcore.switch_constr ~loc:Rloc.no_location ~default:None match_obj cases + in + let func : Mcore.fn = { params = [ param ]; body } in + Ctop_fn + { + binder = error_to_string_binder; + func; + export_info_ = None; + loc_ = Loc.no_location; + } + : Mcore.top_item) -let add_dependency (worklist : t) (ident : Ident.t) (dep : Ident.t) : unit = - match Ident.Hash.find_opt worklist.dependency ident with - | Some (_, deps) -> Ident.Hashset.add deps dep - | None -> - let deps = Ident.Hashset.create 17 in - Ident.Hashset.add deps dep; - let index = Ident.Hash.length worklist.dependency in - Ident.Hash.add worklist.dependency ident (index, deps) +let add_dependency (worklist : t) (ident : Ident.t) (dep : Ident.t) = + (match Ident.Hash.find_opt worklist.dependency ident with + | Some (_, deps) -> Ident.Hashset.add deps dep + | None -> + let deps = Ident.Hashset.create 17 in + Ident.Hashset.add deps dep; + let index = Ident.Hash.length worklist.dependency in + Ident.Hash.add worklist.dependency ident (index, deps) + : unit) let order_globals (worklist : t) - (globals : (Ident.t * Mcore.expr * bool * Loc.t) Vec.t) : - (Ident.t * Mcore.expr * bool * Loc.t) Vec.t = - let indexed_globals = Basic_hash_int.create 17 in - let res = Vec.empty () in - Vec.iter (fun ((id, _, _, _) as global) -> - match Ident.Hash.find_opt worklist.dependency id with - | Some (index, _) -> Basic_hash_int.add indexed_globals index global - | None -> Vec.push res global) globals; - if Vec.length res = Vec.length globals then res - else - let nodes_num = Ident.Hash.length worklist.dependency in - let dep_graph = Array.init nodes_num (fun _ -> Vec_int.empty ()) in - Ident.Hash.iter worklist.dependency (fun (_, (src_index, deps)) -> - Ident.Hashset.iter deps (fun d -> - match Ident.Hash.find_opt worklist.dependency d with - | Some (tgt_index, _) -> - Vec_int.push dep_graph.(src_index) tgt_index - | None -> ())); - let scc = Basic_scc.graph dep_graph in - Vec.iter (fun c -> - Vec_int.iter c (fun i -> - match Basic_hash_int.find_opt indexed_globals i with - | Some global -> Vec.push res global - | None -> ())) scc; - res + (globals : (Ident.t * Mcore.expr * bool * Loc.t) Vec.t) = + (let indexed_globals = Basic_hash_int.create 17 in + let res = Vec.empty () in + Vec.iter (fun ((id, _, _, _) as global) -> + match Ident.Hash.find_opt worklist.dependency id with + | Some (index, _) -> Basic_hash_int.add indexed_globals index global + | None -> Vec.push res global) + globals; + if Vec.length res = Vec.length globals then res + else + let nodes_num = Ident.Hash.length worklist.dependency in + let dep_graph = Array.init nodes_num (fun _ -> Vec_int.empty ()) in + Ident.Hash.iter worklist.dependency (fun (_, (src_index, deps)) -> + Ident.Hashset.iter deps (fun d -> + match Ident.Hash.find_opt worklist.dependency d with + | Some (tgt_index, _) -> + Vec_int.push dep_graph.(src_index) tgt_index + | None -> ())); + let scc = Basic_scc.graph dep_graph in + Vec.iter (fun c -> + Vec_int.iter c (fun i -> + match Basic_hash_int.find_opt indexed_globals i with + | Some global -> Vec.push res global + | None -> ())) + scc; + res + : (Ident.t * Mcore.expr * bool * Loc.t) Vec.t) let add_any_to_string (worklist : t) (monofy_env : Monofy_env.t) (ty : Stype.t) = @@ -282,21 +289,22 @@ let add_any_to_string (worklist : t) (monofy_env : Monofy_env.t) (ty : Stype.t) let local_cache : (Method_env.method_info * Stype.t) Basic_vec.t = Basic_vec.empty () in - let resolve_by_type_path (tp : Type_path.t) : bool = - match Type_path.Hash.find_opt worklist.obj_to_string tp with - | Some (Some mi) -> - Basic_vec.push local_cache (mi, ty); - true - | Some None -> false - | None -> ( - match check_impl_show_trait ~monofy_env ~type_name:tp with - | Some mi -> - Basic_vec.push local_cache (mi, ty); - Type_path.Hash.add worklist.obj_to_string tp (Some mi); - true - | None -> - Type_path.Hash.add worklist.obj_to_string tp None; - false) + let resolve_by_type_path (tp : Type_path.t) = + (match Type_path.Hash.find_opt worklist.obj_to_string tp with + | Some (Some mi) -> + Basic_vec.push local_cache (mi, ty); + true + | Some None -> false + | None -> ( + match check_impl_show_trait ~monofy_env ~type_name:tp with + | Some mi -> + Basic_vec.push local_cache (mi, ty); + Type_path.Hash.add worklist.obj_to_string tp (Some mi); + true + | None -> + Type_path.Hash.add worklist.obj_to_string tp None; + false) + : bool) in let rec resolve_by_type (ty : Stype.t) = match ty with @@ -306,21 +314,22 @@ let add_any_to_string (worklist : t) (monofy_env : Monofy_env.t) (ty : Stype.t) | T_trait _ | Tarrow _ | Tvar _ | Tparam _ | T_blackhole -> false in if resolve_by_type ty then - Basic_vec.iter (fun ((mi: Method_env.method_info), ty) -> - add_value_if_not_exist worklist mi.id [| ty |] |> ignore) local_cache + Basic_vec.iter (fun ((mi : Method_env.method_info), ty) -> + ignore (add_value_if_not_exist worklist mi.id [| ty |])) + local_cache -let transl_any_to_string (worklist : t) (ty : Stype.t) : - (Ident.t * Primitive.prim option) option = - let ty = Stype.type_repr ty in - let resolve_by_type_path (tp : Type_path.t) = - match Type_path.Hash.find_opt worklist.obj_to_string tp with - | Some (Some mi) -> ( - match find_new_binder_opt worklist mi.id [| ty |] with - | Some id -> Some (id, mi.prim) - | None -> None) - | _ -> None - in - match ty with - | T_constr { type_constructor = tp; _ } -> resolve_by_type_path tp - | T_builtin b -> resolve_by_type_path (Stype.tpath_of_builtin b) - | T_trait _ | Tarrow _ | Tvar _ | Tparam _ | T_blackhole -> None +let transl_any_to_string (worklist : t) (ty : Stype.t) = + (let ty = Stype.type_repr ty in + let resolve_by_type_path (tp : Type_path.t) = + match Type_path.Hash.find_opt worklist.obj_to_string tp with + | Some (Some mi) -> ( + match find_new_binder_opt worklist mi.id [| ty |] with + | Some id -> Some (id, mi.prim) + | None -> None) + | _ -> None + in + match ty with + | T_constr { type_constructor = tp; _ } -> resolve_by_type_path tp + | T_builtin b -> resolve_by_type_path (Stype.tpath_of_builtin b) + | T_trait _ | Tarrow _ | Tvar _ | Tparam _ | T_blackhole -> None + : (Ident.t * Primitive.prim option) option) diff --git a/src/moon0_main.ml b/src/moon0_main.ml index ae2acba..efc1c4f 100644 --- a/src/moon0_main.ml +++ b/src/moon0_main.ml @@ -33,9 +33,12 @@ and shrink_wasm = Driver_config.Common_Opt.shrink_wasm and source_map = Driver_config.Common_Opt.source_map and source_map_url = Driver_config.Common_Opt.source_map_url and debug_tokens = Driver_config.Common_Opt.debug_tokens +and debug_segments = Driver_config.Common_Opt.debug_segments and contification = Driver_config.Common_Opt.contification and quiet = Driver_config.Common_Opt.quiet and no_intermediate_file = Driver_config.Common_Opt.no_intermediate_file +and enable_value_tracing = Driver_config.Common_Opt.enable_value_tracing + and is_main = Driver_config.Common_Opt.is_main let moonc_executable_name = "moonc" @@ -54,41 +57,51 @@ See s.ml for more about S-expressions. *) let write_s name sexp = if not !no_intermediate_file then Io.write_s name sexp -(** TAST stands for typed AST. *) -let tast_of_ast ~name ~build_context (asts : Parse.output list) : - Typedtree.output * Global_env.t = - let write_opt suffix sexp = write_s (name ^ suffix) sexp in - let export_tast tast = - write_opt ".typedtree" (Typedtree.sexp_of_output tast) - in - let std_import = Driver_util.Std_Path !Basic_config.std_path in - Driver_util.tast_of_ast ~diagnostics ~build_context ~imports:[] ~std_import - ~quiet:!quiet - ~genv_callback:(fun _ -> ()) - ~tast_callback:export_tast ~pkg_config:None ~import_kind:Normal asts +let tast_of_ast ~name ~build_context (asts : Parse.output list) = + (let write_opt suffix sexp = write_s (name ^ suffix) sexp in + let export_tast tast = + write_opt ".typedtree" (Typedtree.sexp_of_output tast) + in + let pkgs = Pkg.create_tbl () in + Pkg.load_std pkgs ~std_path:!Basic_config.std_path ~diagnostics; + Driver_util.tast_of_ast ~diagnostics ~build_context + ~import_items:Basic_map_string.empty ~import_kind:Normal ~pkgs + ~quiet:!quiet + ~genv_callback:(fun _ -> ()) + ~tast_callback:export_tast asts + : Typedtree.output * Global_env.t) let core_invariant_check ~global_env:_ _ir_name _core = () -let core_of_tast ~name genv (tast : Typedtree.output) : Core.program = - let core_callback ~global_env stage prog = - match stage with - | `Core_Inline_Single_Use_Join -> - core_invariant_check ~global_env "core+inline-single-use-join" prog - | `Core_Remove_Let_Alias -> - core_invariant_check ~global_env "core+remove-let-alias" prog - | `Core_Stackalloc -> - core_invariant_check ~global_env "core+stackalloc" prog - | `Core_Lambda_Lift -> - core_invariant_check ~global_env "core+lambda-lift" prog - | `Core_DCE -> core_invariant_check ~global_env "core+dce" prog - | `Core_Contify -> - write_s (name ^ ".core.contified") (Core.sexp_of_program prog); - core_invariant_check ~global_env "core+contify" prog - | `Core_Start -> () - | `Core_End -> () - in - Driver_util.core_of_tast ~debug:!Config.debug ~contification:!contification - ~genv ~tast ~core_callback +let core_of_tast ~name genv (tast : Typedtree.output) = + (let core_callback ~global_env stage prog = + match stage with + | `Core_Inline_Single_Use_Join -> + core_invariant_check ~global_env "core+inline-single-use-join" prog + | `Core_Remove_Let_Alias -> + core_invariant_check ~global_env "core+remove-let-alias" prog + | `Core_Stackalloc -> + core_invariant_check ~global_env "core+stackalloc" prog + | `Core_Unbox_Loop_Params -> + core_invariant_check ~global_env "core+unbox-loop-params" prog + | `Core_Propagate_Constr -> + core_invariant_check ~global_env "core+propagate-constr" prog + | `Core_Lambda_Lift -> + core_invariant_check ~global_env "core+lambda-lift" prog + | `Core_DCE -> core_invariant_check ~global_env "core+dce" prog + | `Core_Contify -> + write_s (name ^ ".core.contified") (Core.sexp_of_program prog); + core_invariant_check ~global_env "core+contify" prog + | `Core_Start -> + write_s (name ^ ".core.initial") (Core.sexp_of_program prog); + | `Core_no_async -> + write_s (name ^ ".core") (Core.sexp_of_program prog); + core_invariant_check ~global_env "core-noasync" prog + | `Core_End -> () + in + Driver_util.core_of_tast ~no_opt:!Config.no_opt ~contification:!contification + ~genv ~tast ~core_callback + : Core.program) let wasm_gen ~(name : string) c = let optimize_count = ref 0 in @@ -103,16 +116,23 @@ let wasm_gen ~(name : string) c = | `Clam_Unused_Let -> write_opt ".unused_let.clam" (Clam.sexp_of_prog clam) | `Clam_End -> write_s (name ^ ".o.clam") (Clam.sexp_of_prog clam) in - Driver_util.wasm_gen ~elim_unused_let:!elim_unused_let c ~clam_callback + let target = + match !Config.target with + | Wasm_gc -> + Driver_util.Wasm_gc { clam_callback; dwarfsm_callback = (fun _ -> ()) } + in + Driver_util.wasm_gen ~elim_unused_let:!elim_unused_let c ~target let source_loader ~pkg file = let path = Pkg_path_tbl.resolve_source Loc.pkg_path_tbl ~pkg ~file in let content = try Some (Io.load_file path) with _ -> None in (path, content) -let wasm_bin_gen ~file ~on_source_map (mod_ : Driver_util.wasm_rep) = +let wasm_bin_gen ~file ~on_source_map (mod_ : Dwarfsm_ast.module_) = let m = - match mod_ with Driver_util.Wat sexp -> Dwarfsm_parse.module_ sexp + if !Driver_config.Common_Opt.dedup_wasm then + Dwarfsm_elim_equivdefn.elim_equiv_defn mod_ + else mod_ in if !Config.debug then if !source_map then ( @@ -133,16 +153,20 @@ let wat_gen (sexp : W.t list) = (match sexp with | [] -> () | s :: ss -> - Buffer.add_string buf - (W.to_string - ~ignores: - [ "source_name"; "source_pos"; "source_type"; "prologue_end" ] - s); + Buffer.add_string buf (W.to_string s); List.iter (fun s -> Buffer.add_string buf "\n"; Buffer.add_string buf (W.to_string s)) ss); Buffer.contents buf +let wat_gen_from_module (mod_ : Dwarfsm_ast.module_) = + let ctx = Dwarfsm_encode_context.make_context () in + Dwarfsm_encode_resolve.resolve ctx mod_; + let output_buf = Buffer.create 1000 in + Buffer.add_string output_buf "(module"; + Buffer.add_string output_buf ")"; + Buffer.contents output_buf + let riscv_gen (sexp : Riscv.t list) = List.map Riscv.to_asm_string sexp |> String.concat "\n" @@ -196,23 +220,27 @@ let link_core () = let filename = !output_file in if Filename.check_suffix filename ".wat" then Io.write filename (wat_gen sexp) - else if Filename.check_suffix filename ".wasm" then - Io.write filename - (wasm_bin_gen ~file:filename ~on_source_map (Driver_util.Wat sexp)) - else raise (Arg.Bad ("unrecognized output file type: " ^ filename ^ "; must be one of .wat or .wasm")) + else raise (Arg.Bad ("unrecognized output file type: " ^ filename ^ "; must be one of .wat")) + in + let dwarfsm_callback dwarfsm = + match !output_file with + | "" -> + prerr_string "unspecified output file"; + exit 2 + | filename -> + if Filename.check_suffix filename ".wasm" then + Io.write filename (wasm_bin_gen ~file:filename ~on_source_map dwarfsm) + else prerr_string (filename ^ ": unrecognized file type") in - let riscv_gen_target sexp = (* No need to check file type as in wasm. *) (* We will write RISC-V assembly anyway. *) Io.write !output_file (riscv_gen sexp) in - - let target = match !Config.target with | Wasm_gc -> - Driver_util.Wasm_gc { clam_callback = (fun _ _ -> ()); sexp_callback = wasm_gen_target } + Driver_util.Wasm_gc { clam_callback = (fun _ _ -> ()); dwarfsm_callback } | Riscv -> Driver_util.Riscv { sexp_callback = riscv_gen_target } in @@ -225,6 +253,7 @@ let build_package () = let mi_files = Driver_config.Buildpkg_Opt.mi_files in let output_file = Driver_config.Buildpkg_Opt.output_file in let no_mi = Driver_config.Buildpkg_Opt.no_mi in + let patch_file = Driver_config.Buildpkg_Opt.patch_file in let blackbox_test = Driver_config.Buildpkg_Opt.blackbox_test in let whitebox_test = Driver_config.Buildpkg_Opt.whitebox_test in Compile_env.reset (); @@ -245,9 +274,15 @@ let build_package () = let mbt_files = List.map (fun path -> Driver_util.File_Path path) !input_files in - let profile_callback asts = asts in - let debug_source_callback _ _ = () + let patches = + if !patch_file = "" then [] + else Patch.parse_patch_from_file ~file_path:!patch_file + in + let tracing_callback asts = + if !enable_value_tracing then Value_tracing.instrument asts else asts in + let profile_callback asts = asts in + let debug_source_callback _file (_ast : Parse.output) = () in let genv_callback genv = if (not (Diagnostics.has_fatal_errors diagnostics)) && not !no_mi then let mi_path = Filename.remove_extension !output_file ^ ".mi" in @@ -263,9 +298,15 @@ let build_package () = core_invariant_check ~global_env "core+remove-let-alias" prog | `Core_Stackalloc -> core_invariant_check ~global_env "core+stackalloc" prog + | `Core_Unbox_Loop_Params -> + core_invariant_check ~global_env "core+unbox-loop-params" prog + | `Core_Propagate_Constr -> + core_invariant_check ~global_env "core+propagate-constr" prog | `Core_Lambda_Lift -> core_invariant_check ~global_env "core+lambda-lift" prog | `Core_DCE -> core_invariant_check ~global_env "core+dce" prog + | `Core_no_async -> + core_invariant_check ~global_env "core+eliminate-async" prog | `Core_Start -> () | `Core_End -> let core_path = Filename.remove_extension !output_file ^ ".core" in @@ -284,18 +325,20 @@ let build_package () = let import_kind : Pkg_config_util.import_kind = if !blackbox_test then Bbtest else if !whitebox_test then Wbtest else Normal in - Driver_util.build_package ~diagnostics ~std_import ~imports - ~debug_tokens:!debug_tokens ~debug:!Config.debug - ~contification:!contification ~is_main:!is_main ~quiet:!quiet - ~profile_callback ~debug_source_callback ~genv_callback ~tast_callback - ~core_callback ~pkg_config_file ~import_kind mbt_files - |> ignore + ignore + (Driver_util.build_package ~diagnostics ~std_import ~imports + ~debug_tokens:!debug_tokens ~no_opt:!Config.no_opt + ~contification:!contification ~is_main:!is_main ~quiet:!quiet + ~tracing_callback ~profile_callback ~debug_source_callback ~genv_callback + ~tast_callback ~core_callback ~pkg_config_file ~import_kind ~patches + mbt_files) let check () = let input_files = ref [] in let mi_files = Driver_config.Check_Opt.mi_files in let output_file = Driver_config.Check_Opt.output_file in let no_mi = Driver_config.Check_Opt.no_mi in + let patch_file = Driver_config.Check_Opt.patch_file in let blackbox_test = Driver_config.Check_Opt.blackbox_test in let whitebox_test = Driver_config.Check_Opt.whitebox_test in let check_spec = Driver_config.Check_Opt.spec in @@ -310,8 +353,14 @@ let check () = let output_dir = Filename.dirname !output_file in if not !no_mi then make_directory output_dir; let std_import = Driver_util.Std_Path !Basic_config.std_path in - let imports = List.map (fun imp -> Driver_util.Import_Path imp) !mi_files in - let mbt_files = List.map (fun path -> Driver_util.File_Path path) !input_files in + let imports = Lst.map !mi_files (fun imp -> Driver_util.Import_Path imp) in + let mbt_files = + Lst.map !input_files (fun path -> Driver_util.File_Path path) + in + let patches = + if !patch_file = "" then [] + else Patch.parse_patch_from_file ~file_path:!patch_file + in let genv_callback genv = if not !no_mi then Global_env.export_mi ~action:(Write_file !output_file) @@ -330,15 +379,16 @@ let check () = let import_kind : Pkg_config_util.import_kind = if !blackbox_test then Bbtest else if !whitebox_test then Wbtest else Normal in - Driver_util.check ~diagnostics ~std_import ~imports - ~debug_tokens:!debug_tokens ~is_main:!is_main ~quiet:!quiet ~genv_callback - ~tast_callback:(fun _ -> ()) - ~pkg_config_file ~import_kind mbt_files - |> ignore; + ignore + (Driver_util.check ~diagnostics ~std_import ~imports + ~debug_tokens:!debug_tokens ~is_main:!is_main ~quiet:!quiet + ~genv_callback + ~tast_callback:(fun _ -> ()) + ~patches ~pkg_config_file ~import_kind mbt_files); Diagnostics.check_diagnostics diagnostics let compile () = - let src = ref [] in + let src = Basic_vec_string.make 4 in let output_file = Driver_config.Compile_Opt.output_file in let extra_deps = Driver_config.Compile_Opt.extra_deps in let export_functions_info = Driver_config.Compile_Opt.export_functions_info in @@ -352,8 +402,9 @@ let compile () = Compile_env.reset (); Diagnostics.reset diagnostics; let ast = - Parse.parse ~diagnostics ~debug_tokens:!debug_tokens ~transform:false - name ~directive_handler:(fun directive -> + Parse.parse ~diagnostics ~debug_tokens:!debug_tokens + ~debug_segments:!debug_segments ~transform:false name + ~directive_handler:(fun directive -> match Basic_lst.assoc_str directive "build" with | None -> () | Some d -> @@ -362,102 +413,115 @@ let compile () = (Sys.executable_name :: String.split_on_char ' ' d) in (try Arg.parse_argv build_flags spec ignore "" - with Arg.Bad s -> prerr_endline s); - ()) + with Arg.Bad s -> prerr_string s); + if !Basic_config.verbose then prerr_endline ("compiling " ^ name)) in - let ast = - postprocess_ast ast |-> fun c -> - write_s (name ^ ".ast") (Parse.sexp_of_output c) - in - let ast = [ ast ] in - if !stop_after_parsing then ( - Diagnostics.check_diagnostics diagnostics; - raise_notrace Exit); - let tast, genv = tast_of_ast ~build_context:SingleFile ~name ast in - Diagnostics.check_diagnostics diagnostics; - if !stop_after_typing then raise_notrace Exit; - let program = core_of_tast ~name genv tast in - Basic_uuid.reset (); - let targets = Basic_vec.empty () in - !extra_deps - |> List.iter (fun filename -> - Basic_vec.push targets (Core_link.File_path filename)); - Basic_vec.push targets - (Core_link.Core_format - [| - { - program; - types = - Global_env.get_toplevel_types genv |> Typing_info.get_all_types; - traits = - Global_env.get_toplevel_types genv - |> Typing_info.get_all_traits; - methods = Global_env.get_method_env genv; - ext_methods = Global_env.get_ext_method_env genv; - pkg_name = !Basic_config.current_package; - }; - |]); - let link_output = Core_link.link ~targets in - let exported_functions = - match !export_functions_info with - | Some export -> export - | None -> Exported_functions.Export_all_pubs - in - let mono_core = - Driver_util.monofy_core_link ~link_output ~exported_functions - in - write_s (name ^ ".core.mono") (Mcore.sexp_of_t mono_core); - let on_source_map blob = Io.write (!output_file ^ ".map") blob in - let postprecess mod_ = - let mod_ = - match mod_ with - | Driver_util.Wat sexp -> - Driver_util.Wat - (if !shrink_wasm then Pass_shrink_wasm.shrink sexp else sexp) - in - let sexp = match mod_ with Driver_util.Wat sexp -> wat_gen sexp in - let write_wat_to filename = - Io.write filename sexp; - if !wat_stats then - let bin = wasm_bin_gen ~file:filename ~on_source_map mod_ in - let binary_size = Int.to_string (String.length bin) in - let statsfile = filename ^ ".stats" in - Io.write statsfile - (filename ^ ": binary size " ^ binary_size ^ " bytes") - in - match !output_file with - | "" -> - let filename = name ^ ".wat" in - write_wat_to filename - | filename -> - if Filename.check_suffix filename ".wat" then write_wat_to filename - else if Filename.check_suffix filename ".wasm" then - Io.write filename - (wasm_bin_gen ~file:filename ~on_source_map mod_) - else prerr_string (filename ^ ": unrecognized file type") - in - match !Config.target with - | Wasm_gc -> - let mod_ = wasm_gen ~name mono_core in - postprecess mod_ - | Riscv -> failwith "TODO" (* TODO *) + match[@warning "-fragile-match"] + if !enable_value_tracing then Value_tracing.instrument [ ast ] + else [ ast ] + with + | ast :: [] -> ( + let ast = + postprocess_ast ast |-> fun c -> + write_s (name ^ ".ast") (Parse.sexp_of_output c) + in + let ast = [ ast ] in + if !stop_after_parsing then ( + Diagnostics.check_diagnostics diagnostics; + raise_notrace Exit); + let tast, genv = tast_of_ast ~build_context:SingleFile ~name ast in + Diagnostics.check_diagnostics diagnostics; + if !stop_after_typing then raise_notrace Exit; + let program = core_of_tast ~name genv tast in + Basic_uuid.reset (); + let targets = Basic_vec.empty () in + Basic_lst.iter + ~f:(fun filename -> + Basic_vec.push targets (Core_link.File_path filename)) + !extra_deps; + Basic_vec.push targets + (Core_link.Core_format + [| + { + program; + types = + Array.append + (Global_env.all_local_types genv) + (Typing_info.get_all_types + (Global_env.get_toplevel_types genv)); + traits = + Typing_info.get_all_traits + (Global_env.get_toplevel_types genv); + methods = Global_env.get_method_env genv; + ext_methods = Global_env.get_ext_method_env genv; + pkg_name = !Basic_config.current_package; + }; + |]); + let link_output = Core_link.link ~targets in + let exported_functions = + match !export_functions_info with + | Some export -> export + | None -> Exported_functions.Export_all_pubs + in + let mono_core = + Driver_util.monofy_core_link ~link_output ~exported_functions + in + write_s (name ^ ".core.mono") (Mcore.sexp_of_t mono_core); + let on_source_map blob = Io.write (!output_file ^ ".map") blob in + let postprecess mod_ = + let mod_ = + if !shrink_wasm then Shrink_wasmir.shrink mod_ else mod_ + in + let sexp = wat_gen_from_module mod_ in + let write_wat_to filename = + Io.write filename sexp; + if !wat_stats then + let bin = wasm_bin_gen ~file:filename ~on_source_map mod_ in + let binary_size = Int.to_string (String.length bin) in + let statsfile = filename ^ ".stats" in + Io.write statsfile + (filename ^ ": binary size " ^ binary_size ^ " bytes") + in + match !output_file with + | "" -> + let filename = name ^ ".wat" in + write_wat_to filename + | filename -> + if Filename.check_suffix filename ".wat" then write_wat_to filename + else if Filename.check_suffix filename ".wasm" then + Io.write filename + (wasm_bin_gen ~file:filename ~on_source_map mod_) + else prerr_string (filename ^ ": unrecognized file type") + in + match !Config.target with + | Wasm_gc -> + let mod_ = wasm_gen ~name mono_core in + postprecess mod_ + | Riscv -> failwith "TODO" (* TODO *)) + | _ -> assert false with Exit -> () in Arg.parse_argv ~current:(ref 1) Sys.argv spec - (fun name -> src := name :: !src) + (fun name -> Basic_vec_string.push src name) compile_usage; - Basic_lst.rev_iter !src compile + Basic_vec_string.iter src compile let gen_test_info () = - let input_files = Basic_vec.make ~dummy:"" 7 in + let input_files = Basic_vec_string.make 7 in + let patch_file = Driver_config.Gentestinfo_Opt.patch_file in let json = Driver_config.Gentestinfo_Opt.json in Compile_env.reset (); Arg.parse_argv ~current:(ref 1) Sys.argv Driver_config.Gentestinfo_Opt.spec - (fun input_file -> Basic_vec.push input_files input_file) + (fun input_file -> Basic_vec_string.push input_files input_file) gen_test_info_usage; - Basic_vec.map_into_list input_files (fun path -> Driver_util.File_Path path) - |> Driver_util.gen_test_info ~diagnostics ~json:!json - |> print_string + let patches = + if !patch_file = "" then [] + else Patch.parse_patch_from_file ~file_path:!patch_file + in + print_string + (Driver_util.gen_test_info ~diagnostics ~json:!json ~patches + (Basic_vec_string.map_into_list input_files ~unorder:(fun path -> + Driver_util.File_Path path))) let subcommands = [ @@ -472,9 +536,8 @@ let subcommands = let print_help () = Printf.printf "Usage: %s subcommand\n" moonc_executable_name; Printf.printf "Available subcommands:\n"; - List.iter - (fun (name, help, _) -> Printf.printf " %s: %s\n" name help) - subcommands + Basic_lst.iter subcommands ~f:(fun (name, help, _) -> + Printf.printf " %s: %s\n" name help) let run_main () = let argv_len = Array.length Sys.argv in @@ -488,7 +551,7 @@ let run_main () = with | Some (_, _, command) -> let before, after = - Driver_compenv.moonc_internal_params () |> Driver_compenv.parse_args + Driver_compenv.parse_args (Driver_compenv.moonc_internal_params ()) in Driver_compenv.exec_args before; (try command () with diff --git a/src/moon_intrinsic.ml b/src/moon_intrinsic.ml index b677d08..cf15914 100644 --- a/src/moon_intrinsic.ml +++ b/src/moon_intrinsic.ml @@ -40,6 +40,13 @@ type t = | Array_unsafe_get | Array_set | Array_unsafe_set + | ArrayView_length + | ArrayView_unsafe_set + | ArrayView_unsafe_get + | ArrayView_unsafe_as_view + | BytesView_length + | BytesView_unsafe_get + | BytesView_unsafe_as_view include struct let _ = fun (_ : t) -> () @@ -70,34 +77,51 @@ include struct | Array_unsafe_get -> S.Atom "Array_unsafe_get" | Array_set -> S.Atom "Array_set" | Array_unsafe_set -> S.Atom "Array_unsafe_set" + | ArrayView_length -> S.Atom "ArrayView_length" + | ArrayView_unsafe_set -> S.Atom "ArrayView_unsafe_set" + | ArrayView_unsafe_get -> S.Atom "ArrayView_unsafe_get" + | ArrayView_unsafe_as_view -> S.Atom "ArrayView_unsafe_as_view" + | BytesView_length -> S.Atom "BytesView_length" + | BytesView_unsafe_get -> S.Atom "BytesView_unsafe_get" + | BytesView_unsafe_as_view -> S.Atom "BytesView_unsafe_as_view" : t -> S.t) let _ = sexp_of_t + let equal = (Stdlib.( = ) : t -> t -> bool) + let _ = equal end -let string_of_t (i : t) : string = - match i with - | Char_to_string -> "%char.to_string" - | F64_to_string -> "%f64.to_string" - | String_substring -> "%string.substring" - | FixedArray_join -> "%fixedarray.join" - | FixedArray_iter -> "%fixedarray.iter" - | FixedArray_iteri -> "%fixedarray.iteri" - | FixedArray_map -> "%fixedarray.map" - | FixedArray_fold_left -> "%fixedarray.fold_left" - | FixedArray_copy -> "%fixedarray.copy" - | FixedArray_fill -> "%fixedarray.fill" - | Iter_map -> "%iter.map" - | Iter_iter -> "%iter.iter" - | Iter_take -> "%iter.take" - | Iter_reduce -> "%iter.reduce" - | Iter_from_array -> "%iter.from_array" - | Iter_flat_map -> "%iter.flat_map" - | Iter_repeat -> "%iter.repeat" - | Iter_filter -> "%iter.filter" - | Iter_concat -> "%iter.concat" - | Array_length -> "%array.length" - | Array_get -> "%array.get" - | Array_unsafe_get -> "%array.unsafe_get" - | Array_set -> "%array.set" - | Array_unsafe_set -> "%array.unsafe_set" +let string_of_t (i : t) = + (match i with + | Char_to_string -> "%char.to_string" + | F64_to_string -> "%f64.to_string" + | String_substring -> "%string.substring" + | FixedArray_join -> "%fixedarray.join" + | FixedArray_iter -> "%fixedarray.iter" + | FixedArray_iteri -> "%fixedarray.iteri" + | FixedArray_map -> "%fixedarray.map" + | FixedArray_fold_left -> "%fixedarray.fold_left" + | FixedArray_copy -> "%fixedarray.copy" + | FixedArray_fill -> "%fixedarray.fill" + | Iter_map -> "%iter.map" + | Iter_iter -> "%iter.iter" + | Iter_take -> "%iter.take" + | Iter_reduce -> "%iter.reduce" + | Iter_from_array -> "%iter.from_array" + | Iter_flat_map -> "%iter.flat_map" + | Iter_repeat -> "%iter.repeat" + | Iter_filter -> "%iter.filter" + | Iter_concat -> "%iter.concat" + | Array_length -> "%array.length" + | Array_get -> "%array.get" + | Array_unsafe_get -> "%array.unsafe_get" + | Array_set -> "%array.set" + | Array_unsafe_set -> "%array.unsafe_set" + | ArrayView_length -> "%arrayview.length" + | ArrayView_unsafe_set -> "%arrayview.unsafe_set" + | ArrayView_unsafe_get -> "%arrayview.unsafe_get" + | ArrayView_unsafe_as_view -> "%arrayview.unsafe_as_view" + | BytesView_length -> "%bytesview.length" + | BytesView_unsafe_get -> "%bytesview.unsafe_get" + | BytesView_unsafe_as_view -> "%bytesview.unsafe_as_view" + : string) diff --git a/src/moon_sexp_conv.ml b/src/moon_sexp_conv.ml index 8b43831..ef93320 100644 --- a/src/moon_sexp_conv.ml +++ b/src/moon_sexp_conv.ml @@ -20,7 +20,7 @@ let default_string_of_float = let y = format_float "%.15G" x in if float_of_string y = x then y else format_float "%.17G" x) -let sexp_of_unit () : S.t = List [] +let sexp_of_unit () = (List [] : S.t) let sexp_of_bool b = S.Atom (string_of_bool b) let sexp_of_string str = S.Atom str let sexp_of_bytes bytes = S.Atom (Bytes.to_string bytes) @@ -32,21 +32,23 @@ let sexp_of_int64 n = S.Atom (Int64.to_string n) let sexp_of_ref sexp_of__a rf = sexp_of__a !rf let write_old_option_format = ref true -let sexp_of_option sexp_of__a s : S.t = - match s with - | Some x when !write_old_option_format -> List [ sexp_of__a x ] - | Some x -> List [ Atom "some"; sexp_of__a x ] - | None when !write_old_option_format -> List [] - | None -> Atom "none" - -let sexp_of_list sexp_of__a lst : S.t = - List (List.rev (List.rev_map sexp_of__a lst)) - -let sexp_of_array sexp_of__a ar : S.t = - let lst_ref = ref [] in - for i = Array.length ar - 1 downto 0 do - lst_ref := sexp_of__a ar.(i) :: !lst_ref - done; - List !lst_ref +let sexp_of_option sexp_of__a s = + (match s with + | Some x when !write_old_option_format -> List [ sexp_of__a x ] + | Some x -> List [ Atom "some"; sexp_of__a x ] + | None when !write_old_option_format -> List [] + | None -> Atom "none" + : S.t) + +let sexp_of_list sexp_of__a lst = + (List (List.rev (List.rev_map sexp_of__a lst)) : S.t) + +let sexp_of_array sexp_of__a ar = + (let lst_ref = ref [] in + for i = Array.length ar - 1 downto 0 do + lst_ref := sexp_of__a ar.(i) :: !lst_ref + done; + List !lst_ref + : S.t) let sexp_of_lazy_t sexp_of__a lv = sexp_of__a (Lazy.force lv) diff --git a/src/mtype.ml b/src/mtype.ml index 609acc4..e75eb1a 100644 --- a/src/mtype.ml +++ b/src/mtype.ml @@ -36,6 +36,8 @@ type t = | T_bool | T_unit | T_byte + | T_int16 + | T_uint16 | T_int64 | T_uint | T_uint64 @@ -45,6 +47,7 @@ type t = | T_bytes | T_optimized_option of { elem : t } | T_func of { params : t list; return : t } + | T_raw_func of { params : t list; return : t } | T_tuple of { tys : t list } | T_fixedarray of { elem : t } | T_constr of id @@ -55,67 +58,76 @@ type t = [@@warning "+4"] include struct + let _ = fun (_ : t) -> () + let rec sexp_of_t t = match t with - | T_int -> S.Atom "int" - | T_char -> S.Atom "char" - | T_bool -> S.Atom "bool" - | T_unit -> S.Atom "unit" - | T_byte -> S.Atom "byte" - | T_int64 -> S.Atom "int64" - | T_uint -> S.Atom "uint" - | T_uint64 -> S.Atom "uint64" - | T_float -> S.Atom "float" - | T_double -> S.Atom "double" - | T_string -> S.Atom "string" - | T_bytes -> S.Atom "bytes" + | T_int -> S.Atom "T_int" + | T_char -> S.Atom "T_char" + | T_bool -> S.Atom "T_bool" + | T_unit -> S.Atom "T_unit" + | T_byte -> S.Atom "T_byte" + | T_int16 -> S.Atom "T_int16" + | T_uint16 -> S.Atom "T_uint16" + | T_int64 -> S.Atom "T_int64" + | T_uint -> S.Atom "T_uint" + | T_uint64 -> S.Atom "T_uint64" + | T_float -> S.Atom "T_float" + | T_double -> S.Atom "T_double" + | T_string -> S.Atom "T_string" + | T_bytes -> S.Atom "T_bytes" | T_optimized_option { elem } -> - let x = [S.List [ S.Atom "elem"; sexp_of_t elem ]] in - S.List (S.Atom "optimized_option" :: x) - | T_func { params; return = ret } -> - let x = [S.List [ S.Atom "return"; sexp_of_t ret ]] in - let y = - S.List [ S.Atom "params"; Moon_sexp_conv.sexp_of_list sexp_of_t params ] :: x - in - S.List (S.Atom "func" :: y) + S.List [ S.Atom "T_optimized_option"; + S.List [ S.Atom "elem"; sexp_of_t elem ] ] + | T_func { params; return } -> + S.List [ S.Atom "T_func"; + S.List [ S.Atom "params"; Moon_sexp_conv.sexp_of_list sexp_of_t params ]; + S.List [ S.Atom "return"; sexp_of_t return ] ] + | T_raw_func { params; return } -> + S.List [ S.Atom "T_raw_func"; + S.List [ S.Atom "params"; Moon_sexp_conv.sexp_of_list sexp_of_t params ]; + S.List [ S.Atom "return"; sexp_of_t return ] ] | T_tuple { tys } -> - let x = - [S.List [ S.Atom "tys"; Moon_sexp_conv.sexp_of_list sexp_of_t tys ]] - in - S.List (S.Atom "tuple" :: x) + S.List [ S.Atom "T_tuple"; + S.List [ S.Atom "tys"; Moon_sexp_conv.sexp_of_list sexp_of_t tys ] ] | T_fixedarray { elem } -> - let x = [S.List [ S.Atom "elem"; sexp_of_t elem ]] in - S.List (S.Atom "fixedarray" :: x) + S.List [ S.Atom "T_fixedarray"; + S.List [ S.Atom "elem"; sexp_of_t elem ] ] | T_constr x -> - S.List [ S.Atom "constr"; sexp_of_id x ] + S.List [ S.Atom "T_constr"; sexp_of_id x ] | T_trait x -> - S.List [ S.Atom "trait"; sexp_of_id x ] + S.List [ S.Atom "T_trait"; sexp_of_id x ] | T_any { name } -> - let x = [S.List [ S.Atom "name"; sexp_of_id name ]] in - S.List (S.Atom "any" :: x) + S.List [ S.Atom "T_any"; + S.List [ S.Atom "name"; sexp_of_id name ] ] | T_maybe_uninit x -> - S.List [ S.Atom "maybe_uninit"; sexp_of_t x ] + S.List [ S.Atom "T_maybe_uninit"; sexp_of_t x ] | T_error_value_result { ok; err; id } -> - let x = [S.List [ S.Atom "id"; sexp_of_id id ]] in - let y = S.List [ S.Atom "err"; sexp_of_t err ] :: x in - let z = S.List [ S.Atom "ok"; sexp_of_t ok ] :: y in - S.List (S.Atom "error_value_result" :: z) + S.List [ S.Atom "T_error_value_result"; + S.List [ S.Atom "ok"; sexp_of_t ok ]; + S.List [ S.Atom "err"; sexp_of_t err ]; + S.List [ S.Atom "id"; sexp_of_id id ] ] + + let _ = sexp_of_t end let to_string (t: t) = sexp_of_t t |> S.to_string let is_numeric (t : t) = match t with - | T_unit | T_int | T_uint | T_char | T_bool | T_byte | T_int64 | T_uint64 - | T_float | T_double -> + | T_unit | T_int | T_uint | T_char | T_bool | T_byte | T_int16 | T_uint16 + | T_int64 | T_uint64 | T_float | T_double -> true | T_optimized_option { elem } -> ( match elem with - | T_char | T_bool | T_byte | T_unit | T_int | T_uint -> true + | T_char | T_bool | T_byte | T_unit | T_int | T_uint | T_int16 | T_uint16 + -> + true | T_int64 | T_uint64 | T_float | T_double | T_optimized_option _ | T_bytes - | T_string | T_func _ | T_tuple _ | T_fixedarray _ | T_maybe_uninit _ - | T_constr _ | T_trait _ | T_any _ | T_error_value_result _ -> + | T_string | T_func _ | T_raw_func _ | T_tuple _ | T_fixedarray _ + | T_maybe_uninit _ | T_constr _ | T_trait _ | T_any _ + | T_error_value_result _ -> false) - | T_bytes | T_string | T_func _ | T_tuple _ | T_fixedarray _ + | T_bytes | T_string | T_func _ | T_raw_func _ | T_tuple _ | T_fixedarray _ | T_maybe_uninit _ | T_constr _ | T_trait _ | T_any _ | T_error_value_result _ -> false @@ -126,12 +138,12 @@ include struct let sexp_of_field_name = (function - | Named arg0__031_ -> - let res0__032_ = Moon_sexp_conv.sexp_of_string arg0__031_ in - S.List [ S.Atom "Named"; res0__032_ ] - | Indexed arg0__033_ -> - let res0__034_ = Moon_sexp_conv.sexp_of_int arg0__033_ in - S.List [ S.Atom "Indexed"; res0__034_ ] + | Named arg0__036_ -> + let res0__037_ = Moon_sexp_conv.sexp_of_string arg0__036_ in + S.List [ S.Atom "Named"; res0__037_ ] + | Indexed arg0__038_ -> + let res0__039_ = Moon_sexp_conv.sexp_of_int arg0__038_ in + S.List [ S.Atom "Indexed"; res0__039_ ] : field_name -> S.t) end @@ -140,22 +152,23 @@ type field_info = { field_type : t; name : field_name; mut : bool } include struct let sexp_of_field_info = - (fun { field_type = field_type__036_; name = name__038_; mut = mut__040_ } -> - let bnds__035_ = ([] : _ Stdlib.List.t) in - let bnds__035_ = - let arg__041_ = Moon_sexp_conv.sexp_of_bool mut__040_ in - (S.List [ S.Atom "mut"; arg__041_ ] :: bnds__035_ : _ Stdlib.List.t) + (fun { field_type = field_type__041_; name = name__043_; mut = mut__045_ } + -> + let bnds__040_ = ([] : _ Stdlib.List.t) in + let bnds__040_ = + let arg__046_ = Moon_sexp_conv.sexp_of_bool mut__045_ in + (S.List [ S.Atom "mut"; arg__046_ ] :: bnds__040_ : _ Stdlib.List.t) in - let bnds__035_ = - let arg__039_ = sexp_of_field_name name__038_ in - (S.List [ S.Atom "name"; arg__039_ ] :: bnds__035_ : _ Stdlib.List.t) + let bnds__040_ = + let arg__044_ = sexp_of_field_name name__043_ in + (S.List [ S.Atom "name"; arg__044_ ] :: bnds__040_ : _ Stdlib.List.t) in - let bnds__035_ = - let arg__037_ = sexp_of_t field_type__036_ in - (S.List [ S.Atom "field_type"; arg__037_ ] :: bnds__035_ + let bnds__040_ = + let arg__042_ = sexp_of_t field_type__041_ in + (S.List [ S.Atom "field_type"; arg__042_ ] :: bnds__040_ : _ Stdlib.List.t) in - S.List bnds__035_ + S.List bnds__040_ : field_info -> S.t) end @@ -165,20 +178,20 @@ include struct let _ = fun (_ : constr_info) -> () let sexp_of_constr_info = - (fun { payload = payload__043_; tag = tag__045_ } -> - let bnds__042_ = ([] : _ Stdlib.List.t) in - let bnds__042_ = - let arg__046_ = Tag.sexp_of_t tag__045_ in - (S.List [ S.Atom "tag"; arg__046_ ] :: bnds__042_ : _ Stdlib.List.t) + (fun { payload = payload__048_; tag = tag__050_ } -> + let bnds__047_ = ([] : _ Stdlib.List.t) in + let bnds__047_ = + let arg__051_ = Tag.sexp_of_t tag__050_ in + (S.List [ S.Atom "tag"; arg__051_ ] :: bnds__047_ : _ Stdlib.List.t) in - let bnds__042_ = - let arg__044_ = - Moon_sexp_conv.sexp_of_list sexp_of_field_info payload__043_ + let bnds__047_ = + let arg__049_ = + Moon_sexp_conv.sexp_of_list sexp_of_field_info payload__048_ in - (S.List [ S.Atom "payload"; arg__044_ ] :: bnds__042_ + (S.List [ S.Atom "payload"; arg__049_ ] :: bnds__047_ : _ Stdlib.List.t) in - S.List bnds__042_ + S.List bnds__047_ : constr_info -> S.t) let _ = sexp_of_constr_info @@ -196,33 +209,34 @@ include struct let sexp_of_method_info = (fun { - params_ty = params_ty__048_; - return_ty = return_ty__050_; - index = index__052_; - name = name__054_; - } -> - let bnds__047_ = ([] : _ Stdlib.List.t) in - let bnds__047_ = - let arg__055_ = Moon_sexp_conv.sexp_of_string name__054_ in - (S.List [ S.Atom "name"; arg__055_ ] :: bnds__047_ : _ Stdlib.List.t) + params_ty = params_ty__053_; + return_ty = return_ty__055_; + index = index__057_; + name = name__059_; + } + -> + let bnds__052_ = ([] : _ Stdlib.List.t) in + let bnds__052_ = + let arg__060_ = Moon_sexp_conv.sexp_of_string name__059_ in + (S.List [ S.Atom "name"; arg__060_ ] :: bnds__052_ : _ Stdlib.List.t) in - let bnds__047_ = - let arg__053_ = Moon_sexp_conv.sexp_of_int index__052_ in - (S.List [ S.Atom "index"; arg__053_ ] :: bnds__047_ : _ Stdlib.List.t) + let bnds__052_ = + let arg__058_ = Moon_sexp_conv.sexp_of_int index__057_ in + (S.List [ S.Atom "index"; arg__058_ ] :: bnds__052_ : _ Stdlib.List.t) in - let bnds__047_ = - let arg__051_ = sexp_of_t return_ty__050_ in - (S.List [ S.Atom "return_ty"; arg__051_ ] :: bnds__047_ + let bnds__052_ = + let arg__056_ = sexp_of_t return_ty__055_ in + (S.List [ S.Atom "return_ty"; arg__056_ ] :: bnds__052_ : _ Stdlib.List.t) in - let bnds__047_ = - let arg__049_ = - Moon_sexp_conv.sexp_of_list sexp_of_t params_ty__048_ + let bnds__052_ = + let arg__054_ = + Moon_sexp_conv.sexp_of_list sexp_of_t params_ty__053_ in - (S.List [ S.Atom "params_ty"; arg__049_ ] :: bnds__047_ + (S.List [ S.Atom "params_ty"; arg__054_ ] :: bnds__052_ : _ Stdlib.List.t) in - S.List bnds__047_ + S.List bnds__052_ : method_info -> S.t) let _ = sexp_of_method_info @@ -244,38 +258,38 @@ include struct (function | Placeholder -> S.Atom "Placeholder" | Externref -> S.Atom "Externref" - | Variant { constrs = constrs__057_ } -> - let bnds__056_ = ([] : _ Stdlib.List.t) in - let bnds__056_ = - let arg__058_ = - Moon_sexp_conv.sexp_of_list sexp_of_constr_info constrs__057_ + | Variant { constrs = constrs__062_ } -> + let bnds__061_ = ([] : _ Stdlib.List.t) in + let bnds__061_ = + let arg__063_ = + Moon_sexp_conv.sexp_of_list sexp_of_constr_info constrs__062_ in - (S.List [ S.Atom "constrs"; arg__058_ ] :: bnds__056_ + (S.List [ S.Atom "constrs"; arg__063_ ] :: bnds__061_ : _ Stdlib.List.t) in - S.List (S.Atom "Variant" :: bnds__056_) + S.List (S.Atom "Variant" :: bnds__061_) | Variant_constr -> S.Atom "Variant_constr" | Constant_variant_constr -> S.Atom "Constant_variant_constr" - | Record { fields = fields__060_ } -> - let bnds__059_ = ([] : _ Stdlib.List.t) in - let bnds__059_ = - let arg__061_ = - Moon_sexp_conv.sexp_of_list sexp_of_field_info fields__060_ + | Record { fields = fields__065_ } -> + let bnds__064_ = ([] : _ Stdlib.List.t) in + let bnds__064_ = + let arg__066_ = + Moon_sexp_conv.sexp_of_list sexp_of_field_info fields__065_ in - (S.List [ S.Atom "fields"; arg__061_ ] :: bnds__059_ + (S.List [ S.Atom "fields"; arg__066_ ] :: bnds__064_ : _ Stdlib.List.t) in - S.List (S.Atom "Record" :: bnds__059_) - | Trait { methods = methods__063_ } -> - let bnds__062_ = ([] : _ Stdlib.List.t) in - let bnds__062_ = - let arg__064_ = - Moon_sexp_conv.sexp_of_list sexp_of_method_info methods__063_ + S.List (S.Atom "Record" :: bnds__064_) + | Trait { methods = methods__068_ } -> + let bnds__067_ = ([] : _ Stdlib.List.t) in + let bnds__067_ = + let arg__069_ = + Moon_sexp_conv.sexp_of_list sexp_of_method_info methods__068_ in - (S.List [ S.Atom "methods"; arg__064_ ] :: bnds__062_ + (S.List [ S.Atom "methods"; arg__069_ ] :: bnds__067_ : _ Stdlib.List.t) in - S.List (S.Atom "Trait" :: bnds__062_) + S.List (S.Atom "Trait" :: bnds__067_) : info -> S.t) let _ = sexp_of_info @@ -287,20 +301,20 @@ include struct let _ = fun (_ : defs) -> () let sexp_of_defs = - (fun { defs = defs__066_; ext_tags = ext_tags__068_ } -> - let bnds__065_ = ([] : _ Stdlib.List.t) in - let bnds__065_ = - let arg__069_ = - Hash_string.sexp_of_t Moon_sexp_conv.sexp_of_int ext_tags__068_ + (fun { defs = defs__071_; ext_tags = ext_tags__073_ } -> + let bnds__070_ = ([] : _ Stdlib.List.t) in + let bnds__070_ = + let arg__074_ = + Hash_string.sexp_of_t Moon_sexp_conv.sexp_of_int ext_tags__073_ in - (S.List [ S.Atom "ext_tags"; arg__069_ ] :: bnds__065_ + (S.List [ S.Atom "ext_tags"; arg__074_ ] :: bnds__070_ : _ Stdlib.List.t) in - let bnds__065_ = - let arg__067_ = Id_hash.sexp_of_t sexp_of_info defs__066_ in - (S.List [ S.Atom "defs"; arg__067_ ] :: bnds__065_ : _ Stdlib.List.t) + let bnds__070_ = + let arg__072_ = Id_hash.sexp_of_t sexp_of_info defs__071_ in + (S.List [ S.Atom "defs"; arg__072_ ] :: bnds__070_ : _ Stdlib.List.t) in - S.List bnds__065_ + S.List bnds__070_ : defs -> S.t) let _ = sexp_of_defs @@ -308,29 +322,31 @@ end let sexp_of_defs defs = if Hash_string.length defs.ext_tags = 0 then - (fun x__070_ -> Id_hash.sexp_of_t sexp_of_info x__070_) defs.defs + (fun x__075_ -> Id_hash.sexp_of_t sexp_of_info x__075_) defs.defs else sexp_of_defs defs let find_stype_exn (stype_defs : Typing_info.stype_defs) (pkg : string) - (id : string) : Typedecl_info.t = - let types = Hash_string.find_exn stype_defs pkg in - Typing_info.find_type_exn types id + (id : string) = + (let types = Hash_string.find_exn stype_defs pkg in + Typing_info.find_type_exn types id + : Typedecl_info.t) let find_trait_exn (stype_defs : Typing_info.stype_defs) (pkg : string) - (id : string) : Trait_decl.t = - let types = Hash_string.find_exn stype_defs pkg in - Typing_info.find_trait_exn types id + (id : string) = + (let types = Hash_string.find_exn stype_defs pkg in + Typing_info.find_trait_exn types id + : Trait_decl.t) let is_optimizable_option_elem t mtype_defs = match t with - | T_char | T_bool | T_int | T_uint | T_unit | T_byte | T_string | T_bytes - | T_tuple _ | T_fixedarray _ | T_trait _ -> + | T_char | T_bool | T_int | T_uint | T_unit | T_byte | T_int16 | T_uint16 + | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ -> true | T_constr id -> ( match Id_hash.find_opt mtype_defs id with | Some Externref -> false | None | Some _ -> true) - | T_int64 | T_uint64 | T_func _ -> false + | T_int64 | T_uint64 | T_func _ | T_raw_func _ -> false | T_float | T_double | T_any _ | T_optimized_option _ | T_maybe_uninit _ -> false | T_error_value_result _ -> false @@ -342,345 +358,415 @@ let make_suberror_mid pkg name = else Stdlib.String.concat "" [ error_mid; "."; pkg; "."; name ] let from_stype (stype : Stype.t) ~(stype_defs : Typing_info.stype_defs) - ~(mtype_defs : defs) : t = - let rec go (stype : Stype.t) : t = - let stype = Stype.type_repr stype in - match stype with - | T_builtin T_unit -> T_unit - | T_builtin T_bool -> T_bool - | T_builtin T_byte -> T_byte - | T_builtin T_char -> T_char - | T_builtin T_int -> T_int - | T_builtin T_int64 -> T_int64 - | T_builtin T_uint -> T_uint - | T_builtin T_uint64 -> T_uint64 - | T_builtin T_float -> T_float - | T_builtin T_double -> T_double - | T_builtin T_string -> T_string - | T_builtin T_bytes -> T_bytes - | Tarrow { params_ty; ret_ty; err_ty = None } -> - T_func { params = Lst.map params_ty go; return = go ret_ty } - | Tarrow { params_ty; ret_ty; err_ty = Some err_ty } -> - T_func - { - params = Lst.map params_ty go; - return = go (Stype.make_multi_value_result_ty ~ok_ty:ret_ty ~err_ty); - } - | T_constr - { - type_constructor = Toplevel { pkg; id }; - tys = []; - is_suberror_ = true; - } -> - let mid = make_suberror_mid pkg id in - (if not (Id_hash.mem mtype_defs.defs mid) then - let typedecl_info = find_stype_exn stype_defs pkg id in - add_type_def stype mid typedecl_info); - T_constr error_mid - | T_constr { type_constructor = T_error; _ } -> - (match Id_hash.find_opt mtype_defs.defs error_mid with - | None -> - Id_hash.add mtype_defs.defs error_mid (Variant { constrs = [] }) - | Some _ -> ()); - T_constr error_mid - | T_constr { type_constructor = T_option as c; tys = t :: [] } -> - let elem_ty = go t in - if is_optimizable_option_elem elem_ty mtype_defs.defs then - T_optimized_option { elem = elem_ty } - else - let type_name = - Type_path.export_name ~cur_pkg_name:!Basic_config.current_package c + ~(mtype_defs : defs) = + (let rec go (stype : Stype.t) = + (let stype = Stype.type_repr stype in + match stype with + | T_builtin T_unit -> T_unit + | T_builtin T_bool -> T_bool + | T_builtin T_byte -> T_byte + | T_builtin T_char -> T_char + | T_builtin T_int16 -> T_int16 + | T_builtin T_uint16 -> T_uint16 + | T_builtin T_int -> T_int + | T_builtin T_int64 -> T_int64 + | T_builtin T_uint -> T_uint + | T_builtin T_uint64 -> T_uint64 + | T_builtin T_float -> T_float + | T_builtin T_double -> T_double + | T_builtin T_string -> T_string + | T_builtin T_bytes -> T_bytes + | Tarrow { params_ty; ret_ty; err_ty; is_async = true } -> + let ret_ty = go ret_ty in + let cont_params = + match err_ty with + | None -> [ T_func { params = [ ret_ty ]; return = T_unit } ] + | Some err_ty -> + [ + T_func { params = [ ret_ty ]; return = T_unit }; + T_func { params = [ go err_ty ]; return = T_unit }; + ] + in + T_func + { + params = Lst.map_append params_ty cont_params go; + return = T_unit; + } + | Tarrow { params_ty; ret_ty; err_ty; is_async = false } -> + let return = + match err_ty with + | None -> go ret_ty + | Some err_ty -> + go (Stype.make_multi_value_result_ty ~ok_ty:ret_ty ~err_ty) in + T_func { params = Lst.map params_ty go; return } + | T_constr + { + type_constructor = Toplevel { pkg; id }; + tys = []; + is_suberror_ = true; + } -> + let mid = make_suberror_mid pkg id in + (if not (Id_hash.mem mtype_defs.defs mid) then + let typedecl_info = find_stype_exn stype_defs pkg id in + add_type_def stype mid typedecl_info); + T_constr error_mid + | T_constr { type_constructor = T_error; _ } -> + (match Id_hash.find_opt mtype_defs.defs error_mid with + | None -> + Id_hash.add mtype_defs.defs error_mid (Variant { constrs = [] }) + | Some _ -> ()); + T_constr error_mid + | T_constr { type_constructor = T_option; tys = t :: [] } -> + let elem_ty = go t in + if is_optimizable_option_elem elem_ty mtype_defs.defs then + T_optimized_option { elem = elem_ty } + else + let s = Type_args.mangle_ty stype in + if not (Id_hash.mem mtype_defs.defs s) then + add_type_def stype s Builtin.ty_constr_option; + T_constr s + | T_constr { type_constructor; tys = _ } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_foreach_result -> let s = Type_args.mangle_ty stype in - (if not (Id_hash.mem mtype_defs.defs s) then - match Typing_info.find_type Builtin.builtin_types type_name with - | Some typedecl_info -> add_type_def stype s typedecl_info - | None -> assert false); + if not (Id_hash.mem mtype_defs.defs s) then + add_type_def stype s Foreach_util.foreach_result; T_constr s - | T_constr { type_constructor; tys = _ } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_foreach_result -> - let s = Type_args.mangle_ty stype in - if not (Id_hash.mem mtype_defs.defs s) then - add_type_def stype s Foreach_util.foreach_result; - T_constr s - | T_constr { type_constructor; tys; only_tag_enum_; is_suberror_ } -> ( - let newtype_info = - match type_constructor with - | Tuple _ | T_unit | T_bool | T_byte | T_char | T_int | T_int64 - | T_uint | T_uint64 | T_float | T_double | T_string | T_option - | T_result | T_error_value_result | T_fixedarray | T_bytes | T_ref - | T_error | Constr _ -> - None - | Toplevel { pkg; id } -> ( - let typedecl_info = find_stype_exn stype_defs pkg id in - match typedecl_info.ty_desc with - | Extern_type | Abstract_type | Record_type _ | Variant_type _ - | Error_type _ | ErrorEnum_type _ -> - None - | New_type info -> Some info) - in - match newtype_info with - | Some { newtype_constr; recursive; _ } -> ( - if recursive then T_any { name = Type_args.mangle_ty stype } - else - let newtype_ty, newtype_ty_field = - Poly_type.instantiate_constr newtype_constr - in - Ctype.unify_exn newtype_ty stype; - match newtype_ty_field with t :: [] -> go t | _ -> assert false) - | None -> ( - if only_tag_enum_ then T_int - else - match type_constructor with - | T_int | T_char | T_bool | T_byte | T_unit | T_int64 | T_uint - | T_uint64 | T_float | T_double | T_bytes | T_string -> - assert false - | T_error -> T_constr error_mid - | T_fixedarray -> ( - match tys with - | elem_ty :: [] -> - let elem = go elem_ty in - if elem = T_byte then T_bytes else T_fixedarray { elem } - | [] | _ :: _ -> assert false) - | T_option | T_ref | T_result | T_error_value_result -> - let type_name = - Type_path.export_name - ~cur_pkg_name:!Basic_config.current_package - type_constructor - in - let s = Type_args.mangle_ty stype in - (if not (Id_hash.mem mtype_defs.defs s) then - match - Typing_info.find_type Builtin.builtin_types type_name - with - | Some typedecl_info -> add_type_def stype s typedecl_info - | None -> assert false); - if Type_path.is_multi_value_result type_constructor then - match tys with - | [ ok_ty; err_ty ] -> - T_error_value_result - { ok = go ok_ty; err = go err_ty; id = s } - | _ -> assert false - else T_constr s - | Tuple _ -> T_tuple { tys = Lst.map tys go } - | _ - when Type_path.equal type_constructor - Type_path.Builtin.type_path_sourceloc -> - T_string - | Toplevel { pkg; id = "UnsafeMaybeUninit" } - when pkg = Basic_config.builtin_package -> ( - match tys with - | t :: [] -> - let t = go t in - if is_numeric t then t else T_maybe_uninit t - | _ -> assert false) - | Toplevel { pkg; id } -> - let s = Type_args.mangle_ty stype in - if not (Id_hash.mem mtype_defs.defs s) then ( - let typedecl_info = find_stype_exn stype_defs pkg id in - match typedecl_info.ty_desc with - | Record_type { fields = [] } -> T_unit - | _ -> - add_type_def stype s typedecl_info; - T_constr s) - else T_constr s - | Constr - { - tag = - Extensible_tag - { pkg; type_name; name; total = _; index = _ }; - _; - } -> - let tag_str = - Basic_constr_info.ext_tag_to_str ~pkg ~type_name ~name - in - let mid = (error_mid ^ "." ^ tag_str : Stdlib.String.t) in - if not (Id_hash.mem mtype_defs.defs mid) then - Id_hash.add mtype_defs.defs mid Variant_constr; - let error_type_mid = make_suberror_mid pkg type_name in - (if not (Id_hash.mem mtype_defs.defs error_type_mid) then - let typedecl_info = - find_stype_exn stype_defs pkg type_name - in - add_type_def stype error_type_mid typedecl_info); - T_constr mid - | Constr - { ty; tag = Constr_tag_regular { name_; is_constant_; _ } } - -> ( - let enum_ty : Stype.t = - T_constr - { - type_constructor = ty; - tys; - generic_ = false; - only_tag_enum_ = false; - is_suberror_; - } - in - match go enum_ty with - | T_constr id -> - let id = id ^ "." ^ name_ in - Id_hash.replace mtype_defs.defs id - (if is_constant_ then Constant_variant_constr - else Variant_constr); - T_constr id - | T_error_value_result { id; ok; err } -> - let id = id ^ "." ^ name_ in - Id_hash.replace mtype_defs.defs id Variant_constr; - T_error_value_result { id; ok; err } - | ( T_int | T_char | T_bool | T_unit | T_byte | T_int64 - | T_uint | T_uint64 | T_float | T_double | T_string - | T_bytes | T_optimized_option _ | T_func _ | T_tuple _ - | T_fixedarray _ | T_trait _ | T_any _ | T_maybe_uninit _ ) - as ty -> - ty))) - | Tvar _ | Tparam _ | T_blackhole -> assert false - | T_trait type_path -> - let s = Type_args.mangle_ty stype in - (if not (Id_hash.mem mtype_defs.defs s) then - let trait_info = - match type_path with - | Toplevel { pkg; id } -> find_trait_exn stype_defs pkg id - | _ -> assert false - in - add_trait_def s trait_info); - T_trait s - and add_type_def (stype : Stype.t) (mid : id) (decl : Typedecl_info.t) = - Id_hash.add mtype_defs.defs mid Placeholder; - match decl.ty_desc with - | Extern_type -> Id_hash.replace mtype_defs.defs mid Externref - | Abstract_type | New_type _ -> () - | Error_type c -> ( - Id_hash.replace mtype_defs.defs mid Variant_constr; - let constr = - let tag = Tag.of_core_tag mtype_defs.ext_tags c.cs_tag in - let payload = - Lst.mapi c.cs_args (fun i ty -> - let field_type = go ty in - { field_type; name = Indexed i; mut = false }) + | T_constr { type_constructor; tys } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_func_ref -> ( + match[@warning "-fragile-match"] tys with + | func_ty :: [] -> ( + match go func_ty with + | T_func { params; return } -> T_raw_func { params; return } + | ( T_raw_func _ | T_int | T_char | T_bool | T_unit | T_byte + | T_int16 | T_uint16 | T_int64 | T_uint | T_uint64 | T_float + | T_double | T_string | T_bytes | T_constr _ + | T_optimized_option _ | T_tuple _ | T_fixedarray _ | T_trait _ + | T_any _ | T_maybe_uninit _ | T_error_value_result _ ) as ty -> + ty) + | _ -> assert false) + | T_constr { type_constructor; tys; is_suberror_ } -> ( + let handle_normal_type ~(pkg : string) id = + (let typedecl_info = find_stype_exn stype_defs pkg id in + match typedecl_info.ty_desc with + | _ when typedecl_info.ty_is_only_tag_enum_ -> T_int + | Record_type { fields = [] } -> T_unit + | Extern_type | Abstract_type | Record_type _ | Variant_type _ + | Error_type _ | ErrorEnum_type _ -> + let s = Type_args.mangle_ty stype in + if not (Id_hash.mem mtype_defs.defs s) then ( + add_type_def stype s typedecl_info; + T_constr s) + else T_constr s + | New_type { newtype_constr; recursive; underlying_typ = _ } -> ( + if recursive then T_any { name = Type_args.mangle_ty stype } + else + let newtype_ty, newtype_ty_field = + Poly_type.instantiate_constr newtype_constr + in + Ctype.unify_exn newtype_ty stype; + match[@warning "-fragile-match"] newtype_ty_field with + | t :: [] -> go t + | _ -> assert false) + : t) + [@@local] in - { payload; tag } - in - match Id_hash.find_opt mtype_defs.defs error_mid with - | None -> - Id_hash.add mtype_defs.defs error_mid - (Variant { constrs = [ constr ] }) - | Some (Variant { constrs = cs }) -> - Id_hash.replace mtype_defs.defs error_mid - (Variant { constrs = constr :: cs }) - | _ -> assert false) - | ErrorEnum_type cs -> ( - Id_hash.replace mtype_defs.defs mid Variant_constr; - let constrs = - Lst.map cs (fun c -> - let tag = Tag.of_core_tag mtype_defs.ext_tags c.cs_tag in - let arity = c.cs_arity_ in - let payload = - Fn_arity.to_list_map2 arity c.cs_args (fun param_kind ty -> - let field_type = go ty in - match param_kind with - | Labelled { label; is_mut = mut; _ } -> - { field_type; name = Named label; mut } - | Positional index -> - { field_type; name = Indexed index; mut = false } - | Optional _ | Autofill _ | Question_optional _ -> - assert false) + match type_constructor with + | T_int | T_char | T_bool | T_byte | T_unit | T_int16 | T_uint16 + | T_int64 | T_uint | T_uint64 | T_float | T_double | T_bytes + | T_string -> + assert false + | T_error -> T_constr error_mid + | T_fixedarray -> ( + match[@warning "-fragile-match"] tys with + | elem_ty :: [] -> + let elem = go elem_ty in + if elem = T_byte then T_bytes else T_fixedarray { elem } + | _ -> assert false) + | T_option | T_ref | T_result | T_error_value_result -> + let type_name = + Type_path.export_name + ~cur_pkg_name:!Basic_config.current_package + type_constructor in - { payload; tag }) - in - match Id_hash.find_opt mtype_defs.defs error_mid with - | None -> Id_hash.add mtype_defs.defs error_mid (Variant { constrs }) - | Some (Variant { constrs = cs }) -> - Id_hash.replace mtype_defs.defs error_mid - (Variant { constrs = constrs @ cs }) - | _ -> assert false) - | Record_type { fields = fs } -> - let _, fs' = - Poly_type.instantiate_record ~ty_record:(`Known stype) fs - in - let fields = - Lst.map fs' (fun f -> + let s = Type_args.mangle_ty stype in + (if not (Id_hash.mem mtype_defs.defs s) then + match[@warning "-fragile-match"] + Typing_info.find_type Builtin.builtin_types type_name + with + | Some typedecl_info -> add_type_def stype s typedecl_info + | _ -> assert false); + if Type_path.is_multi_value_result type_constructor then + match[@warning "-fragile-match"] tys with + | [ ok_ty; err_ty ] -> + T_error_value_result + { ok = go ok_ty; err = go err_ty; id = s } + | _ -> assert false + else T_constr s + | Tuple _ -> T_tuple { tys = Lst.map tys go } + | _ + when Type_path.equal type_constructor + Type_path.Builtin.type_path_sourceloc -> + T_string + | Toplevel { pkg; id = "UnsafeMaybeUninit" } + when pkg = Basic_config.builtin_package -> ( + match[@warning "-fragile-match"] tys with + | t :: [] -> + let t = go t in + if is_numeric t then t else T_maybe_uninit t + | _ -> assert false) + | T_local { toplevel_id; name } -> + handle_normal_type + ~pkg:(Type_path.pkg_of_toplevel_id toplevel_id) + (Local_type.mangle_name toplevel_id name) + | Toplevel { pkg; id } -> handle_normal_type ~pkg id + | Constr { - field_type = go f.ty_field; - name = Named f.field_name; - mut = f.mut; - }) - in - Id_hash.replace mtype_defs.defs mid (Record { fields }) - | Variant_type cs -> - let constrs = - Lst.map cs (fun c -> - let tag = Tag.of_core_tag_no_ext c.cs_tag in - let arity = c.cs_arity_ in - let enum_ty, constr_tys = Poly_type.instantiate_constr c in - Ctype.unify_exn stype enum_ty; - let payload = - Fn_arity.to_list_map2 arity constr_tys (fun param_kind ty -> - let field_type = go ty in - match param_kind with - | Labelled { label; is_mut = mut; _ } -> - { field_type; name = Named label; mut } - | Positional index -> - { field_type; name = Indexed index; mut = false } - | Optional _ | Autofill _ | Question_optional _ -> - assert false) + tag = + Extensible_tag { pkg; type_name; name; total = _; index = _ }; + _; + } -> + let tag_str = + Basic_constr_info.ext_tag_to_str ~pkg ~type_name ~name in - { payload; tag }) - in - Id_hash.replace mtype_defs.defs mid (Variant { constrs }) - and add_trait_def (mid : id) (decl : Trait_decl.t) = - Id_hash.add mtype_defs.defs mid Placeholder; - let methods = - Lst.mapi decl.closure_methods (fun i (_, m) -> - match m.method_typ with - | Stype.Tarrow { params_ty = _ :: params_ty; ret_ty; err_ty } -> - let params_ty = Lst.map params_ty go in - let return_ty = - match err_ty with - | None -> go ret_ty - | Some err_ty -> - go (Stype.make_multi_value_result_ty ~ok_ty:ret_ty ~err_ty) + let mid = + ((error_mid ^ "." ^ tag_str : Stdlib.String.t) [@merlin.hide]) in - { params_ty; return_ty; index = i; name = m.method_name } - | _ -> assert false) - in - Id_hash.replace mtype_defs.defs mid (Trait { methods }) - in - go stype - -let get_constr_tid_exn (t : t) : id = - match t with - | T_constr tid -> tid - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_optimized_option _ | T_func _ - | T_tuple _ | T_fixedarray _ | T_trait _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> - assert false - -let is_func (t : t) : bool = - match t with - | T_func _ -> true - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_constr _ | T_optimized_option _ - | T_tuple _ | T_fixedarray _ | T_trait _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> - false - -let get_fixedarray_elem_exn (t : t) : t = - match t with - | T_fixedarray { elem } -> elem - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_constr _ | T_optimized_option _ - | T_tuple _ | T_trait _ | T_func _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> - assert false - -let is_uninit (t : t) : bool = - match t with - | T_maybe_uninit _ -> true - | T_func _ | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint - | T_uint64 | T_float | T_double | T_string | T_bytes | T_constr _ - | T_optimized_option _ | T_tuple _ | T_fixedarray _ | T_trait _ | T_any _ - | T_error_value_result _ -> - false + if not (Id_hash.mem mtype_defs.defs mid) then + Id_hash.add mtype_defs.defs mid Variant_constr; + let error_type_mid = make_suberror_mid pkg type_name in + (if not (Id_hash.mem mtype_defs.defs error_type_mid) then + let typedecl_info = find_stype_exn stype_defs pkg type_name in + add_type_def stype error_type_mid typedecl_info); + T_constr mid + | Constr { ty; tag = Constr_tag_regular { name_; repr_; _ } } -> ( + let enum_ty : Stype.t = + T_constr + { type_constructor = ty; tys; generic_ = false; is_suberror_ } + in + match go enum_ty with + | T_constr id -> + let id = id ^ "." ^ name_ in + Id_hash.replace mtype_defs.defs id + (match repr_ with + | Constant -> Constant_variant_constr + | Non_constant -> Variant_constr + | Integer _ -> assert false); + T_constr id + | T_error_value_result { id; ok; err } -> + let id = id ^ "." ^ name_ in + Id_hash.replace mtype_defs.defs id Variant_constr; + T_error_value_result { id; ok; err } + | ( T_int | T_char | T_bool | T_unit | T_byte | T_int16 | T_uint16 + | T_int64 | T_uint | T_uint64 | T_float | T_double | T_string + | T_bytes | T_optimized_option _ | T_func _ | T_raw_func _ + | T_tuple _ | T_fixedarray _ | T_trait _ | T_any _ + | T_maybe_uninit _ ) as ty -> + ty)) + | Tparam _ -> assert false + | Tvar _ -> assert false + | T_blackhole -> assert false + | T_trait type_path -> + let s = Type_args.mangle_ty stype in + (if not (Id_hash.mem mtype_defs.defs s) then + match[@warning "-fragile-match"] type_path with + | Toplevel { pkg; id } -> + let trait_info = find_trait_exn stype_defs pkg id in + add_trait_def s trait_info + | _ -> assert false); + T_trait s + : t) + and add_type_def (stype : Stype.t) (mid : id) (decl : Typedecl_info.t) = + Id_hash.add mtype_defs.defs mid Placeholder; + match decl.ty_desc with + | Extern_type -> Id_hash.replace mtype_defs.defs mid Externref + | Abstract_type | New_type _ -> () + | Error_type c -> ( + Id_hash.replace mtype_defs.defs mid Variant_constr; + let constr = + let tag = Tag.of_core_tag mtype_defs.ext_tags c.cs_tag in + let payload = + Lst.mapi c.cs_args (fun i ty -> + let field_type = go ty in + { field_type; name = Indexed i; mut = false }) + in + { payload; tag } + in + match Id_hash.find_opt mtype_defs.defs error_mid with + | None -> + Id_hash.add mtype_defs.defs error_mid + (Variant { constrs = [ constr ] }) + | Some (Variant { constrs = cs }) -> + Id_hash.replace mtype_defs.defs error_mid + (Variant { constrs = constr :: cs }) + | _ -> assert false) + | ErrorEnum_type cs -> ( + Id_hash.replace mtype_defs.defs mid Variant_constr; + let constrs = + Lst.map cs (fun c -> + let tag = Tag.of_core_tag mtype_defs.ext_tags c.cs_tag in + let arity = c.cs_arity_ in + let payload = + Fn_arity.to_list_map2 arity c.cs_args (fun param_kind -> + fun ty -> + let field_type = go ty in + match param_kind with + | Labelled { label; is_mut = mut; _ } -> + { field_type; name = Named label; mut } + | Positional index -> + { + field_type; + name = Indexed index; + mut = false; + } + | Optional _ | Autofill _ | Question_optional _ -> + assert false) + in + { payload; tag }) + in + match Id_hash.find_opt mtype_defs.defs error_mid with + | None -> Id_hash.add mtype_defs.defs error_mid (Variant { constrs }) + | Some (Variant { constrs = cs }) -> + Id_hash.replace mtype_defs.defs error_mid + (Variant { constrs = constrs @ cs }) + | _ -> assert false) + | Record_type { fields = fs } -> + let _, fs' = + Poly_type.instantiate_record ~ty_record:(`Known stype) fs + in + let fields = + Lst.map fs' (fun f -> + { + field_type = go f.ty_field; + name = Named f.field_name; + mut = f.mut; + }) + in + Id_hash.replace mtype_defs.defs mid (Record { fields }) + | Variant_type cs -> + let constrs = + Lst.map cs (fun c -> + let tag = Tag.of_core_tag_no_ext c.cs_tag in + let arity = c.cs_arity_ in + let enum_ty, constr_tys = Poly_type.instantiate_constr c in + Ctype.unify_exn stype enum_ty; + let payload = + Fn_arity.to_list_map2 arity constr_tys (fun param_kind -> + fun ty -> + let field_type = go ty in + match param_kind with + | Labelled { label; is_mut = mut; _ } -> + { field_type; name = Named label; mut } + | Positional index -> + { + field_type; + name = Indexed index; + mut = false; + } + | Optional _ | Autofill _ | Question_optional _ -> + assert false) + in + { payload; tag }) + in + Id_hash.replace mtype_defs.defs mid (Variant { constrs }) + and add_trait_def (mid : id) (decl : Trait_decl.t) = + Id_hash.add mtype_defs.defs mid Placeholder; + let methods = + Lst.mapi decl.closure_methods (fun i -> + fun (_, m) -> + match m.method_typ with + | Stype.Tarrow + { params_ty = _ :: params_ty; ret_ty; err_ty; is_async = false } + -> + let params_ty = Lst.map params_ty go in + let return_ty = + match err_ty with + | None -> go ret_ty + | Some err_ty -> + go + (Stype.make_multi_value_result_ty ~ok_ty:ret_ty ~err_ty) + in + { params_ty; return_ty; index = i; name = m.method_name } + | _ -> assert false) + in + Id_hash.replace mtype_defs.defs mid (Trait { methods }) + in + go stype + : t) + +let is_func (t : t) = + (match t with + | T_func _ -> true + | T_raw_func _ | T_int | T_char | T_bool | T_unit | T_byte | T_int16 + | T_uint16 | T_int64 | T_uint | T_uint64 | T_float | T_double | T_string + | T_bytes | T_constr _ | T_optimized_option _ | T_tuple _ | T_fixedarray _ + | T_trait _ | T_any _ | T_maybe_uninit _ | T_error_value_result _ -> + false + : bool) + +let get_fixedarray_elem_exn (t : t) = + (match t with + | T_fixedarray { elem } -> elem + | T_maybe_uninit _ -> assert false + | T_raw_func _ -> assert false + | T_trait _ -> assert false + | T_optimized_option _ -> assert false + | T_bytes -> assert false + | T_double -> assert false + | T_uint64 -> assert false + | T_int64 -> assert false + | T_int16 -> assert false + | T_unit -> assert false + | T_char -> assert false + | T_int -> assert false + | T_bool -> assert false + | T_byte -> assert false + | T_uint16 -> assert false + | T_uint -> assert false + | T_float -> assert false + | T_string -> assert false + | T_constr _ -> assert false + | T_tuple _ -> assert false + | T_func _ -> assert false + | T_any _ -> assert false + | T_error_value_result _ -> assert false + : t) + +let is_uninit (t : t) = + (match t with + | T_maybe_uninit _ -> true + | T_func _ | T_raw_func _ | T_int | T_char | T_bool | T_unit | T_byte + | T_int16 | T_uint16 | T_int64 | T_uint | T_uint64 | T_float | T_double + | T_string | T_bytes | T_constr _ | T_optimized_option _ | T_tuple _ + | T_fixedarray _ | T_trait _ | T_any _ | T_error_value_result _ -> + false + : bool) + +type optimized_option_kind = + | Not_optimized + | Optimized_to_int + | Optimized_to_int64 + | Optimized_ref + +let get_optimized_option_kind (t : t) = + (match t with + | T_optimized_option { elem } -> ( + match elem with + | T_char | T_byte | T_bool | T_unit | T_int16 | T_uint16 -> + Optimized_to_int + | T_int | T_uint -> Optimized_to_int64 + | T_int64 | T_uint64 | T_func _ | T_raw_func _ -> assert false + | T_float | T_double | T_any _ | T_optimized_option _ | T_maybe_uninit _ + | T_error_value_result _ -> + assert false + | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ + | T_constr _ -> + Optimized_ref) + | T_char | T_byte | T_int16 | T_uint16 | T_bool | T_unit | T_int | T_uint + | T_int64 | T_uint64 | T_float | T_double | T_string | T_bytes | T_func _ + | T_raw_func _ | T_tuple _ | T_fixedarray _ | T_constr _ | T_trait _ + | T_any _ | T_maybe_uninit _ | T_error_value_result _ -> + Not_optimized + : optimized_option_kind) diff --git a/src/name_mangle.ml b/src/name_mangle.ml index ef0a403..1d30872 100644 --- a/src/name_mangle.ml +++ b/src/name_mangle.ml @@ -15,62 +15,78 @@ module Tid = Basic_ty_ident -let make_type_name (t : Mtype.t) : Tid.t = - let buf = Buffer.create 16 in - let ( +> ) = Buffer.add_char in - let ( +>> ) = Buffer.add_string in - let rec go (ty : Mtype.t) = - match ty with - | T_int -> buf +>> "Int" - | T_char -> buf +>> "Char" - | T_bool -> buf +>> "Bool" - | T_unit -> buf +>> "Unit" - | T_byte -> buf +>> "Byte" - | T_int64 -> buf +>> "Int64" - | T_uint -> buf +>> "UInt" - | T_uint64 -> buf +>> "UInt64" - | T_float -> buf +>> "Float" - | T_double -> buf +>> "Double" - | T_string -> buf +>> "String" - | T_bytes -> buf +>> "Bytes" - | T_optimized_option { elem = T_char } -> buf +>> "Option" - | T_optimized_option { elem } -> - buf +>> "Option<"; - go elem; - buf +>> ">" - | T_func { params; return } -> - buf +> '<'; - (match params with [] -> () | ty :: [] -> go ty | tys -> gos '*' tys); - buf +> '>'; - buf +>> "=>"; - go return - | T_tuple { tys } -> - buf +> '<'; - gos '*' tys; - buf +> '>' - | T_fixedarray { elem } -> - buf +>> "FixedArray<"; - go elem; - buf +>> ">" - | T_constr id -> buf +>> Mtype.id_to_string id - | T_trait id -> buf +>> Mtype.id_to_string id - | T_any { name } -> buf +>> Mtype.id_to_string name - | T_maybe_uninit t -> - buf +>> "UnsafeMaybeUninit<"; - go t; - buf +>> ">" - | T_error_value_result { id } -> - buf +>> Mtype.id_to_string id - and gos (sep : char) = function - | [] -> () - | ty :: [] -> go ty - | ty :: tys -> - go ty; - buf +> sep; - gos sep tys - in - go t; - Tid.of_string (Buffer.contents buf) +let make_type_name (t : Mtype.t) = + (let buf = Buffer.create 16 in + let ( +> ) = Buffer.add_char in + let ( +>> ) = Buffer.add_string in + let rec go (ty : Mtype.t) = + match ty with + | T_int -> buf +>> "Int" + | T_char -> buf +>> "Char" + | T_bool -> buf +>> "Bool" + | T_unit -> buf +>> "Unit" + | T_byte -> buf +>> "Byte" + | T_int16 -> buf +>> "Int16" + | T_uint16 -> buf +>> "UInt16" + | T_int64 -> buf +>> "Int64" + | T_uint -> buf +>> "UInt" + | T_uint64 -> buf +>> "UInt64" + | T_float -> buf +>> "Float" + | T_double -> buf +>> "Double" + | T_string -> buf +>> "String" + | T_bytes -> buf +>> "Bytes" + | T_optimized_option { elem = T_char } -> buf +>> "Option" + | T_optimized_option { elem } -> + buf +>> "Option<"; + go elem; + buf +>> ">" + | T_func { params; return } -> + buf +> '<'; + (match params with [] -> () | ty :: [] -> go ty | tys -> gos '*' tys); + buf +> '>'; + buf +>> "=>"; + go return + | T_raw_func { params; return } -> + buf +>> "RawFunction<"; + (match params with [] -> () | ty :: [] -> go ty | tys -> gos '*' tys); + buf +> '>'; + buf +>> "=>"; + go return + | T_tuple { tys } -> + buf +> '<'; + gos '*' tys; + buf +> '>' + | T_fixedarray { elem } -> + buf +>> "FixedArray<"; + go elem; + buf +>> ">" + | T_constr id -> buf +>> Mtype.id_to_string id + | T_trait id -> buf +>> Mtype.id_to_string id + | T_any { name } -> buf +>> Mtype.id_to_string name + | T_maybe_uninit t -> + buf +>> "UnsafeMaybeUninit<"; + go t; + buf +>> ">" + | T_error_value_result { ok; err; id } -> + buf +>> "Result<"; + go ok; + buf +> ','; + go err; + buf +>> ">"; + (match !Basic_config.target with + | Wasm_gc -> buf +>> Mtype.id_to_string id + | Riscv -> ()) + and gos (sep : char) = function + | [] -> () + | ty :: [] -> go ty + | ty :: tys -> + go ty; + buf +> sep; + gos sep tys + in + go t; + Tid.of_string (Buffer.contents buf) + : Tid.t) -let make_constr_name (enum_name : Tid.t) (tag : Tag.t) : Tid.t = - Tid.of_string (Tid.to_string enum_name ^ "." ^ tag.name_) +let make_constr_name (enum_name : Tid.t) (tag : Tag.t) = + (Tid.of_string (Tid.to_string enum_name ^ "." ^ tag.name_) : Tid.t) \ No newline at end of file diff --git a/src/object_util.ml b/src/object_util.ml index a573746..3ff6825 100644 --- a/src/object_util.ml +++ b/src/object_util.ml @@ -58,16 +58,6 @@ let sexp_of_object_method_item { method_id; method_prim; method_ty; } = let x = S.List [ S.Atom "method_id"; Ident.sexp_of_t method_id ] :: x in S.List x -let get_trait_methods ~(trait : Type_path.t) ~stype_defs = - let trait = - match trait with - | Toplevel { pkg; id } -> - let types = Basic_hash_string.find_exn stype_defs pkg in - Typing_info.find_trait_exn types id - | _ -> assert false - in - trait.closure_methods - type object_info = { self_ty : Mtype.t; methods : object_method_item list } let sexp_of_object_info = diff --git a/src/parsing_ast_lint.ml b/src/parsing_ast_lint.ml index 8b31bc7..31896f3 100644 --- a/src/parsing_ast_lint.ml +++ b/src/parsing_ast_lint.ml @@ -23,11 +23,16 @@ module Longident = Basic_longident let add_error = Local_diagnostics.add_error let add_global_error = Diagnostics.add_error +let add_warning = Local_diagnostics.add_warning -let warn_unused_tvars diagnostics map = - Map_string.iter map (fun name loc -> - Local_diagnostics.add_warning diagnostics - { loc; kind = Warnings.Unused_tvar name }) +let warn_unused_tvars diagnostics ~is_error map = + Map_string.iter map (fun name -> + fun loc -> + if is_error then + Local_diagnostics.add_error diagnostics (Errors.unused_tvar ~name ~loc) + else + Local_diagnostics.add_warning diagnostics + { loc; kind = Warnings.Unused_tvar name }) type ctx = { type_vis : Syntax.visibility; @@ -37,22 +42,24 @@ type ctx = { } let tvar_list_to_map ~diagnostics (l : Syntax.tvar_binder list) = - Lst.fold_left l Map_string.empty (fun map { tvar_name; loc_; _ } -> - if Map_string.mem map tvar_name then ( - add_error diagnostics (Errors.duplicate_tvar ~name:tvar_name ~loc:loc_); - map) - else Map_string.add map tvar_name loc_) + Lst.fold_left l Map_string.empty (fun map -> + fun { tvar_name; loc_; _ } -> + if Map_string.mem map tvar_name then ( + add_error diagnostics (Errors.duplicate_tvar ~name:tvar_name ~loc:loc_); + map) + else Map_string.add map tvar_name loc_) let tvar_option_list_to_map ~diagnostics (l : Syntax.type_decl_binder list) = - Lst.fold_left l Map_string.empty (fun map { tvar_name; loc_; _ } -> - match tvar_name with - | Some tvar_name -> - if Map_string.mem map tvar_name then ( - add_error diagnostics - (Errors.duplicate_tvar ~name:tvar_name ~loc:loc_); - map) - else Map_string.add map tvar_name loc_ - | None -> map) + Lst.fold_left l Map_string.empty (fun map -> + fun { tvar_name; loc_; _ } -> + match tvar_name with + | Some tvar_name -> + if Map_string.mem map tvar_name then ( + add_error diagnostics + (Errors.duplicate_tvar ~name:tvar_name ~loc:loc_); + map) + else Map_string.add map tvar_name loc_ + | None -> map) let type_name_is_reserved = function "Self" | "Error" -> true | _ -> false @@ -62,21 +69,30 @@ let syntax_check ~diagnostics impls = object (self) inherit [_] Syntax.iter as super - method! visit_Pexpr_sequence ctx expr1 expr2 _ = - self#visit_expr ctx expr1; - self#visit_expr ctx expr2; - match expr1 with - | Pexpr_return _ | Pexpr_break _ | Pexpr_continue _ -> - Local_diagnostics.add_warning ctx.diagnostics - { - kind = Warnings.Unreachable; - loc = Syntax.loc_of_expression expr2; - } - | _ -> () + method! visit_Pexpr_sequence ctx exprs last_expr _ = + Lst.iter exprs ~f:(self#visit_expr ctx); + self#visit_expr ctx last_expr; + let rec report_unreachable_expr = function + | (Syntax.Pexpr_return _ | Pexpr_break _ | Pexpr_continue _) :: exprs + -> + let loc = + match exprs with + | e :: _ -> + Rloc.merge + (Syntax.loc_of_expression e) + (Syntax.loc_of_expression last_expr) + | [] -> Syntax.loc_of_expression last_expr + in + Local_diagnostics.add_warning ctx.diagnostics + { kind = Warnings.Unreachable; loc } + | _ :: exprs -> report_unreachable_expr exprs + | [] -> () + in + report_unreachable_expr exprs method! visit_Pexpr_letrec ctx bindings body loc = let vis = ref Map_string.empty in - Lst.iter bindings (fun (binder, _) -> + Lst.iter bindings ~f:(fun (binder, _) -> let name = binder.binder_name in vis := Map_string.adjust !vis name (function @@ -118,10 +134,12 @@ let syntax_check ~diagnostics impls = decl_params = None; type_name = _; name = _; - has_error = false; - is_pub = false; + has_error = None; + is_async = false; + vis = Vis_default; params_loc_ = _; doc_ = _; + attrs = _; }, Decl_body { expr = body; local_types = _ } ) -> self#visit_expr ctx body @@ -137,7 +155,7 @@ let syntax_check ~diagnostics impls = tvars = Lst.map fun_decl.quantifiers (fun x -> x.tvar_name); } in - List.iter (self#visit_tvar_binder ctx) fun_decl.quantifiers; + Basic_lst.iter fun_decl.quantifiers ~f:(self#visit_tvar_binder ctx); unused_tvars := tvar_list_to_map ~diagnostics:ctx.diagnostics fun_decl.quantifiers; (match fun_decl.decl_params with @@ -153,8 +171,9 @@ let syntax_check ~diagnostics impls = | Some (ty1, Error_typ { ty }) -> self#visit_typ ctx ty1; self#visit_typ ctx ty); + Lst.iter fun_decl.attrs ~f:(self#visit_attribute ctx); self#visit_decl_body ctx decl_body; - warn_unused_tvars ctx.diagnostics !unused_tvars; + warn_unused_tvars ctx.diagnostics ~is_error:true !unused_tvars; match decl_body with | Decl_stubs decl when fun_decl.quantifiers <> [] @@ -169,12 +188,12 @@ let syntax_check ~diagnostics impls = ~loc:loc_) method! visit_Ptop_typedef ctx - { params; components; type_vis; tycon; tycon_loc_; doc_ = _ } = + { params; components; type_vis; tycon; tycon_loc_; doc_ = _; attrs } = if type_name_is_reserved tycon then add_error ctx.diagnostics (Errors.reserved_type_name ~decl_kind:`Type ~name:tycon ~loc:tycon_loc_); - Lst.iter params (fun tvar_binder -> + Lst.iter params ~f:(fun tvar_binder -> match tvar_binder.tvar_name with | Some name when type_name_is_reserved name -> add_error ctx.diagnostics @@ -182,15 +201,19 @@ let syntax_check ~diagnostics impls = ~loc:tvar_binder.loc_) | _ -> ()); let tvars = - Lst.fold_right params [] (fun x acc -> - match x.tvar_name with Some name -> name :: acc | None -> acc) + Lst.fold_right params [] (fun x -> + fun acc -> + match x.tvar_name with Some name -> name :: acc | None -> acc) in unused_tvars := tvar_option_list_to_map ~diagnostics:ctx.diagnostics params; + Lst.iter attrs ~f:(fun attr -> self#visit_attribute ctx attr); self#visit_type_desc { type_vis; tvars; diagnostics = ctx.diagnostics; base = ctx.base } components; - warn_unused_tvars ctx.diagnostics !unused_tvars; + (match components with + | Ptd_abstract | Ptd_extern -> () + | _ -> warn_unused_tvars ctx.diagnostics ~is_error:false !unused_tvars); if Basic_strutil.starts_with_lower_case tycon.![0] then Local_diagnostics.add_warning ctx.diagnostics { kind = Lowercase_type_name tycon; loc = tycon_loc_ } @@ -235,11 +258,6 @@ let syntax_check ~diagnostics impls = (Syntax.loc_of_type_expression p.cparam_typ)) | _ -> () - method! visit_Ptop_letdef ctx binder ty expr _is_constant _is_pub _ _ = - self#visit_binder ctx binder; - self#visit_expr ctx expr; - Option.iter (self#visit_typ ctx) ty - method! visit_Trait_method ctx name has_error quantifiers param_typs return_type loc_ = if quantifiers <> [] then @@ -254,19 +272,19 @@ let syntax_check ~diagnostics impls = (Errors.reserved_type_name ~decl_kind:`Trait ~name ~loc:decl.trait_name.loc_); let _ = - Lst.fold_left decl.trait_methods Map_string.empty - (fun seen_methods meth -> - let (Trait_method { name; loc_; _ }) = meth in - let name = name.binder_name in - Map_string.adjust seen_methods name (fun prev -> - match prev with - | Some prev_loc -> - add_error ctx.diagnostics - (Errors.trait_duplicate_method - ~trait:decl.trait_name.binder_name ~name - ~first:prev_loc ~second:loc_); - prev_loc - | None -> Rloc.to_loc ~base:ctx.base loc_)) + Lst.fold_left decl.trait_methods Map_string.empty (fun seen_methods -> + fun meth -> + let (Trait_method { name; loc_; _ }) = meth in + let name = name.binder_name in + Map_string.adjust seen_methods name (fun prev -> + match prev with + | Some prev_loc -> + add_error ctx.diagnostics + (Errors.trait_duplicate_method + ~trait:decl.trait_name.binder_name ~name + ~first:prev_loc ~second:loc_); + prev_loc + | None -> Rloc.to_loc ~base:ctx.base loc_)) in super#visit_trait_decl ctx decl @@ -275,22 +293,69 @@ let syntax_check ~diagnostics impls = | { lid = Lident id; loc_ = _ }, [] when Lst.has_string ctx.tvars id -> if Map_string.mem !unused_tvars id then unused_tvars := Map_string.remove !unused_tvars id - | _ -> Lst.iter tys (self#visit_typ ctx) + | _ -> Lst.iter tys ~f:(self#visit_typ ctx) method! visit_Ptop_impl ctx self_ty trait method_name has_error - quantifiers params ret_ty body is_pub loc_ doc_ = - if Option.is_none self_ty then ( - if is_pub then - add_error ctx.diagnostics - (Errors.no_vis_on_default_impl method_name.loc_); - if quantifiers <> [] then - add_error ctx.diagnostics - (Errors.no_quantifiers_on_default_impl method_name.loc_)); + quantifiers params ret_ty body vis loc_ header_loc_ attrs doc_ = + (match self_ty with + | None -> + if quantifiers <> [] then + add_error ctx.diagnostics + (Errors.no_quantifiers_on_default_impl method_name.loc_) + | _ -> ()); + let ctx = + { ctx with tvars = Lst.map quantifiers (fun x -> x.tvar_name) } + in + unused_tvars := + tvar_list_to_map ~diagnostics:ctx.diagnostics quantifiers; super#visit_Ptop_impl ctx self_ty trait method_name has_error - quantifiers params ret_ty body is_pub loc_ doc_ + quantifiers params ret_ty body vis loc_ header_loc_ attrs doc_; + warn_unused_tvars ctx.diagnostics ~is_error:true !unused_tvars + + method! visit_attribute ctx attr = + match attr.parsed with + | None -> + add_error ctx.diagnostics + (Errors.attribute_parse_error ~loc:attr.loc_ + "syntax error in attribute") + | Some expr -> ( + let warn_invalid_attribute message = + add_warning ctx.diagnostics + { + Local_diagnostics.loc = attr.loc_; + kind = Warnings.Invalid_attribute message; + } + in + match expr with + | Attribute.Apply ({ qual = None; name = "deprecated" }, props) -> ( + match props with + | Expr (String _) :: [] -> () + | _ -> + warn_invalid_attribute + "invalid properties in deprecated attribute") + | Attribute.Apply ({ qual = None; name = "alert" }, props) -> ( + match props with + | [ Expr (Ident _); Expr (String _) ] -> () + | _ -> + warn_invalid_attribute + "invalid properties in alert attribute") + | Apply ({ qual = None; name = "intrinsic" }, props) -> ( + match props with + | Expr (String _) :: [] -> () + | _ -> + warn_invalid_attribute + "invalid properties in intrinsic attribute") + | Ident { qual = Some _; name = _ } + | Apply ({ qual = Some _; name = _ }, _) -> + () + | Ident id | Apply (id, _) -> + let id = Attribute.string_of_id id in + warn_invalid_attribute + (("unknown attribute " ^ id : Stdlib.String.t) [@merlin.hide]) + | _ -> warn_invalid_attribute "invalid attribute") end in - Lst.iter impls (fun impl -> + Lst.iter impls ~f:(fun impl -> let base = Syntax.loc_of_impl impl in let local_diagnostics = Local_diagnostics.make ~base in let init_ctx = @@ -304,129 +369,138 @@ let syntax_check ~diagnostics impls = obj#visit_impl init_ctx impl; Local_diagnostics.add_to_global local_diagnostics diagnostics) -let desugar_matchfn cases has_error fn_loc_ loc_ ~diagnostics : Syntax.func = - let only_variable_pattern pats = - let is_variable_pattern (pat : Syntax.pattern) = - match pat with - | Ppat_var _ | Ppat_constraint { pat = Ppat_var _; _ } -> true - | _ -> false - in - Lst.for_all pats is_variable_pattern - in - let loc_of_pats pats = - Rloc.merge - (Syntax.loc_of_pattern (List.hd pats)) - (Syntax.loc_of_pattern (Lst.last pats)) - [@@inline] - in - match cases with - | [] -> - Lambda - { - parameters = []; - params_loc_ = Rloc.no_location; - body = Pexpr_unit { faked = false; loc_ }; - return_type = None; - kind_ = Matrix; - has_error; - } - | (pats, body) :: [] when only_variable_pattern pats -> - let parameters_rev = - Lst.fold_left pats [] (fun acc pat : Syntax.parameter list -> - match pat with - | Ppat_var param_binder -> - { param_binder; param_annot = None; param_kind = Positional } - :: acc - | Ppat_constraint { pat = Ppat_var param_binder; ty } -> - { param_binder; param_annot = Some ty; param_kind = Positional } - :: acc - | _ -> assert false) - in - let parameters = List.rev parameters_rev in - Lambda - { - parameters; - params_loc_ = loc_of_pats pats; - body; - return_type = None; - kind_ = Matrix; - has_error; - } - | (pats, _) :: _ -> ( - let fresh_param_name () = - let i = Basic_uuid.next () in - ("*param" ^ Int.to_string i : Stdlib.String.t) - in - let to_parameter p_name : Syntax.parameter = - { - param_binder = { binder_name = p_name; loc_ = Rloc.no_location }; - param_annot = None; - param_kind = Positional; - } - [@@inline] - in - let to_var p_name = - let loc_ = Rloc.no_location in - Syntax.Pexpr_ident { id = { var_name = Lident p_name; loc_ }; loc_ } - [@@inline] - in - let pat_tuple pats = - let loc_ = loc_of_pats pats in - Syntax.Ppat_tuple { pats; loc_ } - [@@inline] - in - let add_error ~loc ~expect ~actual = - add_error diagnostics - (Errors.matchfn_arity_mismatch ~loc ~expected:expect ~actual) - [@@inline] - in - match List.length pats with - | 1 -> - let param_name = fresh_param_name () in - let param_with_loc = to_parameter param_name in - let cases = - Lst.map cases (fun (pats, body) -> - match pats with - | pat :: [] -> (pat, body) - | _ -> - let loc = loc_of_pats pats in - add_error ~loc ~expect:1 ~actual:(List.length pats); - (pat_tuple pats, body)) - in - let matchee = to_var param_name in - Lambda - { - parameters = [ param_with_loc ]; - params_loc_ = Rloc.no_location; - body = - Syntax.Pexpr_match - { expr = matchee; cases; match_loc_ = fn_loc_; loc_ }; - return_type = None; - kind_ = Matrix; - has_error; - } - | n when n > 1 -> - let param_names = List.init n (fun _ -> fresh_param_name ()) in - let param_names_with_loc = Lst.map param_names to_parameter in - let cases = - Lst.map cases (fun (pats, body) -> (pat_tuple pats, body)) - in - let variables = Lst.map param_names to_var in - let matchee = - Syntax.Pexpr_tuple { exprs = variables; loc_ = Rloc.no_location } - in - Lambda - { - parameters = param_names_with_loc; - params_loc_ = Rloc.no_location; - body = - Syntax.Pexpr_match - { expr = matchee; cases; match_loc_ = fn_loc_; loc_ }; - return_type = None; - kind_ = Matrix; - has_error; - } - | _ -> assert false) +let desugar_matchfn (cases : Syntax.multi_arg_case list) ~has_error ~is_async + fn_loc_ loc_ ~diagnostics = + (let only_variable_pattern pats = + let is_variable_pattern (pat : Syntax.pattern) = + match pat with + | Ppat_var _ | Ppat_constraint { pat = Ppat_var _; _ } -> true + | _ -> false + in + Lst.for_all pats is_variable_pattern + in + let loc_of_pats pats = + Rloc.merge + (Syntax.loc_of_pattern (List.hd pats)) + (Syntax.loc_of_pattern (Lst.last pats)) + [@@inline] + in + match cases with + | [] -> + Lambda + { + parameters = []; + params_loc_ = Rloc.no_location; + body = Pexpr_unit { faked = false; loc_ }; + return_type = None; + kind_ = Matrix; + has_error; + is_async; + } + | { patterns = pats; guard = None; body } :: [] + when only_variable_pattern pats -> + let parameters_rev = + Lst.fold_left pats [] (fun acc -> + fun pat -> + (match pat with + | Ppat_var binder -> Positional { ty = None; binder } :: acc + | Ppat_constraint { pat = Ppat_var binder; ty; _ } -> + Positional { ty = Some ty; binder } :: acc + | _ -> assert false + : Syntax.parameter list)) + in + let parameters = List.rev parameters_rev in + Lambda + { + parameters; + params_loc_ = loc_of_pats pats; + body; + return_type = None; + kind_ = Matrix; + has_error; + is_async; + } + | { patterns = pats; _ } :: _ -> ( + let fresh_param_name () = + let i = Basic_uuid.next () in + (("*param" ^ Int.to_string i : Stdlib.String.t) [@merlin.hide]) + in + let to_parameter p_name loc_ = + (Positional { ty = None; binder = { binder_name = p_name; loc_ } } + : Syntax.parameter) + [@@inline] + in + let to_var p_name loc_ = + Syntax.Pexpr_ident { id = { var_name = Lident p_name; loc_ }; loc_ } + [@@inline] + in + let pat_tuple pats = + let loc_ = loc_of_pats pats in + Syntax.Ppat_tuple { pats; loc_ } + [@@inline] + in + let add_error ~loc ~expect ~actual = + add_error diagnostics + (Errors.matchfn_arity_mismatch ~loc ~expected:expect ~actual) + [@@inline] + in + match pats with + | pat :: [] -> + let param_loc_ = Syntax.loc_of_pattern pat in + let param_name = fresh_param_name () in + let param_with_loc = to_parameter param_name param_loc_ in + let cases = + Lst.map cases (fun { patterns = pats; guard; body } -> + (match pats with + | pat :: [] -> { pattern = pat; guard; body } + | _ -> + let loc = loc_of_pats pats in + add_error ~loc ~expect:1 ~actual:(List.length pats); + { pattern = pat_tuple pats; guard; body } + : Syntax.case)) + in + let matchee = to_var param_name param_loc_ in + Lambda + { + parameters = [ param_with_loc ]; + params_loc_ = Rloc.no_location; + body = + Syntax.Pexpr_match + { expr = matchee; cases; match_loc_ = fn_loc_; loc_ }; + return_type = None; + kind_ = Matrix; + has_error; + is_async; + } + | pats -> + let param_names = + Lst.map pats (fun p -> + (fresh_param_name (), Syntax.loc_of_pattern p)) + in + let param_names_with_loc = + Lst.map param_names (fun (p, loc) -> to_parameter p loc) + in + let cases = + Lst.map cases (fun { patterns = pats; guard; body } -> + ({ pattern = pat_tuple pats; guard; body } : Syntax.case)) + in + let variables = Lst.map param_names (fun (p, loc) -> to_var p loc) in + let matchee = + Syntax.Pexpr_tuple { exprs = variables; loc_ = Rloc.no_location } + in + Lambda + { + parameters = param_names_with_loc; + params_loc_ = Rloc.no_location; + body = + Syntax.Pexpr_match + { expr = matchee; cases; match_loc_ = fn_loc_; loc_ }; + return_type = None; + kind_ = Matrix; + has_error; + is_async; + }) + : Syntax.func) let test_to_func ~diagnostics i expr params local_types loc_ = let test_name_gen = Test_util.gen_test_name (Loc.filename loc_) i in @@ -450,23 +524,27 @@ let test_to_func ~diagnostics i expr params local_types loc_ = match params with | None -> Some [] | Some - ({ - Syntax.param_annot = - Some - (Ptype_name - { - constr_id = - { - lid = - Longident.Ldot - { pkg = "test" | "moonbitlang/core/test"; id = "T" }; - _; - }; - tys = []; - _; - }); - _; - } + (Syntax.Positional + { + ty = + Some + (Ptype_name + { + constr_id = + { + lid = + Longident.Ldot + { + pkg = "test" | "moonbitlang/core/test"; + id = "T"; + }; + _; + }; + tys = []; + _; + }); + _; + } :: []) -> params | _ -> @@ -478,155 +556,154 @@ let test_to_func ~diagnostics i expr params local_types loc_ = fun_decl = { type_name = None; - has_error = false; + has_error = None; + is_async = false; name = { binder_name = test_name_gen; loc_ = Rloc.no_location }; decl_params = params; params_loc_ = Rloc.no_location; quantifiers = []; return_type = Some (unit_type, Error_typ { ty = string_type }); - is_pub = false; + vis = Vis_default; + attrs = []; doc_ = Docstring.empty; }; decl_body = Decl_body { expr; local_types }; loc_; } -let post_process ~diagnostics (impls : Syntax.impls) : Syntax.impls = - syntax_check ~diagnostics impls; - let map_top impl = - let local_diagnostics = - Local_diagnostics.make ~base:(Syntax.loc_of_impl impl) - in - let impl = - (object (self) - inherit [_] Syntax.map as super - - method! visit_Pexpr_array_get env array index loc_ = - let array' = self#visit_expr env array in - let index' = self#visit_expr env index in - Parser_util.desugar_array_get array' index' ~loc_ - - method! visit_Pexpr_array_get_slice env array start_index end_index - index_loc_ loc_ = - let array' = self#visit_expr env array in - let start_index' = Option.map (self#visit_expr env) start_index in - let end_index' = Option.map (self#visit_expr env) end_index in - Parser_util.desugar_array_get_slice array' start_index' end_index' - ~index_loc_ ~loc_ - - method! visit_Pexpr_array_set env array index value loc_ = - let array' = self#visit_expr env array in - let index' = self#visit_expr env index in - let value' = self#visit_expr env value in - Parser_util.desugar_array_set array' index' value' ~loc_ - - method! visit_Pexpr_array_augmented_set env op array index value loc_ = - let op' = self#visit_var env op in - let array' = self#visit_expr env array in - let index' = self#visit_expr env index in - let value' = self#visit_expr env value in - Parser_util.desugar_array_augmented_set op' array' index' value' - ~loc_ - - method! visit_func _ func = - match func with - | Lambda _ -> super#visit_func () func - | Match { cases; has_error; fn_loc_; loc_ } -> - super#visit_func () - (desugar_matchfn cases has_error fn_loc_ loc_ - ~diagnostics:local_diagnostics) - - method! visit_Pexpr_apply env func args bang loc_ = - (match (func, args) with - | Pexpr_constr _, [] -> - add_error local_diagnostics (Errors.illform_constr_arg loc_) - | _ -> ()); - super#visit_Pexpr_apply env func args bang loc_ - - method! visit_Pexpr_record env type_name fields trailing loc = - (match (type_name, fields, trailing) with - | ( None, - Field_def { is_pun = true; _ } :: [], - (Syntax.Trailing_semi | Trailing_none) ) -> - Local_diagnostics.add_warning local_diagnostics - { loc; kind = Warnings.Ambiguous_block } - | _ -> ()); - super#visit_Pexpr_record env type_name fields trailing loc - - method! visit_Pexpr_group env expr _ _ = super#visit_expr env expr - - method! visit_Pexpr_unary env op expr loc_ = - match op.var_name with - | Lident "-" -> - Pexpr_dot_apply - { - loc_; - self = self#visit_expr env expr; - method_name = - { - label_name = - (Parsing_operators.find_exn "~-").method_name; - loc_; - }; - return_self = false; - attr = No_attr; - args = []; - } - | _ -> assert false - - method! visit_Interp_source env interp_source = - let base = Loc.get_start (Syntax.loc_of_impl impl) in - let expr = - Parsing_interp.expr_of_interp ~diagnostics ~base interp_source - in - let expr = self#visit_expr env expr in - let loc_ = - Rloc.of_loc - ~base:(Loc.get_start (Syntax.loc_of_impl impl)) - interp_source.loc_ - in - Syntax.Interp_expr { expr; loc_ } - end) - #visit_impl - () impl - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - impl - in - let rec aux i impls = - match impls with - | [] -> [] - | hd :: tl -> ( - (let loc = Syntax.loc_of_impl hd in - let loca = Loc.get_start loc in - let not_left_aligned = - loca.pos_cnum <> loca.pos_bol && not (Loc.is_no_location loc) - in - if not_left_aligned then - Diagnostics.add_warning diagnostics - { loc; kind = Warnings.Toplevel_not_left_aligned }); - match map_top hd with - | Syntax.Ptop_test { expr; name = _; params; local_types; loc_ } -> - test_to_func ~diagnostics i expr params local_types loc_ - :: aux (i + 1) tl - | Syntax.Ptop_funcdef - { - fun_decl = - { name = { binder_name = "init"; _ }; type_name = None; _ }; - decl_body = Decl_body { expr = body; local_types }; - loc_; - } -> - Syntax.Ptop_expr { expr = body; is_main = false; local_types; loc_ } - :: aux i tl - | Syntax.Ptop_funcdef - { - fun_decl = - { name = { binder_name = "main"; _ }; type_name = None; _ }; - decl_body = Decl_body { expr = body; local_types }; - loc_; - } -> - Syntax.Ptop_expr { expr = body; is_main = true; local_types; loc_ } - :: aux i tl - | top -> top :: aux i tl) - in - aux 0 impls +let post_process ~diagnostics (impls : Syntax.impls) = + (syntax_check ~diagnostics impls; + let map_top impl = + let local_diagnostics = + Local_diagnostics.make ~base:(Syntax.loc_of_impl impl) + in + let impl = + (object (self) + inherit [_] Syntax.map as super + + method! visit_Pexpr_array_get env array index loc_ = + let array' = self#visit_expr env array in + let index' = self#visit_expr env index in + Parser_util.desugar_array_get array' index' ~loc_ + + method! visit_Pexpr_array_set env array index value loc_ = + let array' = self#visit_expr env array in + let index' = self#visit_expr env index in + let value' = self#visit_expr env value in + Parser_util.desugar_array_set array' index' value' ~loc_ + + method! visit_Pexpr_array_augmented_set env op array index value loc_ + = + let op' = self#visit_var env op in + let array' = self#visit_expr env array in + let index' = self#visit_expr env index in + let value' = self#visit_expr env value in + Parser_util.desugar_array_augmented_set op' array' index' value' + ~loc_ + + method! visit_func _ func = + match func with + | Lambda _ -> super#visit_func () func + | Match { cases; has_error; is_async; fn_loc_; loc_ } -> + super#visit_func () + (desugar_matchfn cases ~has_error ~is_async fn_loc_ loc_ + ~diagnostics:local_diagnostics) + + method! visit_Pexpr_apply env func args bang loc_ = + (match (func, args) with + | Pexpr_constr _, [] -> + add_error local_diagnostics (Errors.illform_constr_arg loc_) + | _ -> ()); + super#visit_Pexpr_apply env func args bang loc_ + + method! visit_Pexpr_record env type_name fields trailing loc = + (match (type_name, fields, trailing) with + | ( None, + Field_def { is_pun = true; _ } :: [], + (Syntax.Trailing_semi | Trailing_none) ) -> + Local_diagnostics.add_warning local_diagnostics + { loc; kind = Warnings.Ambiguous_block } + | _ -> ()); + super#visit_Pexpr_record env type_name fields trailing loc + + method! visit_Pexpr_group env expr _ _ = super#visit_expr env expr + + method! visit_Pexpr_unary env op expr loc_ = + match op.var_name with + | Lident "-" -> + Pexpr_dot_apply + { + loc_; + self = self#visit_expr env expr; + method_name = + { + label_name = + (Parsing_operators.find_exn "~-").method_name; + loc_; + }; + return_self = false; + attr = No_attr; + args = []; + } + | _ -> assert false + + method! visit_Interp_source env interp_source = + let base = Loc.get_start (Syntax.loc_of_impl impl) in + let expr = + Parsing_interp.expr_of_interp ~diagnostics ~base interp_source + in + let expr = self#visit_expr env expr in + let loc_ = + Rloc.of_loc + ~base:(Loc.get_start (Syntax.loc_of_impl impl)) + interp_source.loc_ + in + Syntax.Interp_expr { expr; loc_ } + end) + #visit_impl + () impl + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + impl + in + let rec aux i impls = + match impls with + | [] -> [] + | hd :: tl -> ( + (let loc = Syntax.loc_of_impl hd in + let loca = Loc.get_start loc in + let not_left_aligned = + loca.pos_cnum <> loca.pos_bol && not (Loc.is_no_location loc) + in + if not_left_aligned then + Diagnostics.add_warning diagnostics + { loc; kind = Warnings.Toplevel_not_left_aligned }); + match map_top hd with + | Syntax.Ptop_test + { expr; name = _; params; local_types; loc_; attrs = _ } -> + test_to_func ~diagnostics i expr params local_types loc_ + :: aux (i + 1) tl + | Syntax.Ptop_funcdef + { + fun_decl = + { name = { binder_name = "init"; _ }; type_name = None; _ }; + decl_body = Decl_body { expr = body; local_types }; + loc_; + } -> + Syntax.Ptop_expr + { expr = body; is_main = false; local_types; loc_ } + :: aux i tl + | Syntax.Ptop_funcdef + { + fun_decl = + { name = { binder_name = "main"; _ }; type_name = None; _ }; + decl_body = Decl_body { expr = body; local_types }; + loc_; + } -> + Syntax.Ptop_expr { expr = body; is_main = true; local_types; loc_ } + :: aux i tl + | top -> top :: aux i tl) + [@@tail_mod_cons] + in + aux 0 impls + : Syntax.impls) diff --git a/src/parsing_compact.ml b/src/parsing_compact.ml index 6792b88..5142e0d 100644 --- a/src/parsing_compact.ml +++ b/src/parsing_compact.ml @@ -27,7 +27,7 @@ type semi_expr_prop = | Stmt_guard_let of { pat : pattern; expr : expr; - otherwise : (pattern * expr) list option; + otherwise : Syntax.case list option; loc : Rloc.t; } | Stmt_letmut of { @@ -38,23 +38,24 @@ type semi_expr_prop = } | Stmt_func of { binder : binder; func : Syntax.func; loc : Rloc.t } -let rec compact_rev (ls : semi_expr_prop list) (semi_list_loc : Rloc.t) : expr = - match ls with - | Stmt_expr { expr } :: rest -> collect_rev rest expr - | rest -> - let loc_ = - match rest with - | [] -> semi_list_loc - | ( Stmt_let { loc; _ } - | Stmt_guard { loc; _ } - | Stmt_guard_let { loc; _ } - | Stmt_letmut { loc; _ } - | Stmt_func { loc; _ } ) - :: _ -> - loc - | Stmt_expr _ :: _ -> assert false - in - collect_rev rest (Syntax.Pexpr_unit { loc_; faked = true }) +let rec compact_rev (ls : semi_expr_prop list) (semi_list_loc : Rloc.t) = + (match ls with + | Stmt_expr { expr } :: rest -> collect_rev rest expr + | rest -> + let loc_ = + match rest with + | [] -> semi_list_loc + | ( Stmt_let { loc; _ } + | Stmt_guard { loc; _ } + | Stmt_guard_let { loc; _ } + | Stmt_letmut { loc; _ } + | Stmt_func { loc; _ } ) + :: _ -> + loc + | Stmt_expr _ :: _ -> assert false + in + collect_rev rest (Syntax.Pexpr_unit { loc_; faked = true }) + : expr) and collect_rev rest cont = match rest with @@ -62,19 +63,11 @@ and collect_rev rest cont = | x :: xs -> ( match x with | Stmt_func x -> collect_letrec x.loc [ (x.binder, x.func) ] xs cont + | Stmt_expr _ -> + collect_sequence (Syntax.loc_of_expression cont) [] rest cont | _ -> let acc : Syntax.expr = match x with - | Stmt_expr { expr = expr1 } -> - Pexpr_sequence - { - expr1; - expr2 = cont; - loc_ = - Rloc.merge - (Syntax.loc_of_expression expr1) - (Syntax.loc_of_expression cont); - } | Stmt_let { pat; expr; loc } -> let loc_ = Rloc.merge loc (Syntax.loc_of_expression cont) in Pexpr_let { pattern = pat; expr; loc_; body = cont } @@ -87,10 +80,18 @@ and collect_rev rest cont = | Stmt_letmut { binder; ty_opt; expr; loc } -> let loc_ = Rloc.merge loc (Syntax.loc_of_expression cont) in Pexpr_letmut { binder; ty = ty_opt; expr; loc_; body = cont } - | Stmt_func _ -> assert false + | Stmt_expr _ | Stmt_func _ -> assert false in collect_rev xs acc) +and collect_sequence loc_ (acc : Syntax.expr list) todo cont = + match todo with + | Stmt_expr { expr = expr1 } :: rest -> + let loc_ = Rloc.merge (Syntax.loc_of_expression expr1) loc_ in + collect_sequence loc_ (expr1 :: acc) rest cont + | _ -> + collect_rev todo (Pexpr_sequence { exprs = acc; last_expr = cont; loc_ }) + and collect_letrec firstloc acc todo cont = match todo with | Stmt_func x :: rest -> diff --git a/src/parsing_core.ml b/src/parsing_core.ml new file mode 100644 index 0000000..7c33461 --- /dev/null +++ b/src/parsing_core.ml @@ -0,0 +1,532 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Menhir_token = Lex_menhir_token +module Menhir_token_util = Lex_menhir_token_util +module Token_triple = Lex_token_triple +module Vec = Basic_vec +module Lst = Basic_lst +module Syntax = Parsing_syntax +module Segment = Parsing_segment + +type token = Menhir_token.token +type triple = Token_triple.t +type absolute_pos = Lexing.position +type position = Rloc.rpos +type location = Syntax.location +type string_literal = Menhir_token.Literal.string_literal + +type token_kind = Menhir_token.token_kind = + | Token_kind : _ Menhir_token.terminal -> token_kind +[@@unboxed] + +let kind_of_token = Menhir_token.kind_of_token +and sexp_of_token = Menhir_token.sexp_of_token + +let token_kind_to_expect_string = Menhir_token_util.token_kind_to_expect_string + +type parse_mode = + | Normal + | Panic of { fail_at : token_kind; sync_at : int; loc : location } + +type parse_state = { + segment : Segment.t; + diagnostics : Diagnostics.t; + mutable previous_triple : triple; + mutable parsed_position : absolute_pos; + syncs : token_kind Vec.t; + mutable mode : parse_mode; + mutable base : absolute_pos; +} + +let index_of_token_kind (xs : token_kind Vec.t) (x : token_kind) = + let rec loop (xs : token_kind Vec.t) x i = + match Vec.get_opt xs i with + | None -> None + | Some x' -> if x = x' then Some i else loop xs x (i - 1) + in + loop xs x (Vec.length xs - 1) + +let rec mem_token_kind (xs : token_kind list) (x : token_kind) = + match xs with [] -> false | a :: l -> a = x || mem_token_kind l x + +let skip_this (state : parse_state) = + state.previous_triple <- Segment.next state.segment; + let _, _, e = state.previous_triple in + state.parsed_position <- e + +let init_state ~diagnostics (segment : Segment.t) = + (let syncs = Vec.empty () in + let () = Vec.push syncs (Menhir_token.Token_kind T_EOF) in + let ((_, s, _) as first_triple) = Segment.peek segment in + { + segment; + previous_triple = first_triple; + parsed_position = s; + diagnostics; + syncs; + mode = Normal; + base = s; + } + : parse_state) + +let get_mode (state : parse_state) = (state.mode : parse_mode) +let peek_triple (state : parse_state) = (Segment.peek state.segment : triple) + +let peek_token (state : parse_state) = + (let tok, _, _ = peek_triple state in + tok + : token) + +let peek_token_kind (state : parse_state) = + (kind_of_token (peek_token state) : token_kind) + +let peek_nth_token (state : parse_state) (n : int) = + (let tok, _, _ = Segment.peek_nth state.segment n in + tok + : token) + +let peek_nth_token_kind (state : parse_state) (n : int) = + (kind_of_token (peek_nth_token state n) : token_kind) + +let peek_loc_start (state : parse_state) = + (let _, s, _ = peek_triple state in + Rloc.lex_pos_to_pos ~base:state.base s + : position) + +let peek_loc_end (state : parse_state) = + (let _, _, e = peek_triple state in + Rloc.lex_pos_to_pos ~base:state.base e + : position) + +let loc_start_with (state : parse_state) (loc_start : position) = + (let e = state.parsed_position in + let loc_end = Rloc.lex_pos_to_pos ~base:state.base e in + Rloc.of_pos (loc_start, loc_end) + : location) + +let peek_location (state : parse_state) = + (let _, s, e = peek_triple state in + let loc = (s, e) in + Rloc.of_menhir ~base:state.base loc + : location) + +let peek_absolute_location (state : parse_state) = + (let _, s, e = peek_triple state in + let loc = (s, e) in + Loc.of_menhir loc + : Loc.t) + +let debug_mode : bool = false +let debug_indent : int ref = ref 0 + +let parser_debug_print (str : string) = + if debug_mode then Printf.printf "%*s%s\n" !debug_indent " " str + +let debug_show_rest_tokens (state : parse_state) (n : int) = + if debug_mode then + for i = 1 to n do + parser_debug_print (S.to_string (sexp_of_token (peek_nth_token state i))) + done + +let debugged (str : string) (state : parse_state) (parser : parse_state -> 'a) = + (if debug_mode then ( + if get_mode state = Normal then + parser_debug_print + ("# " ^ str ^ " at " + ^ S.to_string (sexp_of_token (peek_token state)) + ^ " (" + ^ Loc.to_string (peek_absolute_location state) + ^ ")") + else parser_debug_print ("!!! " ^ str ^ " skipped."); + debug_indent := !debug_indent + 2; + let res = parser state in + debug_indent := !debug_indent - 2; + res) + else parser state + : 'a) + +let parser_panic (state : parse_state) = + if debug_mode then ( + parser_debug_print + ("[!] parser paniced at " ^ S.to_string (sexp_of_token (peek_token state))); + debug_show_rest_tokens state 8); + match get_mode state with + | Normal -> + let _, _, prev_token_end = state.previous_triple in + let fail_at, first_token_start, _ = peek_triple state in + let rec find_recovery_point n_skipped = + let _, _, last_token_end = state.previous_triple in + let next_token, next_token_start, _ = peek_triple state in + match index_of_token_kind state.syncs (kind_of_token next_token) with + | Some index -> + let loc = + if n_skipped > 0 then + Rloc.of_menhir ~base:state.base + (first_token_start, last_token_end) + else ( + state.parsed_position <- next_token_start; + Rloc.of_menhir ~base:state.base + (prev_token_end, next_token_start)) + in + state.mode <- + Panic { fail_at = kind_of_token fail_at; sync_at = index; loc }; + loc + | None -> + skip_this state; + find_recovery_point (n_skipped + 1) + in + find_recovery_point 0 + | Panic { loc; _ } -> loc + +let parser_recover (state : parse_state) = + if get_mode state <> Normal then ( + if debug_mode then parser_debug_print "!!! parser recovered here!") + else failwith "you can't recover from normal mode!"; + state.mode <- Normal + +let add_error_failed_to_parse (state : parse_state) (found : token) + (expected : string) (loc : Rloc.t) = + let loc = Rloc.to_loc_base_pos ~base:state.base loc in + let error = + let fallback found = + Errors.unexpected_token + ~found:(token_kind_to_expect_string (kind_of_token found)) + ~expected ~loc + in + match found with + | SEMI false -> Errors.unexpected_line_break ~expected ~loc + | EOF -> ( + match Segment.next_segment_head state.segment with + | Some (tok, _, _) -> ( + match tok with + | FN | LET -> + Errors.unexpected_token_maybe_forget_indent ~expected + ~next:(token_kind_to_expect_string (kind_of_token tok)) + ~loc + | _ -> fallback tok) + | _ -> fallback found) + | _ -> fallback found + in + parser_debug_print error.message; + Diagnostics.add_error state.diagnostics error + +let add_error_unexpected (state : parse_state) (found : token) + (expect : token_kind list) (loc : location) = + let expect = + String.concat " or " (Lst.map expect token_kind_to_expect_string) + in + add_error_failed_to_parse state found expect loc + +let add_error_skipped (_state : parse_state) (expect : string) (_loc : Rloc.t) = + let message = "Skipped: " ^ expect in + parser_debug_print message + +let add_error (state : parse_state) (error : Local_diagnostics.error) = + parser_debug_print error.message; + let loc = Rloc.to_loc_base_pos ~base:state.base error.loc in + let error : Diagnostics.report = + { loc; message = error.message; error_code = error.error_code } + in + Diagnostics.add_error state.diagnostics error + +let push_sync (state : parse_state) (sync : token_kind) = + Vec.push state.syncs sync + +let pop_sync (state : parse_state) (sync : token_kind) = + match Vec.pop_opt state.syncs with + | Some x -> ( + if x <> sync then failwith "unmatched sync token!"; + match state.mode with + | Panic { sync_at; _ } when sync_at = Vec.length state.syncs -> + parser_recover state + | _ -> ()) + | None -> failwith "pop from an empty stack!" + +let push_sync_list (state : parse_state) (syncs : token_kind list) = + Basic_lst.iter syncs ~f:(fun sync -> push_sync state sync) + +let pop_sync_list (state : parse_state) (syncs : token_kind list) = + Basic_lst.iter (List.rev syncs) ~f:(fun sync -> pop_sync state sync) + +let with_sync (state : parse_state) (sync : token_kind) f = + push_sync state sync; + let r = f state in + pop_sync state sync; + r + +let with_syncs (state : parse_state) (syncs : token_kind list) f = + push_sync_list state syncs; + let r = f state in + pop_sync_list state syncs; + r + +let expected_token (expect : token_kind) (state : parse_state) = + (match state.mode with + | Normal -> + let tok, loc_start, loc_end = peek_triple state in + let found = kind_of_token tok in + if found = expect then ( + if debug_mode then + parser_debug_print (" consumed " ^ S.to_string (sexp_of_token tok)); + skip_this state) + else + let _ = parser_panic state in + add_error_unexpected state tok [ expect ] + (Rloc.of_menhir ~base:state.base (loc_start, loc_end)) + | Panic { loc; _ } -> + add_error_skipped state (token_kind_to_expect_string expect) loc + : unit) + +let expected_template (expect : token_kind) (default : 'a) + (func : token -> 'a option) (state : parse_state) = + match state.mode with + | Normal -> ( + let found, loc_start, loc_end = peek_triple state in + match func found with + | Some res -> + skip_this state; + res + | None -> + let _ = parser_panic state in + add_error_unexpected state found [ expect ] + (Rloc.of_menhir ~base:state.base (loc_start, loc_end)); + default) + | Panic { loc; _ } -> + add_error_skipped state (token_kind_to_expect_string expect) loc; + default + +let expected_lident (state : parse_state) = + (expected_template (Token_kind T_LIDENT) "?LIDENT" + (fun tok -> match tok with LIDENT res -> Some res | _ -> None) + state + : string) + +let expected_uident ?(default = "?UIDENT") (state : parse_state) = + (expected_template (Token_kind T_UIDENT) default + (fun tok -> match tok with UIDENT res -> Some res | _ -> None) + state + : string) + +let expected_string (state : parse_state) = + (expected_template (Token_kind T_STRING) + ({ string_val = "?STRING"; string_repr = "?STRING" } : string_literal) + (fun tok -> match tok with STRING res -> Some res | _ -> None) + state + : string_literal) + +let expected_pkg_name (state : parse_state) = + (expected_template (Token_kind T_PACKAGE_NAME) "?PACKAGE_NAME" + (fun tok -> match tok with PACKAGE_NAME res -> Some res | _ -> None) + state + : string) + +let expected_dot_lident (state : parse_state) = + (expected_template (Token_kind T_DOT_LIDENT) "?DOT_IDENT" + (fun tok -> match tok with DOT_LIDENT res -> Some res | _ -> None) + state + : string) + +let expected_dot_uident (state : parse_state) = + (expected_template (Token_kind T_DOT_UIDENT) "?DOT_IDENT" + (fun tok -> match tok with DOT_UIDENT res -> Some res | _ -> None) + state + : string) + +let expected_dot_int (state : parse_state) = + (expected_template (Token_kind T_DOT_INT) 0 + (fun tok -> match tok with DOT_INT res -> Some res | _ -> None) + state + : int) + +let expected_int (state : parse_state) = + (expected_template (Token_kind T_INT) "" + (fun tok -> match tok with INT res -> Some res | _ -> None) + state + : string) + +let option (first : token_kind list) (parser : parse_state -> 'a) + (state : parse_state) = + (match state.mode with + | Normal -> + if mem_token_kind first (kind_of_token (peek_token state)) then + Some (parser state) + else None + | Panic { loc; _ } -> + add_error_skipped state "option .." loc; + None + : 'a option) + +let sepby (delim : token_kind) (first : token_kind list) + (parser : parse_state -> 'a) (state : parse_state) = + (match state.mode with + | Normal -> + push_sync state delim; + if mem_token_kind first (kind_of_token (peek_token state)) then ( + let elem1 = parser state in + let res = ref [ elem1 ] in + while kind_of_token (peek_token state) = delim do + pop_sync state delim; + expected_token delim state; + push_sync state delim; + res := parser state :: !res + done; + pop_sync state delim; + List.rev !res) + else ( + pop_sync state delim; + []) + | Panic { loc; _ } -> + add_error_skipped state "sepby .." loc; + [] + : 'a list) + +let sepby1 (delim : token_kind) (parser : parse_state -> 'a) + (state : parse_state) = + (match state.mode with + | Normal -> + push_sync state delim; + let elem1 = parser state in + let res = ref [ elem1 ] in + while kind_of_token (peek_token state) = delim do + pop_sync state delim; + expected_token delim state; + push_sync state delim; + res := parser state :: !res + done; + pop_sync state delim; + List.rev !res + | Panic { loc; _ } -> + add_error_skipped state "sepby1 .." loc; + [] + : 'a list) + +let surround (left : token_kind) (right : token_kind) + (parser : parse_state -> 'a) (state : parse_state) = + match state.mode with + | Normal -> + expected_token left state; + push_sync state right; + let res = parser state in + pop_sync state right; + expected_token right state; + res + | Panic { loc; _ } -> + add_error_skipped state "surround .." loc; + parser state + +let with_follow (follow : token_kind list) (parser : parse_state -> 'a) + (state : parse_state) = + (match state.mode with + | Normal -> + push_sync_list state follow; + let result = parser state in + if not (mem_token_kind follow (peek_token_kind state)) then ( + add_error_unexpected state (peek_token state) follow + (peek_location state); + ignore (parser_panic state)); + pop_sync_list state follow; + result + | Panic { loc; _ } -> + add_error_skipped state "with follow " loc; + parser state + : 'a) + +let sepby_with_follow ?(invalid_delims = []) (delim : token_kind) + (follow : token_kind list) (parser : parse_state -> 'a) + (state : parse_state) = + (let try_recover_to_delim () = + let loc = peek_location state in + let tok = peek_token state in + push_sync state delim; + let _ = parser_panic state in + add_error_unexpected state tok (delim :: follow) loc; + pop_sync state delim; + if peek_token_kind state = delim then expected_token delim state + in + match state.mode with + | Normal -> + let res = ref [] in + push_sync_list state follow; + let rec loop () = + match state.mode with + | Panic _ -> () + | Normal when mem_token_kind follow (peek_token_kind state) -> () + | Normal -> ( + push_sync state delim; + res := parser state :: !res; + pop_sync state delim; + match state.mode with + | Panic _ -> () + | Normal when mem_token_kind follow (peek_token_kind state) -> () + | Normal when peek_token_kind state = delim -> + expected_token delim state; + loop () + | Normal when mem_token_kind invalid_delims (peek_token_kind state) + -> + let error = + Errors.invalid_extra_delimiter + ~loc: + (Rloc.to_loc_base_pos ~base:state.base + (peek_location state)) + ~delimiter: + (Menhir_token_util.token_kind_to_expect_string + (peek_token_kind state)) + in + Diagnostics.add_error state.diagnostics error; + skip_this state; + loop () + | Normal -> + try_recover_to_delim (); + loop ()) + in + loop (); + pop_sync_list state follow; + let prv_tok, _, _ = state.previous_triple in + let trailing_delim = kind_of_token prv_tok = delim in + (List.rev !res, trailing_delim) + | Panic { loc; _ } -> + add_error_skipped state "sepby with right .." loc; + ([], false) + : 'a list * bool) + +let surround_sepby ?(invalid_delims = []) (left : token_kind) + (right : token_kind) (delim : token_kind) (parser : parse_state -> 'a) + (state : parse_state) = + (match state.mode with + | Normal -> + Stdlib.fst + (surround left right + (sepby_with_follow ~invalid_delims delim [ right ] parser) + state) + | Panic { loc; _ } -> + add_error_skipped state "surround sepby .." loc; + [] + : 'a list) + +let located (state : parse_state) (parser : parse_state -> location -> 'a) = + (let loc_start = peek_loc_start state in + let func = parser state in + let loc = loc_start_with state loc_start in + func loc + : 'a) + +let get_absolute_loc (state : parse_state) (loc : location) = + (Rloc.to_loc_base_pos ~base:state.base loc : Loc.t) + +let update_base (state : parse_state) = + (let _, s, _ = peek_triple state in + state.base <- s + : unit) diff --git a/src/parsing_header_parser.ml b/src/parsing_header_parser.ml index 095f282..99f98fe 100644 --- a/src/parsing_header_parser.ml +++ b/src/parsing_header_parser.ml @@ -13,50 +13,23 @@ *) -module Vec = Basic_vec -module Token_triple = Lex_token_triple -module Vec_token = Lex_vec_token - -type state = { mutable cur : int; tokens : Token_triple.t array; len : int } - -let bump_any state : unit = state.cur <- state.cur + 1 - -let rec peek state : Token_triple.t = - if state.cur >= state.len then - let _, posa, posb = state.tokens.(state.cur - 1) in - (EOF, posa, posb) - else - let ((t, _, _) as res) = state.tokens.(state.cur) in - if t = NEWLINE then ( - bump_any state; - peek state) - else res - type directive = (string * string) list -let parse_directive state : directive = - let parse_entry start s = - Basic_strutil.split_on_first ':' - (String.sub s start (String.length s - start)) - in - let rec go acc = - match peek state with - | COMMENT s, _, _ when String.starts_with s.content ~prefix:"//!" -> - bump_any state; - go - (let k, v = parse_entry 3 s.content in - (k, v) :: acc) - | _ -> acc - in - List.rev (go []) - -let parse (tokens : Vec_token.t) : directive * int = - let state : state = - { - cur = 0; - tokens = Vec.unsafe_internal_array tokens; - len = Vec.length tokens; - } - in - let directive = parse_directive state in - (directive, state.cur) +let parse_directive segment = + (let parse_entry start s = + Basic_strutil.split_on_first ':' + (String.sub s start (String.length s - start)) + in + let rec go acc = + match Parsing_segment.peek ~comment:true segment with + | COMMENT s, _, _ when String.starts_with s.content ~prefix:"//!" -> + Parsing_segment.skip ~comment:true segment; + go + (let k, v = parse_entry 3 s.content in + (k, v) :: acc) + | _ -> acc + in + List.rev (go []) + : directive) + +let parse (segment : Parsing_segment.t) = (parse_directive segment : directive) diff --git a/src/parsing_import_path.ml b/src/parsing_import_path.ml index 469f8db..85947f1 100644 --- a/src/parsing_import_path.ml +++ b/src/parsing_import_path.ml @@ -44,7 +44,8 @@ let default_abbrev s = | None -> s | Some x -> String.sub s (x + 1) (s_len - x - 1) -let parse (s : string) : t = - match Basic_strutil.split_on_last ':' s with - | "", s -> { path = s; alias = None } - | path, alias -> { path; alias = Some alias } +let parse (s : string) = + (match Basic_strutil.split_on_last ':' s with + | "", s -> { path = s; alias = None } + | path, alias -> { path; alias = Some alias } + : t) diff --git a/src/parsing_interp.ml b/src/parsing_interp.ml index 3254d6a..b14e282 100644 --- a/src/parsing_interp.ml +++ b/src/parsing_interp.ml @@ -19,11 +19,12 @@ module Segment = Parsing_segment module Syntax = Parsing_syntax module Menhir_token = Lex_menhir_token module Parser = Parsing_parser +module Parser_main = Parsing_main let menhir_parse ~loc_ ~diagnostics ~base segment = let lexbuf : Lexing.lexbuf = Lexing.from_string "" in - let lexer (lexbuf : Lexing.lexbuf) : Menhir_token.token = - Segment.next_with_lexbuf_update segment lexbuf + let lexer (lexbuf : Lexing.lexbuf) = + (Segment.next_with_lexbuf_update segment lexbuf : Menhir_token.token) in Parsing_menhir_state.initialize_base_pos base; try Parser.expression lexer lexbuf @@ -41,9 +42,20 @@ let expr_of_interp ~diagnostics ~base ({ source; loc_ } : Literal.interp_source) ~name:start_pos.pos_fname source ~comment:false ~diagnostics in let segment = - match Segment.toplevel_segments tokens with + match Toplevel_segments.toplevel_segments tokens with | segment :: [] -> segment | _ -> assert false in let loc_ = Rloc.of_loc ~base loc_ in - menhir_parse ~loc_ ~diagnostics ~base segment + match Basic_config.current_parser () with + | `Menhir -> menhir_parse ~loc_ ~diagnostics ~base segment + | `Handrolled -> Parser_main.parse_expression ~diagnostics segment + | `Both -> + let menhir_diag = Diagnostics.make () in + let menhir_ast = + menhir_parse ~loc_ ~diagnostics:menhir_diag ~base segment + in + if not (Diagnostics.has_fatal_errors menhir_diag) then ( + Diagnostics.merge_into diagnostics menhir_diag; + menhir_ast) + else Parser_main.parse_expression ~diagnostics segment diff --git a/src/parsing_main.ml b/src/parsing_main.ml new file mode 100644 index 0000000..93e8539 --- /dev/null +++ b/src/parsing_main.ml @@ -0,0 +1,3780 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Parser_core = Parsing_core +module Parser_util = Parsing_util +module Compact = Parsing_compact +module Syntax = Parsing_syntax +module Menhir_token = Lex_menhir_token +module Longident = Basic_longident +module Vec = Basic_vec +module Lst = Basic_lst + +type parse_state = Parser_core.parse_state +type position = Parser_core.position +type token = Menhir_token.token + +type token_kind = Menhir_token.token_kind = + | Token_kind : _ Menhir_token.terminal -> token_kind +[@@unboxed] + +let loc_of_expression = Syntax.loc_of_expression +and loc_of_pattern = Syntax.loc_of_pattern +and loc_of_type_expression = Syntax.loc_of_type_expression + +let add_error = Parser_core.add_error +and add_error_failed_to_parse = Parser_core.add_error_failed_to_parse +and add_error_skipped = Parser_core.add_error_skipped +and add_error_unexpected = Parser_core.add_error_unexpected +and debugged = Parser_core.debugged +and expected_dot_int = Parser_core.expected_dot_int +and expected_dot_lident = Parser_core.expected_dot_lident +and expected_dot_uident = Parser_core.expected_dot_uident +and expected_lident = Parser_core.expected_lident +and expected_uident = Parser_core.expected_uident +and expected_pkg_name = Parser_core.expected_pkg_name +and expected_int = Parser_core.expected_int +and expected_string = Parser_core.expected_string +and expected_token = Parser_core.expected_token +and get_mode = Parser_core.get_mode +and loc_start_with = Parser_core.loc_start_with +and located = Parser_core.located +and option = Parser_core.option +and parser_panic = Parser_core.parser_panic +and peek_location = Parser_core.peek_location +and peek_loc_start = Parser_core.peek_loc_start +and peek_loc_end = Parser_core.peek_loc_end +and peek_nth_token = Parser_core.peek_nth_token +and peek_nth_token_kind = Parser_core.peek_nth_token_kind +and peek_token = Parser_core.peek_token +and get_absolute_loc = Parser_core.get_absolute_loc +and pop_sync = Parser_core.pop_sync +and push_sync = Parser_core.push_sync +and sepby = Parser_core.sepby +and sepby1 = Parser_core.sepby1 +and sepby_with_follow = Parser_core.sepby_with_follow +and skip_this = Parser_core.skip_this +and surround = Parser_core.surround +and surround_sepby = Parser_core.surround_sepby +and with_follow = Parser_core.with_follow +and with_sync = Parser_core.with_sync +and with_syncs = Parser_core.with_syncs + +let first_qual_lident : token_kind list = + [ Token_kind T_LIDENT; Token_kind T_PACKAGE_NAME ] + +let first_qual_luident : token_kind list = + [ Token_kind T_LIDENT; Token_kind T_UIDENT; Token_kind T_PACKAGE_NAME ] + +let first_luident : token_kind list = + [ Token_kind T_LIDENT; Token_kind T_UIDENT ] + +let first_constr : token_kind list = + [ Token_kind T_LIDENT; Token_kind T_UIDENT; Token_kind T_PACKAGE_NAME ] + +let first_impl : token_kind list = + [ + Token_kind T_PUB; + Token_kind T_PRIV; + Token_kind T_TYPE; + Token_kind T_TYPEALIAS; + Token_kind T_ASYNC; + Token_kind T_FN; + Token_kind T_STRUCT; + Token_kind T_ENUM; + Token_kind T_LET; + Token_kind T_CONST; + Token_kind T_EXTERN; + Token_kind T_TEST; + Token_kind T_IMPL; + Token_kind T_TRAIT; + Token_kind T_TRAITALIAS; + ] + +let first_simple_expr : token_kind list = + [ + Token_kind T_TRUE; + Token_kind T_FALSE; + Token_kind T_INT; + Token_kind T_FLOAT; + Token_kind T_CHAR; + Token_kind T_STRING; + Token_kind T_MULTILINE_STRING; + Token_kind T_BYTE; + Token_kind T_INTERP; + Token_kind T_PACKAGE_NAME; + Token_kind T_ASYNC; + Token_kind T_FN; + Token_kind T_LIDENT; + Token_kind T_UIDENT; + Token_kind T_LPAREN; + Token_kind T_LBRACKET; + Token_kind T_LBRACE; + Token_kind T_UNDERSCORE; + ] + +let first_expr : token_kind list = + [ + Token_kind T_IF; + Token_kind T_MATCH; + Token_kind T_PLUS; + Token_kind T_MINUS; + Token_kind T_LOOP; + Token_kind T_WHILE; + Token_kind T_FOR; + Token_kind T_POST_LABEL; + Token_kind T_GUARD; + Token_kind T_TRY; + ] + @ first_simple_expr + +let first_map_pattern_key : token_kind list = + [ + Token_kind T_TRUE; + Token_kind T_FALSE; + Token_kind T_CHAR; + Token_kind T_INT; + Token_kind T_FLOAT; + Token_kind T_MINUS; + Token_kind T_STRING; + ] + +let first_type : token_kind list = + [ + Token_kind T_PACKAGE_NAME; + Token_kind T_LIDENT; + Token_kind T_UIDENT; + Token_kind T_LPAREN; + Token_kind T_UNDERSCORE; + ] + +let parse_optional_bang (state : parse_state) = + (match peek_token state with + | EXCLAMATION -> + let loc = peek_location state in + skip_this state; + Some loc + | _ -> None + : Rloc.t option) + +let rec parse_attributes (state : parse_state) = + (match peek_token state with + | ATTRIBUTE content -> + let loc_ = peek_location state in + skip_this state; + Parsing_util.make_attribute ~loc_ content :: parse_attributes state + | _ -> [] + : Attribute.t list) + +let rec parse_toplevel (state : parse_state) = + (debugged "toplevel" state (fun state -> + match get_mode state with + | Normal -> + let res = ref [] in + push_sync state (Token_kind T_EOF); + let rec loop () = + if get_mode state = Normal && peek_token state <> EOF then ( + let top = + with_syncs state first_impl (fun s -> + Parsing_core.update_base state; + parse_top s) + in + res := top :: !res; + match peek_token state with + | SEMI _ -> + expected_token (Token_kind T_SEMI) state; + loop () + | PUB | PRIV | TYPE | TYPEALIAS | TRAIT | TRAITALIAS | ASYNC | FN + | STRUCT | ENUM | LET | CONST | EXTERN | TEST | IMPL -> + loop () + | EOF -> + pop_sync state (Token_kind T_EOF); + expected_token (Token_kind T_EOF) state + | other -> + let loc_ = with_syncs state first_impl parser_panic in + add_error_unexpected state other first_impl loc_; + loop ()) + in + loop (); + List.rev !res + | Panic { loc; _ } -> + add_error_skipped state "toplevel" loc; + []) + : Syntax.impl list) + +and parse_expression ~diagnostics segment = + (let state = Parser_core.init_state ~diagnostics segment in + with_sync state (Token_kind T_EOF) parse_expr + : Syntax.expr) + +and parse_qual_lident (state : parse_state) = + (debugged "qual_lident" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | LIDENT _ -> + let id = expected_lident state in + Lident id + | PACKAGE_NAME _ -> + let pkg = expected_pkg_name state in + let id = expected_dot_lident state in + Ldot { pkg; id } + | other -> + let other_loc = peek_location state in + add_error_unexpected state other first_qual_lident other_loc; + let _ = parser_panic state in + Lident "?qual_lident") + | Panic { loc; _ } -> + add_error_skipped state "qual_lident" loc; + Lident "?qual_lident" + : Longident.t)) + : Longident.t) + +and parse_qual_luident (state : parse_state) = + (debugged "qual_luident" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | LIDENT _ -> + let id = expected_lident state in + Lident id + | UIDENT _ -> + let id = expected_uident state in + Lident id + | PACKAGE_NAME _ -> ( + let pkg = expected_pkg_name state in + match peek_token state with + | DOT_LIDENT id | DOT_UIDENT id -> + skip_this state; + Ldot { pkg; id } + | other -> + let other_loc = peek_location state in + add_error_unexpected state other + [ Token_kind T_DOT_LIDENT; Token_kind T_DOT_UIDENT ] + other_loc; + let _ = parser_panic state in + Lident "?qual_luident") + | other -> + let other_loc = peek_location state in + add_error_unexpected state other first_qual_luident other_loc; + let _ = parser_panic state in + Lident "?qual_luident") + | Panic { loc; _ } -> + add_error_skipped state "qual_luident" loc; + Lident "?qual_luident" + : Longident.t)) + : Longident.t) + +and parse_luident (state : parse_state) = + (debugged "luident" state (fun state -> + match get_mode state with + | Normal -> ( + match peek_token state with + | LIDENT _ -> expected_lident state + | UIDENT _ -> expected_uident state + | other -> + let other_loc = peek_location state in + add_error_unexpected state other first_luident other_loc; + let _ = parser_panic state in + "?luident") + | Panic { loc; _ } -> + add_error_skipped state "luident" loc; + "?luident") + : string) + +and parse_binder (state : parse_state) = + (debugged "binder" state (fun state -> + (match get_mode state with + | Normal -> + let loc_ = peek_location state in + let binder_name = expected_lident state in + { binder_name; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "binder" loc; + { binder_name = "?binder"; loc_ = loc } + : Syntax.binder)) + : Syntax.binder) + +and parse_type_name (state : parse_state) = + (debugged "type_name" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let is_object = + match peek_token state with + | AMPER -> + skip_this state; + true + | _ -> false + in + let name = parse_qual_luident state in + let loc_ = loc_start_with state loc_start in + { name; is_object; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "type_name" loc; + { name = Lident "?type_name"; is_object = false; loc_ = loc } + : Syntax.type_name)) + : Syntax.type_name) + +and parse_fun_binder (state : parse_state) = + (debugged "fun_binder" state (fun state -> + match get_mode state with + | Normal -> ( + let parse_qual_with_coloncolon state = + let type_name = parse_type_name state in + expected_token (Token_kind T_COLONCOLON) state; + let loc_func_name = peek_location state in + let func_name = expected_lident state in + ( Some type_name, + ({ binder_name = func_name; loc_ = loc_func_name } + : Syntax.binder) ) + in + match peek_token state with + | PACKAGE_NAME _ | UIDENT _ | AMPER -> + parse_qual_with_coloncolon state + | LIDENT _ when peek_nth_token_kind state 1 = Token_kind T_COLONCOLON + -> + parse_qual_with_coloncolon state + | LIDENT _ -> + let id = parse_binder state in + (None, id) + | t -> + let loc_ = parser_panic state in + add_error_unexpected state t first_qual_luident loc_; + (None, { binder_name = "?fun_binder"; loc_ })) + | Panic { loc; _ } -> + add_error_skipped state "fun_binder" loc; + (None, { binder_name = "?fun_binder"; loc_ = loc })) + : Syntax.type_name option * Syntax.binder) + +and parse_var (state : parse_state) = + (debugged "var" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let var_name = parse_qual_lident state in + let loc_ = loc_start_with state loc_start in + { var_name; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "var" loc; + { var_name = Lident "?qual_lident"; loc_ = loc } + : Syntax.var)) + : Syntax.var) + +and parse_tvar_binder (state : parse_state) = + (debugged "tvar_binder" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let tvar_name = parse_luident state in + let loc_ = loc_start_with state loc_start in + let tvar_constraints = + option [ Token_kind T_COLON ] + (fun state -> + expected_token (Token_kind T_COLON) state; + (sepby1 (Token_kind T_PLUS) (fun state -> + (let loc_ = peek_location state in + let tvc_trait : Longident.t = + match peek_token state with + | UIDENT _ -> ( + let id = expected_uident state in + match peek_token state with + | QUESTION -> + skip_this state; + Lident (id ^ "?") + | _ -> Lident id) + | _ -> parse_qual_luident state + in + { tvc_trait; loc_ } + : Syntax.tvar_constraint))) + state) + state + in + let tvar_constraints = Option.value ~default:[] tvar_constraints in + { tvar_name; tvar_constraints; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "tvar binder" loc; + { tvar_name = "?tvar_name"; tvar_constraints = []; loc_ = loc } + : Syntax.tvar_binder)) + : Syntax.tvar_binder) + +and parse_type_decl_binder (state : parse_state) = + (debugged "type_decl_binder" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let tvar_name = + match peek_token state with + | UNDERSCORE -> + skip_this state; + None + | _ -> Some (parse_luident state) + in + let loc_ = loc_start_with state loc_start in + { tvar_name; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "tvar binder" loc; + { tvar_name = None; loc_ = loc } + : Syntax.type_decl_binder)) + : Syntax.type_decl_binder) + +and parse_constr (state : parse_state) = + (debugged "constr" state (fun state -> + (match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + match peek_token state with + | UIDENT _ + when peek_nth_token_kind state 1 <> Token_kind T_COLONCOLON -> + let loc_ = peek_location state in + let str = parse_luident state in + let loc_constr = loc_start_with state loc_start in + { + constr_name = { name = str; loc_ }; + extra_info = No_extra_info; + loc_ = loc_constr; + } + | PACKAGE_NAME pkg + when peek_nth_token_kind state 1 = Token_kind T_DOT_UIDENT + && peek_nth_token_kind state 2 <> Token_kind T_COLONCOLON -> + skip_this state; + let constr_name : Syntax.constr_name = + let loc_start = peek_loc_start state in + let name = Parser_core.expected_dot_uident state in + { name; loc_ = loc_start_with state loc_start } + in + let loc_ = loc_start_with state loc_start in + { constr_name; extra_info = Package pkg; loc_ } + | LIDENT _ | UIDENT _ | PACKAGE_NAME _ | AMPER -> + let type_name = parse_type_name state in + expected_token (Token_kind T_COLONCOLON) state; + let right_loc = peek_location state in + let right = Parser_core.expected_uident ~default:"" state in + let loc_ = loc_start_with state loc_start in + { + constr_name = { name = right; loc_ = right_loc }; + extra_info = Type_name type_name; + loc_; + } + | other -> + let other_loc = peek_location state in + add_error_unexpected state other first_constr other_loc; + let loc_ = parser_panic state in + { + constr_name = { name = "?constr"; loc_ }; + extra_info = No_extra_info; + loc_; + }) + | Panic { loc; _ } -> + add_error_skipped state "constr" loc; + { + constr_name = { name = "?constr"; loc_ = loc }; + extra_info = No_extra_info; + loc_ = loc; + } + : Syntax.constructor)) + : Syntax.constructor) + +and parse_opt_typ_params (state : parse_state) = + (debugged "typ_params" state (fun state -> + match get_mode state with + | Normal -> ( + let res = + option [ Token_kind T_LBRACKET ] + (Parsing_core.surround_sepby (Token_kind T_LBRACKET) + (Token_kind T_RBRACKET) (Token_kind T_COMMA) parse_tvar_binder) + state + in + match res with Some xs -> xs | None -> []) + | Panic { loc; _ } -> + add_error_skipped state "typ_params" loc; + []) + : Syntax.tvar_binder list) + +and parse_opt_typ_params_no_constraints (state : parse_state) = + (debugged "typ_params" state (fun state -> + match get_mode state with + | Normal -> ( + let res = + option [ Token_kind T_LBRACKET ] + (surround_sepby (Token_kind T_LBRACKET) (Token_kind T_RBRACKET) + (Token_kind T_COMMA) parse_type_decl_binder) + state + in + match res with Some xs -> xs | None -> []) + | Panic { loc; _ } -> + add_error_skipped state "typ_params" loc; + []) + : Syntax.type_decl_binder list) + +and parse_local_type_decl (state : parse_state) = + (debugged "local_type_decl" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | STRUCT -> + expected_token (Token_kind T_STRUCT) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let fs = + Parsing_core.surround_sepby + ~invalid_delims:[ Token_kind T_COMMA ] (Token_kind T_LBRACE) + (Token_kind T_RBRACE) (Token_kind T_SEMI) parse_field_decl + state + in + let deriving_ = parse_deriving_directive_list state in + { + local_tycon = tycon; + local_tycon_loc_ = tycon_loc_; + local_components = Ptd_record fs; + deriving_; + } + | ENUM -> + expected_token (Token_kind T_ENUM) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let cs = + surround_sepby ~invalid_delims:[ Token_kind T_COMMA ] + (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_constr_decl state + in + let deriving_ = parse_deriving_directive_list state in + { + local_tycon = tycon; + local_tycon_loc_ = tycon_loc_; + local_components = Ptd_variant cs; + deriving_; + } + | TYPE -> + expected_token (Token_kind T_TYPE) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let typ = parse_type state in + let deriving_ = parse_deriving_directive_list state in + { + local_tycon = tycon; + local_tycon_loc_ = tycon_loc_; + local_components = Ptd_newtype typ; + deriving_; + } + | other -> + let other_loc = peek_location state in + add_error_unexpected state other + [ Token_kind T_STRUCT; Token_kind T_ENUM ] + other_loc; + let loc_ = parser_panic state in + { + local_tycon = "?local_tycon"; + local_tycon_loc_ = loc_; + local_components = Ptd_variant []; + deriving_ = []; + }) + | Panic { loc; _ } -> + add_error_skipped state "local_type_decl" loc; + { + local_tycon = "?local_tycon"; + local_tycon_loc_ = loc; + local_components = Ptd_variant []; + deriving_ = []; + } + : Syntax.local_type_decl)) + : Syntax.local_type_decl) + +and parse_fun_decl ~attrs (state : parse_state) = + (debugged "fun_decl" state (fun state -> + (match get_mode state with + | Normal -> + let is_async = + match peek_token state with + | ASYNC -> + skip_this state; + true + | _ -> false + in + expected_token (Menhir_token.kind_of_token FN) state; + let type_name, name = parse_fun_binder state in + let has_error = parse_optional_bang state in + let quantifiers = parse_opt_typ_params state in + let param_loc_start = peek_loc_start state in + let decl_params = + option [ Token_kind T_LPAREN ] + (surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_parameter) + state + in + let params_loc_ = loc_start_with state param_loc_start in + let return_type = + option + [ Token_kind T_THIN_ARROW ] + (fun state -> + expected_token (Token_kind T_THIN_ARROW) state; + let res = parse_return_type state in + res) + state + in + { + name; + has_error; + is_async; + type_name; + quantifiers; + params_loc_; + decl_params; + return_type; + vis = Vis_default; + doc_ = Docstring.empty; + attrs; + } + | Panic { loc; _ } -> + add_error_skipped state "fun_decl" loc; + { + name = { binder_name = "???"; loc_ = loc }; + has_error = None; + is_async = false; + type_name = None; + decl_params = Some []; + params_loc_ = loc; + quantifiers = []; + return_type = None; + vis = Vis_default; + doc_ = Docstring.empty; + attrs; + } + : Syntax.fun_decl)) + : Syntax.fun_decl) + +and parse_trait_method_decl (state : parse_state) = + (debugged "trait_method_decl" state (fun state -> + match get_mode state with + | Normal -> + let loc_start = Parser_core.peek_loc_start state in + push_sync state (Token_kind T_LPAREN); + let func_name = parse_binder state in + let has_error = parse_optional_bang state in + let quantifiers = parse_opt_typ_params state in + pop_sync state (Token_kind T_LPAREN); + expected_token (Token_kind T_LPAREN) state; + let params, _ = + sepby_with_follow (Token_kind T_COMMA) [ Token_kind T_RPAREN ] + (fun state -> + (match peek_token state with + | POST_LABEL label_name as tok -> + let label : Syntax.label = + let label_loc = + match tok with + | POST_LABEL _ -> + Rloc.trim_last_char (peek_location state) + | _ -> assert false + in + skip_this state; + { label_name; loc_ = label_loc } + in + expected_token (Token_kind T_COLON) state; + let typ = parse_type state in + { tmparam_label = Some label; tmparam_typ = typ } + | _ -> + let typ = parse_type state in + { tmparam_label = None; tmparam_typ = typ } + : Syntax.trait_method_param)) + state + in + expected_token (Token_kind T_RPAREN) state; + let return_type = + match peek_token state with + | THIN_ARROW -> + expected_token (Token_kind T_THIN_ARROW) state; + let t = parse_return_type state in + Some t + | _ -> None + in + let loc_ = loc_start_with state loc_start in + Syntax.Trait_method + { + name = func_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + return_type; + loc_; + } + | Panic { loc; _ } -> + add_error_skipped state "trait_method_decl" loc; + Trait_method + { + name = { binder_name = "?"; loc_ = loc }; + has_error = false; + quantifiers = []; + params = []; + return_type = None; + loc_ = loc; + }) + : Syntax.trait_method_decl) + +and parse_trait_decl ~attrs ~(vis : Syntax.visibility) (state : parse_state) = + (debugged "trait_decl" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_TRAIT) state; + let name = parse_luident state in + let loc_ = peek_location state in + let supers = + match peek_token state with + | COLON -> + skip_this state; + with_follow [ Token_kind T_LBRACE ] + (sepby1 (Token_kind T_PLUS) (fun state -> + (let loc_ = peek_location state in + let tvc_trait = parse_qual_luident state in + { tvc_trait; loc_ } + : Syntax.tvar_constraint))) + state + | _ -> [] + in + expected_token (Token_kind T_LBRACE) state; + let methods, _ = + sepby_with_follow (Token_kind T_SEMI) [ Token_kind T_RBRACE ] + parse_trait_method_decl state + in + expected_token (Token_kind T_RBRACE) state; + let trait_loc_ = loc_start_with state loc_start in + let trait_name : Syntax.binder = { binder_name = name; loc_ } in + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = get_absolute_loc state trait_loc_; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + | Panic { loc; _ } -> + add_error_skipped state "trait_decl" loc; + { + trait_name = { binder_name = "?"; loc_ = loc }; + trait_supers = []; + trait_methods = []; + trait_vis = Vis_default; + trait_loc_ = get_absolute_loc state loc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Syntax.trait_decl)) + : Syntax.trait_decl) + +and parse_visibility (state : parse_state) = + (debugged "visibility" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | PRIV -> + let loc_ = peek_location state in + expected_token (Token_kind T_PRIV) state; + Vis_priv { loc_ } + | PUB -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_PUB) state; + let pub_attr = + option [ Token_kind T_LPAREN ] + (surround (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (fun state -> + match peek_token state with + | READONLY -> + skip_this state; + "readonly" + | LIDENT attr -> + skip_this state; + attr + | tok -> + let loc = peek_location state in + let _ = parser_panic state in + add_error_unexpected state tok + [ Token_kind T_READONLY; Token_kind T_LIDENT ] + loc; + "")) + state + in + let loc_ = loc_start_with state loc_start in + Vis_pub { attr = pub_attr; loc_ } + | _ -> Vis_default) + | Panic { loc; _ } -> + add_error_skipped state "visibility" loc; + Vis_default + : Syntax.visibility)) + : Syntax.visibility) + +and parse_top (state : parse_state) = + (debugged "top" state (fun state -> + (match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + let attrs = parse_attributes state in + let vis = parse_visibility state in + match peek_token state with + | TYPE when peek_nth_token_kind state 1 = Token_kind T_EXCLAMATION + -> + expected_token (Token_kind T_TYPE) state; + expected_token (Token_kind T_EXCLAMATION) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let components : Syntax.type_desc = + match peek_token state with + | LBRACE -> + let cs = + surround_sepby ~invalid_delims:[ Token_kind T_COMMA ] + (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_constr_decl state + in + Ptd_error (Enum_payload cs) + | _ -> + let typ = option first_type parse_type state in + let exception_decl : Syntax.exception_decl = + match typ with + | Some ty -> Single_payload ty + | None -> No_payload + in + Ptd_error exception_decl + in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params = []; + components; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | TYPE -> + expected_token (Token_kind T_TYPE) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let params = parse_opt_typ_params_no_constraints state in + let components : Syntax.type_desc = + match peek_token state with + | SEMI _ | EOF | DERIVE -> Ptd_abstract + | _ -> + let typ = parse_type state in + Ptd_newtype typ + in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | TYPEALIAS -> + skip_this state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let params = parse_opt_typ_params_no_constraints state in + expected_token (Token_kind T_EQUAL) state; + let typ = parse_type state in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_alias typ; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | STRUCT -> + expected_token (Token_kind T_STRUCT) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let params = parse_opt_typ_params_no_constraints state in + let fs = + surround_sepby ~invalid_delims:[ Token_kind T_COMMA ] + (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_field_decl state + in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_record fs; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | ENUM -> + expected_token (Token_kind T_ENUM) state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let params = parse_opt_typ_params_no_constraints state in + let cs = + surround_sepby ~invalid_delims:[ Token_kind T_COMMA ] + (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_constr_decl state + in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_variant cs; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | LET | CONST -> + let is_constant, binder = + match peek_token state with + | LET -> + skip_this state; + (false, parse_binder state) + | CONST -> + skip_this state; + let loc_ = peek_location state in + let binder_name = expected_uident state in + (true, { binder_name; loc_ }) + | _ -> assert false + in + let ty = parse_opt_annot state in + expected_token (Token_kind T_EQUAL) state; + let expr = parse_expr state in + let loc_ = loc_start_with state loc_start in + Ptop_letdef + { + binder; + ty; + expr; + is_constant; + vis; + loc_ = get_absolute_loc state loc_; + doc_ = Docstring.empty; + attrs; + } + | EXTERN when peek_nth_token_kind state 1 = Token_kind T_TYPE -> + skip_this state; + skip_this state; + let tycon, tycon_loc_ = + let loc_ = peek_location state in + let res = parse_luident state in + (res, loc_) + in + let params = parse_opt_typ_params_no_constraints state in + let deriving_ = parse_deriving_directive_list state in + let loc_ = loc_start_with state loc_start in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_extern; + type_vis = vis; + doc_ = Docstring.empty; + deriving_; + loc_ = get_absolute_loc state loc_; + attrs; + } + | EXTERN -> ( + expected_token (Token_kind T_EXTERN) state; + let language = expected_string state in + let fun_decl = parse_fun_decl ~attrs state in + let fun_decl = { fun_decl with vis } in + expected_token (Token_kind T_EQUAL) state; + match peek_token state with + | MULTILINE_STRING _ -> + let rec loop xs = + match peek_token state with + | MULTILINE_STRING x -> + expected_token (Token_kind T_MULTILINE_STRING) state; + loop (x :: xs) + | _ -> xs + in + let xs = loop [] in + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = + Decl_stubs + (Embedded + { + language = Some language; + code = Code_multiline_string (List.rev xs); + }); + loc_ = get_absolute_loc state loc_; + } + | _ -> + let body = expected_string state in + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = + Decl_stubs + (Embedded + { + language = Some language; + code = Code_string body; + }); + loc_ = get_absolute_loc state loc_; + }) + | ASYNC | FN -> ( + let fun_decl = parse_fun_decl ~attrs state in + let fun_decl = { fun_decl with vis } in + match peek_token state with + | EQUAL -> ( + expected_token (Token_kind T_EQUAL) state; + match peek_token state with + | MULTILINE_STRING _ -> + let rec loop xs = + match peek_token state with + | MULTILINE_STRING x -> + expected_token (Token_kind T_MULTILINE_STRING) + state; + loop (x :: xs) + | _ -> xs + in + let xs = loop [] in + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = + Decl_stubs + (Embedded + { + language = None; + code = Code_multiline_string (List.rev xs); + }); + loc_ = get_absolute_loc state loc_; + } + | _ -> ( + let name1 = expected_string state in + match peek_token state with + | STRING name2 -> + let _ = expected_string state in + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = + Decl_stubs + (Import + { + module_name = name1; + func_name = name2; + }); + loc_ = get_absolute_loc state loc_; + } + | _ -> + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = + Decl_stubs + (Embedded + { + language = None; + code = Code_string name1; + }); + loc_ = get_absolute_loc state loc_; + })) + | _ -> + let local_types, body = + parse_block_expr_with_local_types state + in + let loc_ = loc_start_with state loc_start in + Ptop_funcdef + { + fun_decl; + decl_body = Decl_body { expr = body; local_types }; + loc_ = get_absolute_loc state loc_; + }) + | TRAIT -> Ptop_trait (parse_trait_decl ~attrs ~vis state) + | TRAITALIAS -> + skip_this state; + let binder : Syntax.binder = + let loc_ = peek_location state in + let binder_name = parse_luident state in + { binder_name; loc_ } + in + expected_token (Token_kind T_EQUAL) state; + let target = parse_type_name state in + let loc_ = loc_start_with state loc_start in + Ptop_trait_alias + { + binder; + target; + vis; + loc_ = get_absolute_loc state loc_; + attrs; + doc_ = Docstring.empty; + } + | TEST -> + skip_this state; + let name = + match peek_token state with + | STRING _ -> + let name_loc = peek_location state in + let v = expected_string state in + Some ({ v; loc_ = name_loc } : _ Rloc.loced) + | _ -> None + in + let params = + match peek_token state with + | LPAREN -> + let params = + surround_sepby (Token_kind T_LPAREN) + (Token_kind T_RPAREN) (Token_kind T_COMMA) + parse_parameter state + in + Some params + | _ -> None + in + let local_types, expr = + parse_block_expr_with_local_types state + in + let loc_ = loc_start_with state loc_start in + Ptop_test + { + name; + params; + expr; + local_types; + loc_ = get_absolute_loc state loc_; + doc_ = Docstring.empty; + attrs; + } + | IMPL -> ( + skip_this state; + push_sync state (Token_kind T_WITH); + push_sync state (Token_kind T_FOR); + let quantifiers = parse_opt_typ_params state in + let trait = parse_type_name state in + pop_sync state (Token_kind T_FOR); + match (get_mode state, peek_token state) with + | Normal, FOR -> + skip_this state; + let self_ty = parse_type state in + pop_sync state (Token_kind T_WITH); + expected_token (Token_kind T_WITH) state; + push_sync state (Token_kind T_LBRACE); + let method_name = parse_binder state in + let has_error = parse_optional_bang state in + let params = + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_parameter state + in + let ret_ty = + option + [ Token_kind T_THIN_ARROW ] + (fun state -> + skip_this state; + parse_return_type state) + state + in + let header_loc_ = loc_start_with state loc_start in + pop_sync state (Token_kind T_LBRACE); + let body : Syntax.decl_body = + match peek_token state with + | EQUAL -> + skip_this state; + let code = expected_string state in + Decl_stubs + (Embedded + { language = None; code = Code_string code }) + | _ -> + let local_types, body = + parse_block_expr_with_local_types state + in + Decl_body { expr = body; local_types } + in + Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = + (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + vis; + body; + loc_ = + get_absolute_loc state + (loc_start_with state loc_start); + header_loc_; + doc_ = Docstring.empty; + attrs; + } + | Normal, WITH -> + pop_sync state (Token_kind T_WITH); + skip_this state; + push_sync state (Token_kind T_LBRACE); + let method_name = parse_binder state in + let has_error = parse_optional_bang state in + let params = + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_parameter state + in + let ret_ty = + option + [ Token_kind T_THIN_ARROW ] + (fun state -> + skip_this state; + parse_return_type state) + state + in + let header_loc_ = loc_start_with state loc_start in + pop_sync state (Token_kind T_LBRACE); + let body : Syntax.decl_body = + match peek_token state with + | EQUAL -> + skip_this state; + let code = expected_string state in + Decl_stubs + (Embedded + { language = None; code = Code_string code }) + | _ -> + let local_types, body = + parse_block_expr_with_local_types state + in + Decl_body { expr = body; local_types } + in + Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = + (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + vis; + body; + loc_ = + get_absolute_loc state + (loc_start_with state loc_start); + header_loc_; + doc_ = Docstring.empty; + attrs; + } + | Normal, other -> + pop_sync state (Token_kind T_WITH); + let other_loc = peek_location state in + add_error_unexpected state other + [ Token_kind T_FOR; Token_kind T_WITH ] + other_loc; + let header_loc_ = loc_start_with state loc_start in + let _ = parser_panic state in + let loc_ = loc_start_with state loc_start in + Ptop_impl + { + self_ty = None; + trait; + method_name = + { binder_name = "*"; loc_ = Rloc.no_location }; + has_error = false; + quantifiers = []; + params = []; + ret_ty = None; + vis; + body = + Decl_body + { + expr = + Pexpr_hole + { + loc_ = Rloc.no_location; + kind = Synthesized; + }; + local_types = []; + }; + loc_ = get_absolute_loc state loc_; + header_loc_; + doc_ = Docstring.empty; + attrs; + } + | Panic { loc = loc_; _ }, _ -> + pop_sync state (Token_kind T_WITH); + Ptop_expr + { + expr = Pexpr_hole { loc_; kind = Synthesized }; + is_main = false; + local_types = []; + loc_ = get_absolute_loc state loc_; + }) + | other -> + let other_loc = peek_location state in + add_error_unexpected state other first_impl other_loc; + let loc_ = parser_panic state in + Ptop_expr + { + expr = Pexpr_hole { loc_; kind = Synthesized }; + is_main = false; + local_types = []; + loc_ = get_absolute_loc state loc_; + }) + | Panic { loc; _ } -> + add_error_skipped state "impl" loc; + Ptop_expr + { + expr = Pexpr_hole { loc_ = loc; kind = Synthesized }; + is_main = false; + local_types = []; + loc_ = get_absolute_loc state loc; + } + : Syntax.impl)) + : Syntax.impl) + +and parse_deriving_directive_list (state : parse_state) = + (debugged "deriving_directive_list" state (fun state -> + match get_mode state with + | Normal -> ( + match peek_token state with + | DERIVE -> + skip_this state; + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_deriving_directive state + | _ -> []) + | Panic { loc; _ } -> + add_error_skipped state "deriving_directive" loc; + []) + : Syntax.deriving_directive list) + +and parse_deriving_directive (state : parse_state) = + (let start_loc = peek_loc_start state in + let type_name_ = parse_type_name state in + let args = + match peek_token state with + | LPAREN -> + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_argument state + | _ -> [] + in + { type_name_; args; loc_ = loc_start_with state start_loc } + : Syntax.deriving_directive) + +and parse_field_decl (state : parse_state) = + (debugged "field_decl" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let vis = parse_visibility state in + let mutflag = + option [ Token_kind T_MUTABLE ] + (expected_token (Token_kind T_MUTABLE)) + state + in + let name, name_loc = + let loc_ = peek_location state in + let res = expected_lident state in + (res, loc_) + in + expected_token (Token_kind T_COLON) state; + let typ = parse_type state in + let field_loc_ = loc_start_with state loc_start in + { + field_name = { label = name; loc_ = name_loc }; + field_ty = typ; + field_mut = mutflag <> None; + field_vis = vis; + field_loc_; + } + | Panic { loc; _ } -> + add_error_skipped state "field_decl" loc; + { + field_name = { label = "?field-name"; loc_ = loc }; + field_ty = Ptype_any { loc_ = loc }; + field_mut = false; + field_vis = Vis_default; + field_loc_ = loc; + } + : Syntax.field_decl)) + : Syntax.field_decl) + +and parse_constr_decl (state : parse_state) = + (debugged "constr_decl" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + (match peek_token state with + | PRIV | PUB | READONLY -> + let loc = peek_location state in + skip_this state; + add_error state (Errors.enum_no_individual_visibility loc) + | _ -> ()); + let constr_name_loc = peek_location state in + let name = expected_uident state in + let constr_name : Syntax.constr_name = + { name; loc_ = constr_name_loc } + in + let params = + option [ Token_kind T_LPAREN ] + (surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) (fun state -> + (let cparam_mut = + match peek_token state with + | MUTABLE -> + skip_this state; + true + | _ -> false + in + match peek_token state with + | POST_LABEL label_name as tok -> + let label_loc = + match tok with + | POST_LABEL _ -> + Rloc.trim_last_char (peek_location state) + | _ -> assert false + in + let label : Syntax.label = + { label_name; loc_ = label_loc } + in + skip_this state; + expected_token (Token_kind T_COLON) state; + let typ = parse_type state in + { + cparam_label = Some label; + cparam_mut; + cparam_typ = typ; + } + | _ -> + let typ = parse_type state in + { cparam_label = None; cparam_mut; cparam_typ = typ } + : Syntax.constr_param))) + state + in + let constr_tag = + match peek_token state with + | EQUAL -> + skip_this state; + let tag_loc = peek_location state in + let tag = expected_int state in + Some (tag, tag_loc) + | _ -> None + in + let constr_loc_ = loc_start_with state loc_start in + { constr_name; constr_args = params; constr_tag; constr_loc_ } + | Panic { loc; _ } -> + add_error_skipped state "constr_decl" loc; + { + constr_name = { name = "?constr-name"; loc_ = loc }; + constr_args = None; + constr_tag = None; + constr_loc_ = loc; + } + : Syntax.constr_decl)) + : Syntax.constr_decl) + +and parse_pattern (state : parse_state) = + (debugged "pattern" state (fun state -> + match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let pat = parse_or_pattern state in + let rec loop pat = + match peek_token state with + | AS -> + expected_token (Token_kind T_AS) state; + let binder = parse_binder state in + let loc_ = loc_start_with state loc_start in + loop (Syntax.Ppat_alias { pat; alias = binder; loc_ }) + | _ -> pat + in + loop pat + | Panic { loc; _ } -> + add_error_skipped state "pattern" loc; + Ppat_any { loc_ = loc }) + : Syntax.pattern) + +and parse_or_pattern (state : parse_state) = + (debugged "or pattern" state (fun state -> + match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + let pat = parse_range_pattern state in + match peek_token state with + | BAR -> + expected_token (Token_kind T_BAR) state; + let pat2 = parse_or_pattern state in + let loc_ = loc_start_with state loc_start in + Syntax.Ppat_or { pat1 = pat; pat2; loc_ } + | _ -> pat) + | Panic { loc; _ } -> + add_error_skipped state "pattern" loc; + Ppat_any { loc_ = loc }) + : Syntax.pattern) + +and parse_range_pattern (state : parse_state) = + (debugged "range pattern" state (fun state -> + match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + let lhs = parse_simple_pattern state in + match peek_token state with + | RANGE_INCLUSIVE -> + skip_this state; + let rhs = parse_simple_pattern state in + let loc_ = loc_start_with state loc_start in + Syntax.Ppat_range { lhs; rhs; inclusive = true; loc_ } + | RANGE_EXCLUSIVE -> + skip_this state; + let rhs = parse_simple_pattern state in + let loc_ = loc_start_with state loc_start in + Syntax.Ppat_range { lhs; rhs; inclusive = false; loc_ } + | _ -> lhs) + | Panic { loc; _ } -> + add_error_skipped state "pattern" loc; + Ppat_any { loc_ = loc }) + : Syntax.pattern) + +and parse_simple_pattern (state : parse_state) = + (debugged "simple_pattern" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | TRUE -> + let loc_ = peek_location state in + expected_token (Token_kind T_TRUE) state; + Ppat_constant { c = Const_bool true; loc_ } + | FALSE -> + let loc_ = peek_location state in + expected_token (Token_kind T_FALSE) state; + Ppat_constant { c = Const_bool false; loc_ } + | CHAR x -> + let loc_ = peek_location state in + expected_token (Token_kind T_CHAR) state; + Ppat_constant { c = Const_char x; loc_ } + | INT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INT) state; + Ppat_constant { c = Parser_util.make_int x; loc_ } + | BYTE x -> + let loc_ = peek_location state in + expected_token (Token_kind T_BYTE) state; + Ppat_constant { c = Const_byte x; loc_ } + | FLOAT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_FLOAT) state; + Ppat_constant { c = Const_double x; loc_ } + | MINUS -> ( + expected_token (Token_kind T_MINUS) state; + match peek_token state with + | INT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INT) state; + Ppat_constant { c = Parser_util.make_int ("-" ^ x); loc_ } + | FLOAT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_FLOAT) state; + Ppat_constant { c = Const_double ("-" ^ x); loc_ } + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other + "`-Int` or `-Float` in simple pattern" other_loc; + let loc_ = parser_panic state in + Ppat_any { loc_ }) + | BYTES x -> + let loc_ = peek_location state in + expected_token (Token_kind T_BYTES) state; + Ppat_constant { c = Const_bytes x; loc_ } + | STRING x -> + let loc_ = peek_location state in + expected_token (Token_kind T_STRING) state; + Ppat_constant { c = Const_string x; loc_ } + | UNDERSCORE -> + let loc_ = peek_location state in + expected_token (Token_kind T_UNDERSCORE) state; + Ppat_any { loc_ } + | LIDENT _ + when peek_nth_token_kind state 1 <> Token_kind T_COLONCOLON -> + let binder = parse_binder state in + Ppat_var binder + | PACKAGE_NAME _ | UIDENT _ | LIDENT _ -> + let loc_start = peek_loc_start state in + let constr = parse_constr state in + let maybe_args = + option [ Token_kind T_LPAREN ] + (surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) (fun state -> + match peek_token state with + | DOTDOT -> + let loc = peek_location state in + skip_this state; + `Dotdot loc + | _ -> `Arg (parse_constr_pat_argument state))) + state + in + let is_open = ref false in + let args = + match maybe_args with + | None -> None + | Some args -> + let rec check_args args = + match args with + | [] -> [] + | `Dotdot _ :: [] -> + is_open := true; + [] + | `Dotdot loc :: args -> + is_open := true; + add_error state + (Errors.dotdot_in_middle_of_pattern ~kind:`Constr + ~loc); + check_args args + | `Arg arg :: args -> arg :: check_args args + in + Some (check_args args) + in + let loc_ = loc_start_with state loc_start in + Ppat_constr { constr; args; is_open = !is_open; loc_ } + | LPAREN -> + located state (fun state -> + surround (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (fun state -> + let first = parse_pattern state in + match peek_token state with + | COMMA -> ( + expected_token (Token_kind T_COMMA) state; + let pats, _ = + sepby_with_follow (Token_kind T_COMMA) + [ Token_kind T_RPAREN ] parse_pattern state + in + match pats with + | [] -> fun _ -> first + | xs -> + fun loc_ -> + Ppat_tuple { pats = first :: xs; loc_ }) + | COLON -> + expected_token (Token_kind T_COLON) state; + let ty = parse_type state in + fun loc_ -> + Ppat_constraint { pat = first; ty; loc_ } + | RPAREN -> fun _ -> first + | other -> + let other_loc = peek_location state in + add_error_unexpected state other + [ + Token_kind T_COMMA; + Token_kind T_COLON; + Token_kind T_RPAREN; + ] + other_loc; + let _ = parser_panic state in + fun _ -> first) + state) + | LBRACKET -> + let loc_start = peek_loc_start state in + let pats1 = Vec.empty () in + let pats2 = Vec.empty () in + let dotdot = ref `No_dotdot in + let _ = + surround_sepby (Token_kind T_LBRACKET) (Token_kind T_RBRACKET) + (Token_kind T_COMMA) + (fun state -> + match peek_token state with + | DOTDOT -> ( + let pat_loc_start = peek_loc_start state in + skip_this state; + let push_pat pat = + if !dotdot = `No_dotdot then Vec.push pats1 pat + else Vec.push pats2 pat + in + match peek_token state with + | STRING s -> + skip_this state; + let pat : Syntax.array_pattern = + String_spread s + in + push_pat pat + | UIDENT _ -> + let id_loc_ = peek_location state in + let binder_name = expected_uident state in + let binder : Syntax.binder = + { binder_name; loc_ = id_loc_ } + in + let loc_ = loc_start_with state pat_loc_start in + let pat : Syntax.array_pattern = + String_spread_const { binder; pkg = None; loc_ } + in + push_pat pat + | PACKAGE_NAME pkg -> + skip_this state; + let id_loc_ = peek_location state in + let binder_name = expected_dot_uident state in + let binder : Syntax.binder = + { binder_name; loc_ = id_loc_ } + in + let loc_ = loc_start_with state pat_loc_start in + let pat : Syntax.array_pattern = + String_spread_const + { binder; pkg = Some pkg; loc_ } + in + push_pat pat + | _ -> ( + match !dotdot with + | `Dotdot_no_binder | `Dotdot_with_binder _ -> + add_error state + (Errors.array_pat_multiple_dotdot + (peek_location state)) + | `No_dotdot -> ( + match peek_token state with + | AS -> + expected_token (Token_kind T_AS) state; + let binder = parse_binder state in + dotdot := `Dotdot_with_binder binder + | LIDENT _ -> + let binder = parse_binder state in + dotdot := `Dotdot_with_binder binder + | _ -> dotdot := `Dotdot_no_binder))) + | _ -> + let pat : Syntax.array_pattern = + Pattern (parse_pattern state) + in + if !dotdot = `No_dotdot then Vec.push pats1 pat + else Vec.push pats2 pat) + state + in + let pats1_list = Vec.to_list pats1 in + let pats2_list = Vec.to_list pats2 in + let pats : Syntax.array_patterns = + match !dotdot with + | `No_dotdot -> Closed pats1_list + | `Dotdot_no_binder -> Open (pats1_list, pats2_list, None) + | `Dotdot_with_binder b -> + Open (pats1_list, pats2_list, Some b) + in + let loc_ = loc_start_with state loc_start in + Ppat_array { pats; loc_ } + | LBRACE -> ( + let loc_start = peek_loc_start state in + let kind : [ `Map | `Record | `Unknown ] ref = ref `Unknown in + expected_token (Token_kind T_LBRACE) state; + push_sync state (Token_kind T_RBRACE); + let field_pat_or_dotdots, _ = + sepby_with_follow (Token_kind T_COMMA) [ Token_kind T_RBRACE ] + (fun state -> + let loc_start = peek_loc_start state in + let parse_map_elem_pat key = + (match !kind with `Unknown -> kind := `Map | _ -> ()); + skip_this state; + let key_loc_ = loc_start_with state loc_start in + let match_absent = + match peek_token state with + | QUESTION -> + skip_this state; + true + | _ -> false + in + expected_token (Token_kind T_COLON) state; + let pat = parse_pattern state in + let loc_ = loc_start_with state loc_start in + `Map_elem + (Syntax.Map_pat_elem + { key; pat; match_absent; key_loc_; loc_ }) + [@@local] + in + match peek_token state with + | DOTDOT -> + let loc = peek_location state in + skip_this state; + `Dotdot loc + | TRUE -> parse_map_elem_pat (Const_bool true) + | FALSE -> parse_map_elem_pat (Const_bool false) + | CHAR x -> parse_map_elem_pat (Const_char x) + | INT x -> parse_map_elem_pat (Parser_util.make_int x) + | FLOAT x -> parse_map_elem_pat (Const_double x) + | MINUS -> ( + expected_token (Token_kind T_MINUS) state; + match peek_token state with + | INT x -> + parse_map_elem_pat + (Parser_util.make_int ("-" ^ x)) + | FLOAT x -> + parse_map_elem_pat (Const_double ("-" ^ x)) + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other + "`-Int` or `-Float` in key of map pattern" + other_loc; + let _ = parser_panic state in + `Error) + | STRING x -> parse_map_elem_pat (Const_string x) + | LIDENT _ -> + (match !kind with + | `Unknown -> kind := `Record + | _ -> ()); + `Field (parse_field_pat state) + | other -> + let expected = + match !kind with + | `Unknown -> + Token_kind T_LIDENT :: first_map_pattern_key + | `Map -> first_map_pattern_key + | `Record -> [ Token_kind T_LIDENT ] + in + add_error_unexpected state other expected + (peek_location state); + let _ = parser_panic state in + `Error) + state + in + pop_sync state (Token_kind T_RBRACE); + expected_token (Token_kind T_RBRACE) state; + let loc_ = loc_start_with state loc_start in + match !kind with + | `Unknown | `Record -> + let rec collect_fields ~has_dotdot acc field_or_dotdots = + (match field_or_dotdots with + | [] -> + Ppat_record + { + fields = List.rev acc; + is_closed = not has_dotdot; + loc_; + } + | `Dotdot loc :: rest -> + if rest <> [] then + add_error state + (Errors.dotdot_in_middle_of_pattern ~kind:`Record + ~loc); + collect_fields ~has_dotdot:true acc rest + | `Field field_pat :: rest -> + collect_fields ~has_dotdot (field_pat :: acc) rest + | `Map_elem (Syntax.Map_pat_elem { loc_; _ }) :: rest -> + add_error state + (Errors.cannot_mix_record_and_map_pat loc_); + collect_fields ~has_dotdot acc rest + | `Error :: rest -> collect_fields ~has_dotdot acc rest + : Syntax.pattern) + in + collect_fields ~has_dotdot:false [] field_pat_or_dotdots + | `Map -> + let rec collect_elems ~has_dotdot acc field_or_dotdots = + (match field_or_dotdots with + | [] -> + let elems = List.rev acc in + Ppat_map { elems; is_closed = not has_dotdot; loc_ } + | `Dotdot loc :: rest -> + if rest <> [] then + add_error state + (Errors.dotdot_in_middle_of_pattern ~kind:`Map + ~loc); + collect_elems ~has_dotdot:true acc rest + | `Field (Syntax.Field_pat { loc_; _ }) :: rest -> + add_error state + (Errors.cannot_mix_record_and_map_pat loc_); + collect_elems ~has_dotdot acc rest + | `Error :: rest -> collect_elems ~has_dotdot acc rest + | `Map_elem elem :: rest -> + collect_elems ~has_dotdot (elem :: acc) rest + : Syntax.pattern) + in + collect_elems ~has_dotdot:false [] field_pat_or_dotdots) + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "simple pattern" other_loc; + let loc_ = parser_panic state in + Ppat_any { loc_ }) + | Panic { loc; _ } -> + add_error_skipped state "simple_pattern" loc; + Ppat_any { loc_ = loc } + : Syntax.pattern)) + : Syntax.pattern) + +and parse_label (state : parse_state) = + (debugged "label" state (fun state -> + (match get_mode state with + | Normal -> + let loc_ = peek_location state in + let label_name = expected_lident state in + { label_name; loc_ } + | Panic { loc; _ } -> { label_name = "?lident"; loc_ = loc } + : Syntax.label)) + : Syntax.label) + +and parse_field_pat (state : parse_state) = + (debugged "filed_pat" state (fun state -> + (match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + let label = parse_label state in + match peek_token state with + | COLON -> + expected_token (Token_kind T_COLON) state; + let pattern = parse_pattern state in + let loc_ = loc_start_with state loc_start in + Field_pat { label; pattern; is_pun = false; loc_ } + | _ -> + let loc_ = loc_start_with state loc_start in + Field_pat + { + label; + pattern = + Ppat_var + { + Syntax.binder_name = label.label_name; + loc_ = label.loc_; + }; + is_pun = true; + loc_; + }) + | Panic { loc; _ } -> + Field_pat + { + label = { label_name = "?ident"; loc_ = loc }; + pattern = Ppat_any { loc_ = loc }; + is_pun = false; + loc_ = loc; + } + : Syntax.field_pat)) + : Syntax.field_pat) + +and parse_constr_pat_argument (state : parse_state) = + (debugged "argument" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | POST_LABEL label_name -> + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + let pat, (kind : Syntax.argument_kind) = + match peek_token state with + | EQUAL -> + skip_this state; + let pat = parse_pattern state in + add_error state + { + loc = label.loc_; + message = + "unexpected `~` in argument. Did you mean \ + `label=pattern` or `label~`?"; + error_code = Error_code.invalid_tilde_argument; + }; + (pat, Labelled label) + | COMMA | RPAREN -> + ( Parser_util.label_to_pat + ~loc_:(Rloc.trim_last_char label.loc_) + label, + Labelled_pun label ) + | _ -> + (Ppat_any { loc_ = peek_location state }, Labelled label) + in + Constr_pat_arg { pat; kind } + | (LIDENT label_name | UIDENT label_name) + when peek_nth_token_kind state 1 = Token_kind T_EQUAL -> + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + skip_this state; + let pat = parse_pattern state in + Constr_pat_arg { pat; kind = Labelled label } + | _ -> + let pat = parse_pattern state in + Constr_pat_arg { pat; kind = Positional }) + | Panic { loc; _ } -> + add_error_skipped state "argument" loc; + Constr_pat_arg { pat = Ppat_any { loc_ = loc }; kind = Positional } + : Syntax.constr_pat_arg)) + : Syntax.constr_pat_arg) + +and is_binop (tok : token) = + (match tok with + | BARBAR | AMPERAMPER | BAR | CARET | AMPER | INFIX1 _ | INFIX2 _ | PLUS + | MINUS | INFIX3 _ | INFIX4 _ -> + true + | _ -> false + : bool) + +and get_binop_prior_assoc (tok : token) = + (match tok with + | BARBAR -> (1, `Right) + | AMPERAMPER -> (2, `Right) + | BAR -> (4, `Left) + | CARET -> (5, `Left) + | AMPER -> (6, `Left) + | INFIX1 _ -> (7, `Left) + | INFIX2 _ -> (8, `Left) + | PLUS | MINUS -> (9, `Left) + | INFIX3 _ -> (10, `Left) + | INFIX4 _ -> (11, `Left) + | _ -> failwith "not a binop!" + : int * [ `Left | `Right | `Nonassoc ]) + +and parse_binop (state : parse_state) = + (debugged "binop" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | BARBAR -> + let loc_ = peek_location state in + expected_token (Token_kind T_BARBAR) state; + { var_name = Lident "||"; loc_ } + | AMPERAMPER -> + let loc_ = peek_location state in + expected_token (Token_kind T_AMPERAMPER) state; + { var_name = Lident "&&"; loc_ } + | BAR -> + let loc_ = peek_location state in + expected_token (Token_kind T_BAR) state; + { var_name = Lident "|"; loc_ } + | CARET -> + let loc_ = peek_location state in + expected_token (Token_kind T_CARET) state; + { var_name = Lident "^"; loc_ } + | AMPER -> + let loc_ = peek_location state in + expected_token (Token_kind T_AMPER) state; + { var_name = Lident "&"; loc_ } + | INFIX1 x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INFIX1) state; + { var_name = Lident x; loc_ } + | INFIX2 x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INFIX2) state; + { var_name = Lident x; loc_ } + | PLUS -> + let loc_ = peek_location state in + expected_token (Token_kind T_PLUS) state; + { var_name = Lident "+"; loc_ } + | MINUS -> + let loc_ = peek_location state in + expected_token (Token_kind T_MINUS) state; + { var_name = Lident "-"; loc_ } + | INFIX3 x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INFIX3) state; + { var_name = Lident x; loc_ } + | INFIX4 x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INFIX4) state; + { var_name = Lident x; loc_ } + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "binary operator" + other_loc; + let loc_ = parser_panic state in + { var_name = Lident "?binop"; loc_ }) + | Panic { loc; _ } -> + add_error_skipped state "binop" loc; + { var_name = Lident "?binop"; loc_ = loc } + : Syntax.var)) + : Syntax.var) + +and parse_loop_expr (state : parse_state) label = + (let loc_start = peek_loc_start state in + skip_this state; + let args = + with_follow [ Token_kind T_LBRACE ] + (fun state -> sepby1 (Token_kind T_COMMA) parse_expr state) + state + in + let loop_loc_ = Rloc.of_pos (loc_start, peek_loc_end state) in + let body = + match get_mode state with + | Normal -> parse_match_fn_body state + | Panic _ -> [] + in + let loc_ = loc_start_with state loc_start in + Pexpr_loop { args; body; loop_loc_; loc_; label } + : Syntax.expr) + +and parse_for_expr (state : parse_state) label = + (let loc_start = peek_loc_start state in + skip_this state; + let handle_error expected = + (let loc = peek_location state in + let token = peek_token state in + add_error_unexpected state token expected loc; + push_sync state (Token_kind T_LBRACE); + let _ = parser_panic state in + pop_sync state (Token_kind T_LBRACE); + let body = parse_block_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_for + { + binders = []; + condition = None; + continue_block = []; + body; + for_else = None; + loc_; + label; + } + : Syntax.expr) + [@@inline] + in + match peek_token state with + | SEMI _ | LBRACE -> parse_for_loop state ~loc_start label + | UNDERSCORE | IN -> parse_foreach_loop state ~loc_start label + | LIDENT _ -> ( + match peek_nth_token state 1 with + | EQUAL -> parse_for_loop state ~loc_start label + | COMMA | IN -> parse_foreach_loop state ~loc_start label + | _ -> + skip_this state; + handle_error + [ Token_kind T_EQUAL; Token_kind T_COMMA; Token_kind T_IN ]) + | _ -> + handle_error + [ Token_kind T_LIDENT; Token_kind T_SEMI; Token_kind T_LBRACE ] + : Syntax.expr) + +and parse_foreach_loop state ~loc_start label = + (debugged "for .. in" state (fun state -> + (let binders = + with_follow [ Token_kind T_IN ] + (sepby1 (Token_kind T_COMMA) (fun state -> + match peek_token state with + | UNDERSCORE -> + skip_this state; + None + | LIDENT name -> + let loc_ = peek_location state in + skip_this state; + Some ({ binder_name = name; loc_ } : Syntax.binder) + | token -> + add_error_unexpected state token + [ Token_kind T_LIDENT; Token_kind T_UNDERSCORE ] + (peek_location state); + let _ = parser_panic state in + None)) + state + in + expected_token (Token_kind T_IN) state; + let expr = parse_expr state in + let body = parse_block_expr state in + let else_block = + match peek_token state with + | ELSE -> + skip_this state; + Some (parse_block_expr state) + | _ -> None + in + let loc_ = loc_start_with state loc_start in + Pexpr_foreach { binders; expr; body; else_block; loc_; label } + : Syntax.expr)) + : Syntax.expr) + +and parse_for_loop state ~loc_start label = + debugged "for" state (fun state -> + (let parse_binder_with_value state = + let binder = parse_binder state in + expected_token (Token_kind T_EQUAL) state; + let value = parse_expr state in + (binder, value) + in + let binders, _ = + sepby_with_follow (Token_kind T_COMMA) + [ Token_kind T_SEMI; Token_kind T_LBRACE ] + parse_binder_with_value state + in + let condition, continue_block = + match peek_token state with + | LBRACE -> (None, []) + | SEMI _ -> + with_sync state (Token_kind T_LBRACE) (fun state -> + expected_token (Token_kind T_SEMI) state; + let condition = option first_expr parse_infix_expr state in + expected_token (Token_kind T_SEMI) state; + let continue_block, _ = + sepby_with_follow (Token_kind T_COMMA) + [ Token_kind T_LBRACE ] parse_binder_with_value state + in + (condition, continue_block)) + | other -> + let other_loc = peek_location state in + add_error_unexpected state other + [ Token_kind T_SEMI; Token_kind T_LBRACE ] + other_loc; + (None, []) + in + let body = parse_block_expr state in + match peek_token state with + | ELSE -> + with_follow [ Token_kind T_LBRACE ] + (expected_token (Token_kind T_ELSE)) + state; + let else_block = parse_block_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_for + { + binders; + condition; + continue_block; + body; + for_else = Some else_block; + label; + loc_; + } + | _ -> + let loc_ = loc_start_with state loc_start in + Pexpr_for + { + binders; + condition; + continue_block; + body; + for_else = None; + label; + loc_; + } + : Syntax.expr)) + +and parse_while_expr (state : parse_state) label = + (let loc_start = peek_loc_start state in + expected_token (Token_kind T_WHILE) state; + let loop_cond = with_follow [ Token_kind T_LBRACE ] parse_expr state in + let loop_body = parse_block_expr state in + match peek_token state with + | ELSE -> + with_follow [ Token_kind T_LBRACE ] + (expected_token (Token_kind T_ELSE)) + state; + let while_else = parse_block_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_while + { loop_cond; loop_body; while_else = Some while_else; loc_; label } + | _ -> + let loc_ = loc_start_with state loc_start in + Pexpr_while { loop_cond; loop_body; loc_; while_else = None; label } + : Syntax.expr) + +and parse_try_expr (state : parse_state) = + (let loc_start = peek_loc_start state in + let try_loc_ = peek_location state in + expected_token (Token_kind T_TRY) state; + let body = parse_expr state in + let catch_start = peek_loc_start state in + let catch_all = + match peek_token state with + | CATCH -> ( + skip_this state; + match peek_token state with + | EXCLAMATION -> + skip_this state; + true + | _ -> false) + | _ -> false + in + let catch_loc_ = Rloc.of_pos (catch_start, peek_loc_end state) in + let catch = + surround_sepby (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_case state + in + let try_else, else_loc_ = + match peek_token state with + | ELSE -> + let else_start = peek_loc_start state in + skip_this state; + let else_loc_ = Rloc.of_pos (else_start, peek_loc_end state) in + let try_else = + surround_sepby (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_case state + in + (Some try_else, else_loc_) + | _ -> (None, Rloc.no_location) + in + let loc_ = loc_start_with state loc_start in + Pexpr_try + { body; catch; catch_all; try_else; else_loc_; loc_; catch_loc_; try_loc_ } + : Syntax.expr) + +and parse_if_expr (state : parse_state) = + (let loc_start = peek_loc_start state in + expected_token (Token_kind T_IF) state; + let cond = with_follow [ Token_kind T_LBRACE ] parse_expr state in + let ifso = parse_block_expr state in + match peek_token state with + | ELSE -> ( + expected_token (Token_kind T_ELSE) state; + match peek_token state with + | IF -> + let ifnot = parse_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_if { cond; ifso; ifnot = Some ifnot; loc_ } + | _ -> + let ifnot = parse_block_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_if { cond; ifso; ifnot = Some ifnot; loc_ }) + | _ -> + let loc_ = loc_start_with state loc_start in + Pexpr_if { cond; ifso; ifnot = None; loc_ } + : Syntax.expr) + +and parse_match_expr (state : parse_state) = + (let loc_start = peek_loc_start state in + expected_token (Token_kind T_MATCH) state; + let expr = with_follow [ Token_kind T_LBRACE ] parse_expr state in + let match_loc_ = Rloc.of_pos (loc_start, peek_loc_end state) in + let cases = + surround_sepby ~invalid_delims:[ Token_kind T_COMMA ] (Token_kind T_LBRACE) + (Token_kind T_RBRACE) (Token_kind T_SEMI) parse_case state + in + let loc_ = loc_start_with state loc_start in + Pexpr_match { expr; cases; match_loc_; loc_ } + : Syntax.expr) + +and parse_case (state : parse_state) = + (let pat = + with_syncs state [ Token_kind T_FAT_ARROW; Token_kind T_IF ] parse_pattern + in + let guard = + match peek_token state with + | IF -> + skip_this state; + Some (parse_expr state) + | _ -> None + in + expected_token (Token_kind T_FAT_ARROW) state; + let act = parse_expr_stmt state in + { pattern = pat; guard; body = act } + : Syntax.case) + +and parse_multi_pattern_case (state : parse_state) = + (let parse_patterns state = + let patterns, _ = + sepby_with_follow (Token_kind T_COMMA) + [ Token_kind T_FAT_ARROW; Token_kind T_IF ] + parse_pattern state + in + patterns + in + let pats = + with_syncs state [ Token_kind T_FAT_ARROW; Token_kind T_IF ] parse_patterns + in + let guard = + match peek_token state with + | IF -> + skip_this state; + Some (parse_expr state) + | _ -> None + in + expected_token (Token_kind T_FAT_ARROW) state; + let act = parse_expr_stmt state in + { patterns = pats; guard; body = act } + : Syntax.multi_arg_case) + +and parse_expr (state : parse_state) = + (debugged "expr" state (fun state -> + match get_mode state with + | Normal -> ( + match peek_token state with + | POST_LABEL label_name -> ( + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + expected_token (Token_kind T_COLON) state; + match peek_token state with + | LOOP -> parse_loop_expr state (Some label) + | FOR -> parse_for_expr state (Some label) + | WHILE -> parse_while_expr state (Some label) + | other -> + let loc = peek_location state in + add_error_unexpected state other + [ Token_kind T_LOOP; Token_kind T_FOR; Token_kind T_WHILE ] + loc; + let _ = parser_panic state in + Pexpr_hole { loc_ = loc; kind = Synthesized }) + | LOOP -> parse_loop_expr state None + | FOR -> parse_for_expr state None + | WHILE -> parse_while_expr state None + | TRY -> parse_try_expr state + | IF -> parse_if_expr state + | MATCH -> parse_match_expr state + | _ -> parse_pipe_expr state) + | Panic { loc; _ } -> + add_error_skipped state "expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized }) + : Syntax.expr) + +and parse_pipe_expr (state : parse_state) = + (debugged "pipe_expr" state (fun state -> + match get_mode state with + | Normal -> + let start_loc = peek_loc_start state in + let rec loop lhs = + match peek_token state with + | PIPE -> + skip_this state; + let rhs = parse_infix_expr state in + let loc_ = loc_start_with state start_loc in + let lhs : Syntax.expr = Pexpr_pipe { lhs; rhs; loc_ } in + loop lhs + | _ -> lhs + in + loop (parse_infix_expr state) + | Panic { loc; _ } -> + add_error_skipped state "pipe_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized }) + : Syntax.expr) + +and parse_infix_expr (state : parse_state) = + (debugged "infix_expr" state (fun state -> + let make_infix ((lpos, lhs) : position * Syntax.expr) + ((_, op) : token * Syntax.var) ((_, rhs) : position * Syntax.expr) = + (let loc_ = loc_start_with state lpos in + (lpos, Syntax.Pexpr_infix { lhs; op; rhs; loc_ }) + : position * Syntax.expr) + in + let rec push_infix ~(expr_stack : (position * Syntax.expr) list) + ~(op_stack : (token * Syntax.var) list) ~(next_op : token) = + (match (expr_stack, op_stack) with + | _, [] -> (expr_stack, op_stack) + | rhs :: lhs :: expr_stack', op :: op_stack' -> + let priority1, assoc1 = get_binop_prior_assoc (fst op) in + let priority2, _ = get_binop_prior_assoc next_op in + if + priority1 > priority2 + || (priority1 = priority2 && assoc1 = `Left) + then + let new_expr = make_infix lhs op rhs in + push_infix ~expr_stack:(new_expr :: expr_stack') + ~op_stack:op_stack' ~next_op + else (expr_stack, op_stack) + | _ -> assert false + : (position * Syntax.expr) list * (token * Syntax.var) list) + in + let rec reduce_current_stack ~expr_stack ~op_stack = + match (expr_stack, op_stack) with + | expr :: [], [] -> expr + | rhs :: lhs :: expr_stack', op :: op_stack' -> + let new_expr = make_infix lhs op rhs in + reduce_current_stack ~expr_stack:(new_expr :: expr_stack') + ~op_stack:op_stack' + | _ -> assert false + in + let rec loop ~expr_stack ~op_stack state = + if get_mode state <> Normal then + reduce_current_stack ~expr_stack ~op_stack + else + let tok = peek_token state in + if not (is_binop tok) then reduce_current_stack ~expr_stack ~op_stack + else + let expr_stack, op_stack = + push_infix ~expr_stack ~op_stack ~next_op:tok + in + let var = parse_binop state in + let rhs_start = peek_loc_start state in + let new_rhs = parse_postfix_expr state in + loop + ~expr_stack:((rhs_start, new_rhs) :: expr_stack) + ~op_stack:((tok, var) :: op_stack) state + in + let first_start = peek_loc_start state in + let first_expr = parse_postfix_expr state in + snd (loop ~expr_stack:[ (first_start, first_expr) ] ~op_stack:[] state)) + : Syntax.expr) + +and parse_postfix_expr (state : parse_state) = + (debugged "postfix expr" state (fun state -> + let start_loc = peek_loc_start state in + let expr = parse_range_expr state in + match peek_token state with + | AS -> + skip_this state; + let trait = parse_type_name state in + Syntax.Pexpr_as + { expr; trait; loc_ = loc_start_with state start_loc } + | IS -> + skip_this state; + let pat = parse_range_pattern state in + Pexpr_is { expr; pat; loc_ = loc_start_with state start_loc } + | _ -> expr) + : Syntax.expr) + +and parse_range_expr (state : parse_state) = + (debugged "range_expr" state (fun state -> + let start_loc = peek_loc_start state in + let lhs = parse_prefix_expr state in + let op_start_loc = peek_loc_start state in + match peek_token state with + | RANGE_INCLUSIVE -> + skip_this state; + let op_loc = loc_start_with state op_start_loc in + let rhs = parse_prefix_expr state in + let loc_ = loc_start_with state start_loc in + Syntax.Pexpr_infix + { op = { var_name = Lident "..="; loc_ = op_loc }; lhs; rhs; loc_ } + | RANGE_EXCLUSIVE -> + skip_this state; + let op_loc = loc_start_with state op_start_loc in + let rhs = parse_prefix_expr state in + let loc_ = loc_start_with state start_loc in + Syntax.Pexpr_infix + { op = { var_name = Lident "..<"; loc_ = op_loc }; lhs; rhs; loc_ } + | _ -> lhs) + : Syntax.expr) + +and parse_prefix_expr (state : parse_state) = + (debugged "prefix expr" state (fun state -> + match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + match peek_token state with + | PLUS -> + expected_token (Token_kind T_PLUS) state; + let expr = parse_prefix_expr state in + let loc_ = loc_start_with state loc_start in + Parser_util.make_uplus ~loc_ "+" expr + | MINUS -> + expected_token (Token_kind T_MINUS) state; + let expr = parse_prefix_expr state in + let loc_ = loc_start_with state loc_start in + Parser_util.make_uminus ~loc_ "-" expr + | _ -> + let rec loop (left : Syntax.expr) = + match peek_token state with + | EXCLAMATION | QUESTION | LPAREN -> + let attr = parse_apply_attr state in + let args = + surround_sepby (Token_kind T_LPAREN) + (Token_kind T_RPAREN) (Token_kind T_COMMA) + parse_argument state + in + let loc_ = loc_start_with state loc_start in + loop (Pexpr_apply { func = left; args; attr; loc_ }) + | LBRACKET -> + let parse_index state = + match peek_token state with + | COLON -> + skip_this state; + let end_index = option first_expr parse_expr state in + `SliceIndex (None, end_index) + | _ -> ( + let start_index = parse_expr state in + match peek_token state with + | COLON -> + skip_this state; + let end_index = + option first_expr parse_expr state + in + `SliceIndex (Some start_index, end_index) + | _ -> `ArrayIndex start_index) + in + let index_loc_start = peek_loc_start state in + let index = + surround (Token_kind T_LBRACKET) (Token_kind T_RBRACKET) + parse_index state + in + let loc_ = loc_start_with state loc_start in + let index_loc_ = loc_start_with state index_loc_start in + let array_get_expr : Syntax.expr = + match index with + | `ArrayIndex index -> + Pexpr_array_get { loc_; array = left; index } + | `SliceIndex (start_index, end_index) -> + Pexpr_array_get_slice + { + loc_; + index_loc_; + array = left; + start_index; + end_index; + } + in + loop array_get_expr + | DOT_LIDENT _ -> ( + let label : Syntax.label = + let loc_ = peek_location state in + let label_name = expected_dot_lident state in + { label_name; loc_ } + in + let attr = parse_apply_attr state in + match peek_token state with + | LPAREN -> + let args = + surround_sepby (Token_kind T_LPAREN) + (Token_kind T_RPAREN) (Token_kind T_COMMA) + parse_argument state + in + let loc_ = loc_start_with state loc_start in + let expr : Syntax.expr = + Pexpr_dot_apply + { + self = left; + method_name = label; + args; + return_self = false; + attr; + loc_; + } + in + loop expr + | _ -> + let loc_ = loc_start_with state loc_start in + let accessor : Syntax.accessor = + if label.label_name = "_" then Newtype + else Label label + in + loop (Pexpr_field { record = left; accessor; loc_ })) + | DOTDOT -> + skip_this state; + let label = parse_label state in + let attr = parse_apply_attr state in + let args = + surround_sepby (Token_kind T_LPAREN) + (Token_kind T_RPAREN) (Token_kind T_COMMA) + parse_argument state + in + let loc_ = loc_start_with state loc_start in + let expr : Syntax.expr = + Pexpr_dot_apply + { + self = left; + method_name = label; + args; + return_self = true; + attr; + loc_; + } + in + loop expr + | DOT_INT _ -> + let accessor : Syntax.accessor = + let loc_ = peek_location state in + let tuple_index = expected_dot_int state in + Index { tuple_index; loc_ } + in + let loc_ = loc_start_with state loc_start in + loop (Pexpr_field { record = left; accessor; loc_ }) + | _ -> left + in + let left = parse_simple_expr state in + loop left) + | Panic { loc; _ } -> + add_error_skipped state "chain_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized }) + : Syntax.expr) + +and parse_constr_expr ~loc_start ~(extra_info : Syntax.constructor_extra_info) + state = + (debugged "constr_expr" state (fun state -> + (match get_mode state with + | Normal -> + let name_loc_start = peek_loc_start state in + let constr_name = + match extra_info with + | Package _ -> expected_dot_uident state + | No_extra_info | Type_name _ -> expected_uident state + in + let name_loc = loc_start_with state name_loc_start in + let loc_ = loc_start_with state loc_start in + let constr : Syntax.constructor = + { + extra_info; + constr_name = { name = constr_name; loc_ = name_loc }; + loc_; + } + in + Pexpr_constr { constr; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "constr_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_argument (state : parse_state) = + (debugged "argument" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | (LIDENT label_name | UIDENT label_name) + when peek_nth_token_kind state 1 = Token_kind T_EQUAL + || peek_nth_token_kind state 1 = Token_kind T_QUESTION + && peek_nth_token_kind state 2 = Token_kind T_EQUAL -> + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + let arg_kind = + match peek_token state with + | QUESTION -> + let question_loc = peek_location state in + skip_this state; + Syntax.Labelled_option { label; question_loc } + | _ -> Labelled label + in + skip_this state; + let arg_value = parse_expr state in + { arg_value; arg_kind } + | POST_LABEL label_name -> + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + let arg_kind = Syntax.Labelled_pun label in + let arg_value = + Parser_util.label_to_expr + ~loc_:(Rloc.trim_last_char label.loc_) + label + in + { arg_value; arg_kind } + | LIDENT label_name + when peek_nth_token_kind state 1 = Token_kind T_QUESTION + && (peek_nth_token_kind state 2 = Token_kind T_COMMA + || peek_nth_token_kind state 2 = Token_kind T_RPAREN) -> + let label : Syntax.label = + { label_name; loc_ = peek_location state } + in + skip_this state; + let question_loc = peek_location state in + skip_this state; + let arg_kind = + Syntax.Labelled_option_pun { label; question_loc } + in + let arg_value = + Parser_util.label_to_expr ~loc_:label.loc_ label + in + { arg_value; arg_kind } + | _ -> + let arg_value = parse_expr state in + { arg_value; arg_kind = Positional }) + | Panic { loc; _ } -> + add_error_skipped state "argument" loc; + { + arg_value = Pexpr_hole { loc_ = loc; kind = Synthesized }; + arg_kind = Positional; + } + : Syntax.argument)) + : Syntax.argument) + +and parse_func fn_loc_start ~has_error ~is_async (state : parse_state) = + (debugged "func" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | LPAREN -> + let param_loc_start = peek_loc_start state in + let params = + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_parameter state + in + let params_loc_ = loc_start_with state param_loc_start in + let res_ty = + match peek_token state with + | THIN_ARROW -> + expected_token (Token_kind T_THIN_ARROW) state; + let ty = parse_return_type state in + Some ty + | _ -> None + in + let block = parse_block_expr state in + Lambda + { + parameters = params; + params_loc_; + body = block; + return_type = res_ty; + kind_ = Lambda; + has_error; + is_async; + } + | LBRACE -> + let loc_start = peek_loc_start state in + let fn_loc_ = Rloc.of_pos (fn_loc_start, peek_loc_end state) in + let cases = parse_match_fn_body state in + let loc_ = loc_start_with state loc_start in + Match { cases; has_error; is_async; fn_loc_; loc_ } + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "func" other_loc; + let loc_ = parser_panic state in + Lambda + { + parameters = []; + params_loc_ = loc_; + body = Pexpr_hole { loc_; kind = Synthesized }; + return_type = None; + kind_ = Lambda; + has_error; + is_async; + }) + | Panic { loc; _ } -> + add_error_skipped state "func" loc; + Lambda + { + parameters = []; + params_loc_ = loc; + body = Pexpr_hole { loc_ = loc; kind = Synthesized }; + return_type = None; + kind_ = Lambda; + has_error; + is_async; + } + : Syntax.func)) + : Syntax.func) + +and parse_parameter (state : parse_state) = + (debugged "parameter" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | UNDERSCORE -> + let loc_ = peek_location state in + skip_this state; + let param_annot = parse_opt_annot state in + Discard_positional { loc_; ty = param_annot } + | POST_LABEL label_name -> ( + let param_binder : Syntax.binder = + { + binder_name = label_name; + loc_ = Rloc.trim_last_char (peek_location state); + } + in + skip_this state; + let param_annot = parse_opt_annot state in + match (get_mode state, peek_token state) with + | Normal, EQUAL -> + skip_this state; + let default = parse_expr state in + Optional + { default; binder = param_binder; ty = param_annot } + | _ -> Labelled { binder = param_binder; ty = param_annot }) + | LIDENT label_name + when peek_nth_token_kind state 1 = Token_kind T_QUESTION -> ( + let param_binder : Syntax.binder = + { binder_name = label_name; loc_ = peek_location state } + in + skip_this state; + skip_this state; + let param_annot = parse_opt_annot state in + match (get_mode state, peek_token state) with + | Normal, EQUAL -> + skip_this state; + let default = parse_expr state in + add_error state + (Errors.no_default_for_question_optional ~label:label_name + ~loc:(Syntax.loc_of_expression default)); + Optional + { default; binder = param_binder; ty = param_annot } + | _ -> + Question_optional + { binder = param_binder; ty = param_annot }) + | LIDENT param_name -> ( + let param_binder : Syntax.binder = + { binder_name = param_name; loc_ = peek_location state } + in + skip_this state; + let param_annot = parse_opt_annot state in + match (get_mode state, peek_token state) with + | Normal, EQUAL -> + let eq_loc = peek_location state in + skip_this state; + let default = parse_expr state in + add_error state + (Errors.positional_argument_no_default eq_loc); + Optional + { default; binder = param_binder; ty = param_annot } + | _ -> Positional { binder = param_binder; ty = param_annot }) + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "parameter name or label" + other_loc; + let _ = parser_panic state in + Positional + { + binder = + { binder_name = "?binder"; loc_ = Rloc.no_location }; + ty = None; + }) + | Panic { loc; _ } -> + add_error_skipped state "parameter" loc; + Positional + { + binder = { binder_name = "?binder"; loc_ = Rloc.no_location }; + ty = None; + } + : Syntax.parameter)) + : Syntax.parameter) + +and parse_apply_attr (state : parse_state) = + (match get_mode state with + | Normal -> ( + match peek_token state with + | EXCLAMATION -> ( + skip_this state; + match peek_token state with + | EXCLAMATION -> + skip_this state; + Double_exclamation + | _ -> Exclamation) + | QUESTION -> + skip_this state; + Question + | _ -> No_attr) + | Panic _ -> No_attr + : Syntax.apply_attr) + +and parse_simple_expr (state : parse_state) = + (debugged "simple_expr" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | TRUE -> + let loc_ = peek_location state in + expected_token (Token_kind T_TRUE) state; + Pexpr_constant { c = Const_bool true; loc_ } + | FALSE -> + let loc_ = peek_location state in + expected_token (Token_kind T_FALSE) state; + Pexpr_constant { c = Const_bool false; loc_ } + | BYTE x -> + let loc_ = peek_location state in + expected_token (Token_kind T_BYTE) state; + Pexpr_constant { c = Const_byte x; loc_ } + | CHAR x -> + let loc_ = peek_location state in + expected_token (Token_kind T_CHAR) state; + Pexpr_constant { c = Const_char x; loc_ } + | INT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INT) state; + Pexpr_constant { c = Parser_util.make_int x; loc_ } + | FLOAT x -> + let loc_ = peek_location state in + expected_token (Token_kind T_FLOAT) state; + Pexpr_constant { c = Const_double x; loc_ } + | STRING x -> + let loc_ = peek_location state in + expected_token (Token_kind T_STRING) state; + Pexpr_constant { c = Const_string x; loc_ } + | BYTES x -> + let loc_ = peek_location state in + expected_token (Token_kind T_BYTES) state; + Pexpr_constant { c = Const_bytes x; loc_ } + | MULTILINE_STRING _ | MULTILINE_INTERP _ -> + let loc_start = peek_loc_start state in + let rec loop xs = + match peek_token state with + | MULTILINE_STRING x -> + expected_token (Token_kind T_MULTILINE_STRING) state; + loop (Syntax.Multiline_string x :: xs) + | MULTILINE_INTERP x -> + expected_token (Token_kind T_MULTILINE_INTERP) state; + loop + (Syntax.Multiline_interp (Parsing_util.make_interps x) + :: xs) + | _ -> List.rev xs + in + let elems = loop [] in + let loc_ = loc_start_with state loc_start in + Syntax.Pexpr_multiline_string { loc_; elems } + | INTERP x -> + let loc_ = peek_location state in + expected_token (Token_kind T_INTERP) state; + Parser_util.make_Pexpr_interp ~loc_ x + | PACKAGE_NAME pkg -> ( + match peek_nth_token_kind state 1 with + | Token_kind (T_DOT_LIDENT | T_DOT_UIDENT) + when peek_nth_token_kind state 2 = Token_kind T_COLONCOLON -> + parse_coloncolon_expr state + | Token_kind T_DOT_UIDENT -> + let loc_start = peek_loc_start state in + skip_this state; + parse_constr_expr ~loc_start ~extra_info:(Package pkg) state + | _ -> + let loc_start = peek_loc_start state in + let var = parse_qual_lident state in + let loc_ = loc_start_with state loc_start in + Pexpr_ident { id = { var_name = var; loc_ }; loc_ }) + | (LIDENT _ | UIDENT _) + when peek_nth_token_kind state 1 = Token_kind T_COLONCOLON -> + parse_coloncolon_expr state + | AMPER -> parse_coloncolon_expr state + | LIDENT _ -> + let loc_start = peek_loc_start state in + let var = parse_var state in + let loc_ = loc_start_with state loc_start in + Pexpr_ident { id = var; loc_ } + | UIDENT _ -> + let loc_start = peek_loc_start state in + parse_constr_expr ~loc_start ~extra_info:No_extra_info state + | ASYNC -> + let loc_start = peek_loc_start state in + skip_this state; + skip_this state; + let has_error = parse_optional_bang state in + let func = + parse_func loc_start ~has_error ~is_async:true state + in + let loc_ = loc_start_with state loc_start in + Pexpr_function { func; loc_ } + | FN -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_FN) state; + let has_error = parse_optional_bang state in + let func = + parse_func loc_start ~has_error ~is_async:false state + in + let loc_ = loc_start_with state loc_start in + Pexpr_function { func; loc_ } + | LPAREN -> + located state (fun state -> + surround (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (fun state -> + (let first = option first_expr parse_expr state in + match first with + | None -> + fun loc_ -> Pexpr_unit { loc_; faked = false } + | Some first -> ( + match peek_token state with + | COLON -> + expected_token (Token_kind T_COLON) state; + let ty = parse_type state in + fun loc_ -> + Pexpr_constraint { expr = first; ty; loc_ } + | COMMA -> + expected_token (Token_kind T_COMMA) state; + let rest, _ = + sepby_with_follow (Token_kind T_COMMA) + [ Token_kind T_RPAREN ] parse_expr state + in + fun loc_ -> + Pexpr_tuple { exprs = first :: rest; loc_ } + | RPAREN -> + fun loc_ -> + Pexpr_group + { expr = first; group = Group_paren; loc_ } + | _ -> fun _ -> first) + : Rloc.t -> Syntax.expr)) + state) + | LBRACKET -> + let loc_start = peek_loc_start state in + let to_spread = ref false in + let elems = + surround_sepby (Token_kind T_LBRACKET) (Token_kind T_RBRACKET) + (Token_kind T_COMMA) + (fun state -> + (match peek_token state with + | DOTDOT -> + to_spread := true; + let spread_loc_start = peek_loc_start state in + expected_token (Token_kind T_DOTDOT) state; + Elem_spread + { + expr = parse_expr state; + loc_ = loc_start_with state spread_loc_start; + } + | _ -> Elem_regular (parse_expr state) + : Syntax.spreadable_elem)) + state + in + let loc_ = loc_start_with state loc_start in + if !to_spread then Pexpr_array_spread { elems; loc_ } + else + Pexpr_array + { + exprs = + Lst.map elems (function + | Syntax.Elem_regular e -> e + | Syntax.Elem_spread _ -> assert false); + loc_; + } + | LBRACE -> ( + let loc_start = peek_loc_start state in + match peek_nth_token state 1 with + | DOTDOT -> parse_record_expr ~type_name:None state + | LIDENT _ -> ( + match peek_nth_token state 2 with + | SEMI _ when peek_nth_token state 3 = RBRACE -> + parse_semi_trailing_record state + | COLON | COMMA | RBRACE -> + parse_record_expr ~type_name:None state + | _ -> + let loc_ = loc_start_with state loc_start in + let expr = parse_block_expr state in + Pexpr_group { expr; group = Group_brace; loc_ }) + | RBRACE -> parse_map_expr state + | (TRUE | FALSE | CHAR _ | INT _ | FLOAT _ | MINUS | STRING _) + when peek_nth_token state 2 = COLON -> + parse_map_expr state + | _ -> + let loc_ = loc_start_with state loc_start in + let expr = parse_block_expr state in + Pexpr_group { expr; group = Group_brace; loc_ }) + | UNDERSCORE -> + let loc_ = peek_location state in + expected_token (Token_kind T_UNDERSCORE) state; + Pexpr_hole { loc_; kind = Incomplete } + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "simple expression" + other_loc; + let loc_ = parser_panic state in + Pexpr_hole { loc_; kind = Synthesized }) + | Panic { loc; _ } -> + add_error_skipped state "simple_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_coloncolon_expr (state : parse_state) = + (debugged "coloncolon_expr" state (fun state -> + (let loc_start = peek_loc_start state in + let type_name = parse_type_name state in + expected_token (Token_kind T_COLONCOLON) state; + match (get_mode state, peek_token state) with + | Normal, LIDENT _ -> + let method_name = parse_label state in + let loc_ = loc_start_with state loc_start in + Pexpr_method { type_name; method_name; loc_ } + | Normal, UIDENT _ -> + parse_constr_expr ~loc_start ~extra_info:(Type_name type_name) state + | Normal, LBRACE -> parse_record_expr ~type_name:(Some type_name) state + | Normal, token -> + add_error_failed_to_parse state token + "method name, constructor name, \"[\" or \"{\"" + (peek_location state); + let skipped_loc = parser_panic state in + let loc_ = Rloc.of_pos (loc_start, Rloc.get_end skipped_loc) in + Pexpr_constr + { + constr = + { + extra_info = Type_name type_name; + constr_name = { name = "?constr"; loc_ = Rloc.no_location }; + loc_; + }; + loc_; + } + | Panic { loc; _ }, _ -> + add_error_skipped state "coloncolon_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_field_def (state : parse_state) = + (debugged "field_def" state (fun state -> + (match get_mode state with + | Normal -> ( + let loc_start = peek_loc_start state in + let label = parse_label state in + let expr_opt = + match peek_token state with + | EQUAL -> + let loc = peek_location state in + add_error state (Errors.invalid_equal_in_struct_expr ~loc); + skip_this state; + Some (parse_expr state) + | COLON -> + skip_this state; + Some (parse_expr state) + | _ -> None + in + match expr_opt with + | Some expr -> + let loc_ = loc_start_with state loc_start in + Field_def { label; expr; is_pun = false; loc_ } + | None -> + let loc_ = loc_start_with state loc_start in + Field_def + { + label; + expr = Parser_util.label_to_expr ~loc_:label.loc_ label; + is_pun = true; + loc_; + }) + | Panic { loc; _ } -> + add_error_skipped state "filed_def" loc; + Field_def + { + label = { label_name = "?"; loc_ = loc }; + expr = Pexpr_hole { loc_ = loc; kind = Synthesized }; + is_pun = false; + loc_ = loc; + } + : Syntax.field_def)) + : Syntax.field_def) + +and parse_semi_trailing_record (state : parse_state) = + (debugged "semi trailing record_expr" state (fun state -> + (match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_LBRACE) state; + let field = parse_field_def state in + expected_token (Token_kind T_SEMI) state; + expected_token (Token_kind T_RBRACE) state; + Pexpr_record + { + type_name = None; + fields = [ field ]; + trailing = Trailing_semi; + loc_ = loc_start_with state loc_start; + } + | Panic { loc; _ } -> + add_error_skipped state "semi trailing record_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_record_expr ~type_name state = + (debugged "record_expr" state (fun state -> + (match get_mode state with + | Normal -> ( + let parse_fields state = + sepby_with_follow (Token_kind T_COMMA) [ Token_kind T_RBRACE ] + parse_field_def state + in + let loc_start = peek_loc_start state in + expected_token (Token_kind T_LBRACE) state; + let spread_record, fields, trailing_comma = + match peek_token state with + | DOTDOT -> + expected_token (Token_kind T_DOTDOT) state; + let spread_record = parse_expr state in + let fields, trailing = + match peek_token state with + | COMMA -> + expected_token (Token_kind T_COMMA) state; + parse_fields state + | _ -> ([], false) + in + (Some spread_record, fields, trailing) + | _ -> + let fields, trailing_semi = parse_fields state in + (None, fields, trailing_semi) + in + expected_token (Token_kind T_RBRACE) state; + let loc_ = loc_start_with state loc_start in + match spread_record with + | Some record -> + Pexpr_record_update { type_name; record; fields; loc_ } + | None -> + Pexpr_record + { + type_name; + fields; + loc_; + trailing = + (if trailing_comma then Trailing_comma else Trailing_none); + }) + | Panic { loc; _ } -> + add_error_skipped state "record_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_map_expr (state : parse_state) = + (debugged "map_expr" state (fun state -> + (match get_mode state with + | Normal -> + let parse_elem state = + let loc_start = peek_loc_start state in + let parse_map_expr_elem key = + skip_this state; + let key_loc_ = loc_start_with state loc_start in + expected_token (Token_kind T_COLON) state; + let expr = parse_expr state in + let loc_ = loc_start_with state loc_start in + Some (Syntax.Map_expr_elem { key; expr; key_loc_; loc_ }) + [@@local] + in + match peek_token state with + | TRUE -> parse_map_expr_elem (Const_bool true) + | FALSE -> parse_map_expr_elem (Const_bool false) + | CHAR x -> parse_map_expr_elem (Const_char x) + | INT x -> parse_map_expr_elem (Parser_util.make_int x) + | FLOAT x -> parse_map_expr_elem (Const_double x) + | MINUS -> ( + expected_token (Token_kind T_MINUS) state; + match peek_token state with + | INT x -> + parse_map_expr_elem (Parser_util.make_int ("-" ^ x)) + | FLOAT x -> parse_map_expr_elem (Const_double ("-" ^ x)) + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other + "`-Int` or `-Float` in key of map pattern" other_loc; + let _ = parser_panic state in + None) + | STRING x -> parse_map_expr_elem (Const_string x) + | other -> + add_error_unexpected state other first_map_pattern_key + (peek_location state); + let _ = parser_panic state in + None + in + let loc_start = peek_loc_start state in + let elems = + surround_sepby (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_COMMA) parse_elem state + in + let elems = + Lst.fold_right elems [] (fun elem_opt -> + fun acc -> + match elem_opt with None -> acc | Some elem -> elem :: acc) + in + let loc_ = loc_start_with state loc_start in + Pexpr_map { elems; loc_ } + | Panic { loc; _ } -> + add_error_skipped state "record_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_opt_annot (state : parse_state) = + (debugged "opt_annot" state (fun state -> + match get_mode state with + | Normal -> ( + match peek_token state with + | COLON -> + expected_token (Token_kind T_COLON) state; + let res = parse_type state in + Some res + | _ -> None) + | Panic { loc; _ } -> + add_error_skipped state "opt_annot" loc; + None) + : Syntax.typ option) + +and parse_block_expr_with_local_types (state : parse_state) = + (debugged "block_expr_with_local_types" state (fun state -> + match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let local_types, stmts = + surround (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (fun s -> + let semi = Token_kind T_SEMI in + let local_types, stmts = + match peek_token state with + | STRUCT | ENUM | TYPE -> + let local_types = Vec.empty () in + let rec loop () = + match peek_token state with + | STRUCT | ENUM | TYPE -> ( + push_sync state semi; + let local_type = parse_local_type_decl state in + Vec.push local_types local_type; + pop_sync state semi; + match peek_token state with + | SEMI _ -> + skip_this state; + loop () + | _ -> []) + | _ -> + let stmts, _ = + sepby_with_follow semi [ Token_kind T_RBRACE ] + parse_stmt s + in + stmts + in + let stmts = loop () in + (Vec.to_list local_types, stmts) + | _ -> + let stmts, _ = + sepby_with_follow semi [ Token_kind T_RBRACE ] + parse_stmt s + in + ([], stmts) + in + (local_types, stmts)) + state + in + let loc_ = loc_start_with state loc_start in + (local_types, Compact.compact_rev (List.rev stmts) loc_) + | Panic { loc; _ } -> + add_error_skipped state "block_expr_with_local_types" loc; + ([], Pexpr_hole { loc_ = loc; kind = Synthesized })) + : Syntax.local_type_decl list * Syntax.expr) + +and parse_block_expr (state : parse_state) = + (debugged "block_expr" state (fun state -> + match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let stmts = + surround_sepby (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_stmt state + in + let loc_ = loc_start_with state loc_start in + Compact.compact_rev (List.rev stmts) loc_ + | Panic { loc; _ } -> + add_error_skipped state "block_expr" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized }) + : Syntax.expr) + +and parse_stmt (state : parse_state) = + (debugged "stmt" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | LET -> ( + let loc_start = peek_loc_start state in + expected_token (Token_kind T_LET) state; + match peek_token state with + | MUTABLE -> + expected_token (Token_kind T_MUTABLE) state; + let binder = parse_binder state in + let ty_opt = parse_opt_annot state in + expected_token (Token_kind T_EQUAL) state; + let expr = parse_expr state in + let loc = loc_start_with state loc_start in + Stmt_letmut { binder; ty_opt; expr; loc } + | _ -> + let pat = parse_pattern state in + let ty_opt = parse_opt_annot state in + let pat : Syntax.pattern = + match ty_opt with + | Some ty -> + Ppat_constraint + { + pat; + ty; + loc_ = + Rloc.merge (loc_of_pattern pat) + (loc_of_type_expression ty); + } + | None -> pat + in + expected_token (Token_kind T_EQUAL) state; + let expr = parse_expr state in + let loc = loc_start_with state loc_start in + Stmt_let { pat; expr; loc }) + | ASYNC + when peek_nth_token_kind state 1 = Token_kind T_FN + && peek_nth_token_kind state 2 = Token_kind T_LIDENT -> + let loc_start = peek_loc_start state in + skip_this state; + skip_this state; + let binder = parse_binder state in + let has_error = parse_optional_bang state in + let func = + parse_func loc_start ~has_error ~is_async:true state + in + let loc = loc_start_with state loc_start in + Stmt_func { binder; func; loc } + | FN when peek_nth_token_kind state 1 = Token_kind T_LIDENT -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_FN) state; + let binder = parse_binder state in + let has_error = parse_optional_bang state in + let func = + parse_func loc_start ~has_error ~is_async:false state + in + let loc = loc_start_with state loc_start in + Stmt_func { binder; func; loc } + | GUARD -> ( + let loc_start = peek_loc_start state in + skip_this state; + match peek_token state with + | LET -> + skip_this state; + push_sync state (Token_kind T_ELSE); + let pat = parse_pattern state in + expected_token (Token_kind T_EQUAL) state; + let expr = parse_infix_expr state in + pop_sync state (Token_kind T_ELSE); + let otherwise = + match peek_token state with + | ELSE -> + skip_this state; + Some + (surround_sepby (Token_kind T_LBRACE) + (Token_kind T_RBRACE) (Token_kind T_SEMI) + parse_case state) + | _ -> None + in + let loc = loc_start_with state loc_start in + Parsing_compact.Stmt_guard_let { pat; expr; otherwise; loc } + | _ -> + let cond = + with_sync state (Token_kind T_ELSE) parse_infix_expr + in + let otherwise = + match peek_token state with + | ELSE -> + skip_this state; + Some (parse_block_expr state) + | _ -> None + in + let loc = loc_start_with state loc_start in + Parsing_compact.Stmt_guard { cond; otherwise; loc }) + | _ -> Stmt_expr { expr = parse_expr_stmt state }) + | Panic { loc; _ } -> + add_error_skipped state "stmt" loc; + Stmt_expr { expr = Pexpr_hole { loc_ = loc; kind = Synthesized } } + : Compact.semi_expr_prop)) + : Compact.semi_expr_prop) + +and parse_assign_or_simple_expr state = + (let loc_start = peek_loc_start state in + let lhs = parse_expr state in + match peek_token state with + | EQUAL -> ( + expected_token (Token_kind T_EQUAL) state; + let rhs = parse_expr state in + let loc_ = loc_start_with state loc_start in + match Parser_util.make_assign_opt ~loc_ lhs rhs with + | Some res -> res + | None -> + add_error state (Errors.invalid_left_value (loc_of_expression lhs)); + lhs) + | AUGMENTED_ASSIGNMENT op -> ( + let loc_ = peek_location state in + let op : Syntax.var = { var_name = Lident op; loc_ } in + expected_token (Token_kind T_AUGMENTED_ASSIGNMENT) state; + let rhs = parse_expr state in + let loc_ = loc_start_with state loc_start in + match Parser_util.make_augmented_assign_opt ~loc_ op lhs rhs with + | Some res -> res + | None -> + add_error state (Errors.invalid_left_value (loc_of_expression lhs)); + lhs) + | _ -> lhs + : Syntax.expr) + +and parse_expr_stmt (state : parse_state) = + (debugged "expr_stmt" state (fun state -> + (match get_mode state with + | Normal -> ( + match peek_token state with + | BREAK -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_BREAK) state; + let label : Syntax.label option = + match peek_token state with + | POST_LABEL label_name -> + skip_this state; + Some { label_name; loc_ = peek_location state } + | _ -> None + in + let arg = option first_expr parse_expr state in + Pexpr_break + { arg; loc_ = loc_start_with state loc_start; label } + | CONTINUE -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_CONTINUE) state; + let label : Syntax.label option = + match peek_token state with + | POST_LABEL label_name -> + skip_this state; + Some { label_name; loc_ = peek_location state } + | _ -> None + in + let args = + sepby (Token_kind T_COMMA) first_expr parse_expr state + in + Pexpr_continue + { args; loc_ = loc_start_with state loc_start; label } + | RETURN -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_RETURN) state; + let expr = option first_expr parse_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_return { return_value = expr; loc_ } + | RAISE -> + let loc_start = peek_loc_start state in + expected_token (Token_kind T_RAISE) state; + let expr = parse_expr state in + let loc_ = loc_start_with state loc_start in + Pexpr_raise { err_value = expr; loc_ } + | ELLIPSIS -> + let loc_ = peek_location state in + skip_this state; + Pexpr_hole { loc_; kind = Todo } + | _ -> parse_assign_or_simple_expr state) + | Panic { loc; _ } -> + add_error_skipped state "stmt" loc; + Pexpr_hole { loc_ = loc; kind = Synthesized } + : Syntax.expr)) + : Syntax.expr) + +and parse_match_fn_body state = + (debugged "match_fn_body" state (fun state -> + match get_mode state with + | Normal -> + surround_sepby (Token_kind T_LBRACE) (Token_kind T_RBRACE) + (Token_kind T_SEMI) parse_multi_pattern_case state + | Panic { loc; _ } -> + add_error_skipped state "match_fn_body" loc; + []) + : Syntax.multi_arg_case list) + +and parse_return_type (state : parse_state) = + (debugged "return_type" state (fun state -> + match get_mode state with + | Normal -> ( + let ty_res = parse_type state in + match peek_token state with + | EXCLAMATION -> + let loc_ = peek_location state in + expected_token (Token_kind T_EXCLAMATION) state; + let ty_err : Syntax.error_typ = + match option first_type parse_type state with + | Some ty -> Error_typ { ty } + | None -> Default_error_typ { loc_ } + in + (ty_res, ty_err) + | _ -> (ty_res, No_error_typ)) + | Panic { loc; _ } -> + add_error_skipped state "return_type" loc; + (Ptype_any { loc_ = loc }, No_error_typ)) + : Syntax.typ * Syntax.error_typ) + +and parse_type (state : parse_state) = + (let rec parse_question_mark state loc_start ty = + match peek_token state with + | QUESTION -> + let constr_loc = peek_location state in + expected_token (Token_kind T_QUESTION) state; + let loc_ = loc_start_with state loc_start in + let ty = Parsing_util.make_Ptype_option ~loc_ ~constr_loc ty in + parse_question_mark state loc_start ty + | _ -> ty + in + debugged "type" state (fun state -> + match get_mode state with + | Normal -> + let loc_start = peek_loc_start state in + let ty : Syntax.typ = + match peek_token state with + | PACKAGE_NAME _ | LIDENT _ | UIDENT _ -> + let name_loc = peek_location state in + let name = parse_qual_luident state in + let args = + option [ Token_kind T_LBRACKET ] + (surround_sepby (Token_kind T_LBRACKET) + (Token_kind T_RBRACKET) (Token_kind T_COMMA) parse_type) + state + in + let loc_ = loc_start_with state loc_start in + Ptype_name + { + constr_id = { lid = name; loc_ = name_loc }; + tys = Option.value ~default:[] args; + loc_; + } + | ASYNC -> + skip_this state; + let tys = + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_type state + in + expected_token (Token_kind T_THIN_ARROW) state; + let ty_res, ty_err = parse_return_type state in + let loc_ = loc_start_with state loc_start in + Ptype_arrow + { ty_arg = tys; ty_res; ty_err; is_async = true; loc_ } + | LPAREN -> ( + let tys = + surround_sepby (Token_kind T_LPAREN) (Token_kind T_RPAREN) + (Token_kind T_COMMA) parse_type state + in + match tys with + | [] -> + expected_token (Token_kind T_THIN_ARROW) state; + let ty_res, ty_err = parse_return_type state in + let loc_ = loc_start_with state loc_start in + Ptype_arrow + { ty_arg = []; ty_res; ty_err; is_async = false; loc_ } + | tys -> ( + match peek_token state with + | THIN_ARROW -> + expected_token (Token_kind T_THIN_ARROW) state; + let ty_res, ty_err = parse_return_type state in + let loc_ = loc_start_with state loc_start in + Ptype_arrow + { + ty_arg = tys; + ty_res; + ty_err; + is_async = false; + loc_; + } + | _ -> ( + match tys with + | [] -> failwith "unreachable!" + | x :: [] -> x + | _ :: _ -> + let loc_ = loc_start_with state loc_start in + Ptype_tuple { tys; loc_ }))) + | UNDERSCORE -> + let loc_ = peek_location state in + expected_token (Token_kind T_UNDERSCORE) state; + Ptype_any { loc_ } + | AMPER -> + skip_this state; + let loc_start = peek_loc_start state in + let lid = parse_qual_luident state in + let loc_ = loc_start_with state loc_start in + Ptype_object { lid; loc_ } + | other -> + let other_loc = peek_location state in + add_error_failed_to_parse state other "type" other_loc; + let loc_ = parser_panic state in + Ptype_any { loc_ } + in + parse_question_mark state loc_start ty + | Panic { loc; _ } -> + add_error_skipped state "type" loc; + Ptype_any { loc_ = loc }) + : Syntax.typ) diff --git a/src/parsing_parse.ml b/src/parsing_parse.ml index 02d75cf..a4d2244 100644 --- a/src/parsing_parse.ml +++ b/src/parsing_parse.ml @@ -16,44 +16,52 @@ module Syntax = Parsing_syntax module Segment = Parsing_segment module Parser = Parsing_parser +module Parser_main = Parsing_main +module Parser_core = Parsing_core module Header_parser = Parsing_header_parser module Ast_lint = Parsing_ast_lint module Vec_token = Lex_vec_token module Menhir_token = Lex_menhir_token module Vec_comment = Lex_vec_comment module Unicode_lex = Lex_unicode_lex +module Lst = Basic_lst type output = { ast : Syntax.impls; - tokens : Vec_token.t; directive : (string * string) list; + tokens_list : Vec_token.t list; name : string; + pkg : string; } -let sexp_of_output (x : output) : S.t = - let impls = Basic_lst.map x.ast Syntax.sexp_of_impl in - let directive = - match Basic_lst.assoc_str x.directive "build" with - | None -> [] - | Some d -> - let msg = "//!build:" ^ d in - ([ List (List.cons (Atom "directive" : S.t) ([ Atom msg ] : S.t list)) ] - : S.t list) - in - (List (List.append (directive : S.t list) (impls : S.t list)) : S.t) +let sexp_of_output (x : output) = + (let impls = Basic_lst.map x.ast Syntax.sexp_of_impl in + let directive = + match Basic_lst.assoc_str x.directive "build" with + | None -> [] + | Some d -> + let msg = "//!build:" ^ d in + ([ + List (List.cons (Atom "directive" : S.t) ([ Atom msg ] : S.t list)); + ] + : S.t list) + in + (List (List.append (directive : S.t list) (impls : S.t list)) : S.t) + : S.t) -let menhir_parse_toplevel ~diagnostics segment : Syntax.impl list = - let lexbuf : Lexing.lexbuf = Lexing.from_string "" in - let lexer (lexbuf : Lexing.lexbuf) : Menhir_token.token = - Segment.next_with_lexbuf_update segment lexbuf - in - Parsing_menhir_state.initialize_state segment; - try Parser.structure lexer lexbuf - with Parser.Error -> - Diagnostics.add_error diagnostics - (Errors.parse_error ~loc_start:lexbuf.lex_start_p - ~loc_end:lexbuf.lex_curr_p "parse error"); - [] +let menhir_parse_toplevel ~diagnostics segment = + (let lexbuf : Lexing.lexbuf = Lexing.from_string "" in + let lexer (lexbuf : Lexing.lexbuf) = + (Segment.next_with_lexbuf_update segment lexbuf : Menhir_token.token) + in + Parsing_menhir_state.initialize_state segment; + try Parser.structure lexer lexbuf + with Parser.Error -> + Diagnostics.add_error diagnostics + (Errors.parse_error ~loc_start:lexbuf.lex_start_p + ~loc_end:lexbuf.lex_curr_p "parse error"); + [] + : Syntax.impl list) let doc_search ~diagnostics (docstrings : Vec_comment.t) (last_pos : Loc.t ref) (ast : Syntax.impl) = @@ -76,13 +84,25 @@ let doc_search ~diagnostics (docstrings : Vec_comment.t) (last_pos : Loc.t ref) in ld.doc_ <- Docstring.of_comments ~diagnostics comments; last_pos := ld.loc_ - | Ptop_expr _ | Ptop_test _ | Ptop_impl_relation _ -> () + | Ptop_expr { loc_; _ } | Ptop_impl_relation { loc_; _ } -> last_pos := loc_ + | Ptop_test test -> + let comments = + Vec_comment.search ~last:!last_pos ~loc_:test.loc_ docstrings + in + test.doc_ <- Docstring.of_comments ~diagnostics comments; + last_pos := test.loc_ | Ptop_trait trait -> let comments = Vec_comment.search ~last:!last_pos ~loc_:trait.trait_loc_ docstrings in trait.trait_doc_ <- Docstring.of_comments ~diagnostics comments; last_pos := trait.trait_loc_ + | Ptop_trait_alias trait_alias -> + let comments = + Vec_comment.search ~last:!last_pos ~loc_:trait_alias.loc_ docstrings + in + trait_alias.doc_ <- Docstring.of_comments ~diagnostics comments; + last_pos := trait_alias.loc_ | Ptop_impl impl -> let comments = Vec_comment.search ~last:!last_pos ~loc_:impl.loc_ docstrings @@ -90,42 +110,212 @@ let doc_search ~diagnostics (docstrings : Vec_comment.t) (last_pos : Loc.t ref) impl.doc_ <- Docstring.of_comments ~diagnostics comments; last_pos := impl.loc_ -let debug_tokens_info name tokens = +let parse_by_menhir ~diagnostics segments = + (Basic_lst.concat_map segments (fun x -> menhir_parse_toplevel ~diagnostics x) + : Syntax.impls) + +let parse_by_handrolled ~diagnostics segments = + (Basic_lst.concat_map segments (fun segment -> + let state = Parser_core.init_state ~diagnostics segment in + Parser_main.parse_toplevel state) + : Syntax.impls) + +let parse_segment ~diagnostics segment = + (let menhir_diag = Diagnostics.make () in + let menhir_output = menhir_parse_toplevel ~diagnostics:menhir_diag segment in + if not (Diagnostics.has_fatal_errors menhir_diag) then ( + Diagnostics.merge_into diagnostics menhir_diag; + menhir_output) + else ( + Segment.reset segment; + let hand_diag = Diagnostics.make () in + let state = Parser_core.init_state ~diagnostics:hand_diag segment in + let hand_output = Parser_main.parse_toplevel state in + if Diagnostics.has_fatal_errors hand_diag then + Diagnostics.merge_into diagnostics hand_diag + else Diagnostics.merge_into diagnostics menhir_diag; + hand_output) + : Syntax.impls) + +let parse_by_mix ~diagnostics segments = + (Basic_lst.concat_map segments (parse_segment ~diagnostics) : Syntax.impls) + +let check_ast ~diagnostics ?name segment menhir_ast handrolled_ast = + Basic_ref.protect Basic_config.show_loc false (fun _ -> + let s1 = Syntax.sexp_of_impls menhir_ast in + let s2 = Syntax.sexp_of_impls handrolled_ast in + if not (S.equal s1 s2) then + Diagnostics.add_warning diagnostics + { + kind = + Warnings.Parser_inconsistency + { + file_name = Option.value ~default:"unknown file" name; + segment = S.to_string (Parsing_segment.sexp_of_t segment); + is_menhir_succeed = true; + is_handrolled_succeed = true; + }; + loc = Loc.no_location; + }) + +let impl_of_segments ~diagnostics ?name ~docstrings ~transform + (segments : Segment.t list) = + (let ast = + match Basic_config.current_parser () with + | `Menhir -> parse_by_menhir ~diagnostics segments + | `Handrolled -> parse_by_handrolled ~diagnostics segments + | `Both -> ( + match Basic_config.env with + | Release -> parse_by_mix ~diagnostics segments + | Debug -> + Basic_lst.concat_map segments (fun segment -> + let menhir_diagnostics = Diagnostics.make () in + let handrolled_diagnostics = Diagnostics.make () in + let menhir_ast = + menhir_parse_toplevel ~diagnostics:menhir_diagnostics segment + in + Segment.reset segment; + let handrolled_ast = + let state = + Parser_core.init_state ~diagnostics:handrolled_diagnostics + segment + in + Parser_main.parse_toplevel state + in + let report_inconsistency is_menhir_succeed + is_handrolled_succeed = + Diagnostics.add_warning diagnostics + { + kind = + Warnings.Parser_inconsistency + { + file_name = + Option.value ~default:"unknown file" name; + segment = + S.to_string + ((Segment.sexp_of_t [@merlin.hide]) segment); + is_menhir_succeed; + is_handrolled_succeed; + }; + loc = Loc.no_location; + } + in + match + ( not (Diagnostics.has_fatal_errors menhir_diagnostics), + not (Diagnostics.has_fatal_errors handrolled_diagnostics) + ) + with + | true, true -> + check_ast ~diagnostics:handrolled_diagnostics ?name segment + menhir_ast handrolled_ast; + Diagnostics.merge_into diagnostics handrolled_diagnostics; + menhir_ast + | false, false -> + Diagnostics.merge_into diagnostics handrolled_diagnostics; + handrolled_ast + | false, true -> + report_inconsistency false true; + Diagnostics.merge_into diagnostics menhir_diagnostics; + handrolled_ast + | true, false -> + report_inconsistency true false; + Diagnostics.merge_into diagnostics menhir_diagnostics; + menhir_ast)) + in + let last_pos = ref Loc.no_location in + Lst.iter ast ~f:(doc_search ~diagnostics docstrings last_pos); + if transform then Ast_lint.post_process ~diagnostics ast else ast + : Syntax.impls) + +let debug_tokens_info name (tokens_list : Vec_token.t list) = + let str = + String.concat "\n" (Lst.map tokens_list Vec_token.string_of_tokens) + in match name with - | Some name -> - Basic_io.write (name ^ ".tokens") (tokens |> Vec_token.string_of_tokens) - | None -> S.print (Vec_token.sexp_of_t tokens) - -let parse_by_menhir ~diagnostics segments : Syntax.impls = - Basic_lst.concat_map segments (fun x -> menhir_parse_toplevel ~diagnostics x) - -let parse_segment ~diagnostics segment : Syntax.impls = - menhir_parse_toplevel ~diagnostics segment - -let impl_of_string ~diagnostics ?name ?(debug_tokens = false) ?directive_handler - ~transform source = - let docstrings = Basic_vec.empty () in - let tokens = - Unicode_lex.tokens_of_string ?name ~docstrings source ~comment:true - ~diagnostics + | Some name -> Basic_io.write (name ^ ".tokens") str + | None -> print_endline str + +let debug_segment_info name source = + let diagnostics = Diagnostics.make () in + let text_segs = Text_segment.of_string ~name:"" source in + let slice_points = + Lst.concat_map text_segs (fun text_segment -> + let docstrings = Basic_vec.empty () in + let tokens = + Unicode_lex.tokens_of_segment ~diagnostics ~docstrings ~comment:true + text_segment + in + let segments = Toplevel_segments.toplevel_segments tokens in + Lst.map segments (fun seg -> (Segment.get_start_pos seg).pos_lnum)) in - if debug_tokens then debug_tokens_info name tokens; - let directive, start_position = Header_parser.parse tokens in - (match directive_handler with None -> () | Some f -> f directive); - let segments = Segment.toplevel_segments ~start:start_position tokens in - let ast = - parse_by_menhir ~diagnostics segments + let codes = String.split_on_char '\n' source in + let divider = " +------------------------\n" in + let buf = Buffer.create 1024 in + let add_line line code = + Buffer.add_string buf (Printf.sprintf "%6d | %s\n" line code) + in + let rec loop slice_points current_line = function + | [] -> Buffer.contents buf + | code :: codes -> + let slice_points = + match slice_points with + | point :: points when point = current_line -> + Buffer.add_string buf divider; + points + | points -> points + in + add_line current_line code; + loop slice_points (current_line + 1) codes + in + let str = loop slice_points 1 codes in + match name with + | Some name -> Basic_io.write (name ^ ".segments") str + | None -> print_endline str + +let impl_of_string ~diagnostics ?name ?(debug_tokens = false) + ?(debug_segments = false) ?directive_handler ~transform source = + let text_segs = Text_segment.of_string ?name source in + let directive = ref [] in + let pairs = + let first = ref true in + Basic_lst.map text_segs (fun text_segment -> + let docstrings = Basic_vec.empty () in + let tokens = + Unicode_lex.tokens_of_segment ~diagnostics ~docstrings ~comment:true + text_segment + in + let segments = Toplevel_segments.toplevel_segments tokens in + if !first then ( + first := false; + match (segments, directive_handler) with + | seg :: _, Some handler -> + let ds = Header_parser.parse seg in + directive := ds; + handler ds + | _ -> ()); + let ast = + impl_of_segments ~diagnostics ?name ~transform ~docstrings segments + in + (ast, tokens)) in - let last_pos = ref Loc.no_location in - Basic_lst.iter ast (doc_search ~diagnostics docstrings last_pos); - let ast = if transform then Ast_lint.post_process ~diagnostics ast else ast in - { ast; tokens; directive; name = Option.value ~default:"" name } + let tokens_list = Lst.map pairs snd in + if debug_segments then debug_segment_info name source; + if debug_tokens then debug_tokens_info name tokens_list; + let ast = List.concat_map fst pairs in + let pkg = !Basic_config.current_package in + { + ast; + directive = !directive; + tokens_list; + name = Option.value ~default:"" name; + pkg; + } -let parse ~diagnostics ?(debug_tokens = false) ?directive_handler ~transform - path = +let parse ~diagnostics ?(debug_tokens = false) ?(debug_segments = false) + ?directive_handler ~transform path = try - In_channel.with_open_bin path In_channel.input_all - |> impl_of_string ~diagnostics ~debug_tokens ~transform ?directive_handler - ~name:(Filename.basename path) + impl_of_string ~diagnostics ~debug_tokens ~debug_segments ~transform + ?directive_handler ~name:(Filename.basename path) + (In_channel.with_open_bin path In_channel.input_all) with Sys_error _ -> raise (Arg.Bad ("cannot open file: " ^ path)) diff --git a/src/parsing_parser.ml b/src/parsing_parser.ml index df95b75..7077f27 100644 --- a/src/parsing_parser.ml +++ b/src/parsing_parser.ml @@ -44,7972 +44,4972 @@ and make_Ppat_constr = Parsing_util.make_Ppat_constr and make_Ppat_constant = Parsing_util.make_Ppat_constant and make_Ppat_tuple = Parsing_util.make_Ppat_tuple and make_Ptype_option = Parsing_util.make_Ptype_option +and make_attribute = Parsing_util.make_attribute and make_Ptype_tuple = Parsing_util.make_Ptype_tuple type ('s, 'r) _menhir_state = | MenhirState0000 : ('s, _menhir_box_expression) _menhir_state - | MenhirState0001 : (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_state - | MenhirState0006 : (('s, 'r) _menhir_cell1_PLUS, 'r) _menhir_state - | MenhirState0012 : (('s, 'r) _menhir_cell1_MINUS, 'r) _menhir_state - | MenhirState0013 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state - | MenhirState0014 : (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_state - | MenhirState0015 : (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_state - | MenhirState0018 - : ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0021 : (('s, 'r) _menhir_cell1_LOOP, 'r) _menhir_state - | MenhirState0022 : (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_state - | MenhirState0024 : (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_state - | MenhirState0026 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_TRUE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0029 : (('s, 'r) _menhir_cell1_IF, 'r) _menhir_state - | MenhirState0031 - : (('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, 'r) _menhir_state - | MenhirState0032 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, + | MenhirState0003 : (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_state + | MenhirState0006 : (('s, 'r) _menhir_cell1_POST_LABEL, 'r) _menhir_state + | MenhirState0008 : (('s, 'r) _menhir_cell1_PLUS, 'r) _menhir_state + | MenhirState0014 : (('s, 'r) _menhir_cell1_MINUS, 'r) _menhir_state + | MenhirState0015 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state + | MenhirState0016 : (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_state + | MenhirState0019 : + ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0020 : (('s, 'r) _menhir_cell1_POST_LABEL, 'r) _menhir_state + | MenhirState0024 : + ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_optional_question + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0025 : (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_state + | MenhirState0026 : (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_state + | MenhirState0027 : (('s, 'r) _menhir_cell1_RETURN, 'r) _menhir_state + | MenhirState0030 : (('s, 'r) _menhir_cell1_IF, 'r) _menhir_state + | MenhirState0031 : (('s, 'r) _menhir_cell1_FN, 'r) _menhir_state + | MenhirState0033 : + ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_optional_bang, + 'r ) + _menhir_state + | MenhirState0034 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state + | MenhirState0036 : + (('s, 'r) _menhir_cell1_UNDERSCORE _menhir_cell0_COLON, 'r) _menhir_state + | MenhirState0042 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state + | MenhirState0044 : + ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0047 : + (('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r) _menhir_state + | MenhirState0049 : + ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) - _menhir_state - | MenhirState0033 : (('s, 'r) _menhir_cell1_THIN_ARROW, 'r) _menhir_state - | MenhirState0039 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state - | MenhirState0041 - : ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_RPAREN, + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0050 : (('s, 'r) _menhir_cell1_AMPER, 'r) _menhir_state + | MenhirState0053 : (('s, 'r) _menhir_cell1_type_, 'r) _menhir_state + | MenhirState0055 : + ( (('s, 'r) _menhir_cell1_type_, 'r) _menhir_cell1_EXCLAMATION, + 'r ) + _menhir_state + | MenhirState0056 : + ( ( (('s, 'r) _menhir_cell1_type_, 'r) _menhir_cell1_EXCLAMATION, 'r ) - _menhir_state - | MenhirState0043 : (('s, 'r) _menhir_cell1_type_, 'r) _menhir_state - | MenhirState0045 - : ( (('s, 'r) _menhir_cell1_type_, 'r) _menhir_cell1_EXCLAMATION, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0058 : + ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_LBRACKET, + 'r ) + _menhir_state + | MenhirState0059 : (('s, 'r) _menhir_cell1_type_, 'r) _menhir_state + | MenhirState0060 : + ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__, + 'r ) + _menhir_state + | MenhirState0061 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__, 'r ) - _menhir_state - | MenhirState0046 - : ( ( (('s, 'r) _menhir_cell1_type_, 'r) _menhir_cell1_EXCLAMATION, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0062 : + ( ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__, 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState0048 - : ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_LBRACKET, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0049 : (('s, 'r) _menhir_cell1_type_, 'r) _menhir_state - | MenhirState0051 - : ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__ - _menhir_cell0_COMMA, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0069 : + ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) - _menhir_state - | MenhirState0052 - : ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__ - _menhir_cell0_COMMA, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0071 : + ( ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0059 - : ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState0061 - : ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_state - | MenhirState0064 - : ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0073 : + ( ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) - _menhir_cell1_COMMA, + _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0067 - : ( ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0075 : + ( ( ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) - _menhir_cell1_COMMA, + _menhir_cell1_type_, 'r ) - _menhir_cell1_non_empty_list_commas_type__ - _menhir_cell0_RPAREN, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0071 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0079 : + ( ( ( ( ('s, 'r) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, 'r ) - _menhir_cell1_RPAREN, + _menhir_cell1_type_, 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0072 : (('s, 'r) _menhir_cell1_RETURN, 'r) _menhir_state - | MenhirState0073 : (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_state - | MenhirState0076 - : ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0086 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_QUESTION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0090 - : ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0095 - : ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0098 - : (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state - | MenhirState0101 : (('s, 'r) _menhir_cell1_prefix_expr, 'r) _menhir_state - | MenhirState0105 - : (('s, 'r) _menhir_cell1_pipe_expr _menhir_cell0_PIPE, 'r) _menhir_state - | MenhirState0111 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_RANGE_INCLUSIVE, - 'r ) - _menhir_state - | MenhirState0113 - : (('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_PLUS, 'r) _menhir_state - | MenhirState0115 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_INFIX4, - 'r ) - _menhir_state - | MenhirState0117 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_INFIX3, - 'r ) - _menhir_state - | MenhirState0119 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_MINUS, - 'r ) - _menhir_state - | MenhirState0121 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_INFIX2, - 'r ) - _menhir_state - | MenhirState0123 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_INFIX1, - 'r ) - _menhir_state - | MenhirState0125 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_CARET, - 'r ) - _menhir_state - | MenhirState0127 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_AMPER, - 'r ) - _menhir_state - | MenhirState0129 - : (('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_BAR, 'r) _menhir_state - | MenhirState0131 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_RANGE_EXCLUSIVE, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0133 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_BARBAR, + _menhir_cell1_non_empty_list_commas_type__ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0082 : + ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0084 : + ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0135 - : ( ('s, 'r) _menhir_cell1_infix_expr _menhir_cell0_AMPERAMPER, + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0086 : + ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0144 - : ( ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0088 : + ( ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, 'r ) - _menhir_cell1_DOTDOT, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0147 - : ( ( ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_DOTDOT, + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0092 : + ( ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_type_, 'r ) - _menhir_cell1_expr - _menhir_cell0_COMMA, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0151 - : ( ( (('s, 'r) _menhir_cell1_DOTDOT, 'r) _menhir_cell1_expr - _menhir_cell0_COMMA, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ - _menhir_cell0_COMMA, + _menhir_cell1_non_empty_list_commas_type__ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0094 : + ( ( ('s, 'r) _menhir_cell1_UNDERSCORE _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0158 - : ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ - _menhir_cell0_COMMA, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0096 : + (('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_EQUAL, 'r) _menhir_state + | MenhirState0102 : (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_state + | MenhirState0103 : + ((('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r) _menhir_state + | MenhirState0104 : + ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_state - | MenhirState0160 - : (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_EQUAL, 'r) _menhir_state - | MenhirState0164 - : ( ( 's _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, + 'r ) + _menhir_state + | MenhirState0106 : + ( ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_cell1_non_empty_list_commas_rev_argument_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0172 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, 'r ) - _menhir_state - | MenhirState0176 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState0177 - : ( ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, + _menhir_cell1_parameters, + 'r ) + _menhir_state + | MenhirState0107 : + ( ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_COLON, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0183 - : ( ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, + _menhir_cell1_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0109 : + ( ( ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, + 'r ) + _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_expr - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0188 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0194 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_QUESTION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0198 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0203 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0211 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_QUESTION - _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0215 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0220 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_option___anonymous_14_, + 'r ) + _menhir_state + | MenhirState0110 : (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_state + | MenhirState0111 : (('s, 'r) _menhir_cell1_RAISE, 'r) _menhir_state + | MenhirState0112 : (('s, 'r) _menhir_cell1_AMPER, 'r) _menhir_state + | MenhirState0119 : + ( ('s, 'r) _menhir_cell1_type_name _menhir_cell0_COLONCOLON + _menhir_cell0_LBRACE, + 'r ) + _menhir_state + | MenhirState0121 : + (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state + | MenhirState0125 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_QUESTION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0128 : (('s, 'r) _menhir_cell1_range_expr, 'r) _menhir_state + | MenhirState0136 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state + | MenhirState0138 : (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_state + | MenhirState0139 : (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_state + | MenhirState0141 : (('s, 'r) _menhir_cell1_MINUS, 'r) _menhir_state + | MenhirState0145 : + (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state + | MenhirState0155 : + ( ('s, 'r) _menhir_cell1_simple_pattern _menhir_cell0_RANGE_INCLUSIVE, + 'r ) + _menhir_state + | MenhirState0159 : + (('s, 'r) _menhir_cell1_constr _menhir_cell0_LPAREN, 'r) _menhir_state + | MenhirState0162 : + (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_EQUAL, 'r) _menhir_state + | MenhirState0164 : + (('s, 'r) _menhir_cell1_range_pattern _menhir_cell0_BAR, 'r) _menhir_state + | MenhirState0170 : (('s, 'r) _menhir_cell1_DOTDOT, 'r) _menhir_state + | MenhirState0176 : + (('s, 'r) _menhir_cell1_constr_pat_argument, 'r) _menhir_state + | MenhirState0177 : + ( (('s, 'r) _menhir_cell1_constr_pat_argument, 'r) _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0181 : + ( ('s, 'r) _menhir_cell1_simple_pattern _menhir_cell0_RANGE_EXCLUSIVE, + 'r ) + _menhir_state + | MenhirState0184 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_DOTDOT, + 'r ) + _menhir_state + | MenhirState0191 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0226 - : ( ( ('s, 'r) _menhir_cell1_FOR, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_foreach_binder_ - _menhir_cell0_COMMA, + _menhir_cell1_non_empty_list_commas_with_tail_map_elem_pat_ + _menhir_cell0_DOTDOT, + 'r ) + _menhir_state + | MenhirState0194 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0232 - : ( ( ('s, 'r) _menhir_cell1_FOR, - 'r ) - _menhir_cell1_non_empty_list_commas_rev___anonymous_11_ - _menhir_cell0_COMMA - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL, + _menhir_cell1_non_empty_list_commas_with_tail_fields_pat_single_ + _menhir_cell0_DOTDOT, + 'r ) + _menhir_state + | MenhirState0196 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0236 - : ( ( ('s, 'r) _menhir_cell1_FOR, + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, + 'r ) + _menhir_state + | MenhirState0197 : + ( ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, 'r ) - _menhir_state - | MenhirState0238 - : ( ( ( ('s, 'r) _menhir_cell1_FOR, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0198 : + ( ( ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, 'r ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, + _menhir_cell1_COMMA, 'r ) - _menhir_state - | MenhirState0239 - : ( ( ( ( ('s, 'r) _menhir_cell1_FOR, + _menhir_cell1_map_syntax_key, + 'r ) + _menhir_state + | MenhirState0201 : + ( ( ( ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - 'r ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0241 - : (('s, 'r) _menhir_cell1_ELSE _menhir_cell0_LBRACE, 'r) _menhir_state - | MenhirState0243 : (('s, 'r) _menhir_cell1_RAISE, 'r) _menhir_state - | MenhirState0248 : (('s, 'r) _menhir_cell1_LET, 'r) _menhir_state - | MenhirState0250 : (('s, 'r) _menhir_cell1_UIDENT, 'r) _menhir_state - | MenhirState0251 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state - | MenhirState0256 - : ( ('s, 'r) _menhir_cell1_PACKAGE_NAME _menhir_cell0_DOT_UIDENT, - 'r ) - _menhir_state - | MenhirState0261 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state - | MenhirState0263 : (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_state - | MenhirState0264 : (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_state - | MenhirState0267 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_TRUE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0273 - : ( ('s, 'r) _menhir_cell1_simple_pattern _menhir_cell0_RANGE_INCLUSIVE, - 'r ) - _menhir_state - | MenhirState0277 - : ( ('s, 'r) _menhir_cell1_qual_ident_ty _menhir_cell0_COLONCOLON - _menhir_cell0_UIDENT, - 'r ) - _menhir_state - | MenhirState0279 - : ( ('s, 'r) _menhir_cell1_simple_pattern _menhir_cell0_RANGE_EXCLUSIVE, - 'r ) - _menhir_state - | MenhirState0282 - : ( ('s, 'r) _menhir_cell1_range_pattern _menhir_cell0_BAR, - 'r ) - _menhir_state - | MenhirState0288 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_TRUE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0292 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_STRING - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0294 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_STRING - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0300 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0302 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS - _menhir_cell0_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0306 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0308 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0311 - : (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state - | MenhirState0315 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0317 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0321 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0323 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0327 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FALSE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0329 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FALSE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0333 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_CHAR - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0335 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_CHAR - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0339 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTES - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0341 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTES - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0345 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0347 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0358 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0360 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0364 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_STRING - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0366 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_STRING - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0371 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0373 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0377 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0379 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0383 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0385 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0389 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0391 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0395 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0397 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0401 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0403 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0407 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0409 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0413 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_QUESTION - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0415 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0418 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0425 - : ( (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_cell1_DOTDOT, - 'r ) - _menhir_state - | MenhirState0429 - : ( ( (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_cell1_DOTDOT, - 'r ) - _menhir_cell1_option___anonymous_18_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0432 - : ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_pattern_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0436 - : ( ( ('s, 'r) _menhir_cell1_LBRACKET, - 'r ) - _menhir_cell1_non_empty_list_commas_with_tail_pattern_ - _menhir_cell0_DOTDOT, - 'r ) - _menhir_state - | MenhirState0438 - : ( ( ( ('s, 'r) _menhir_cell1_LBRACKET, + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, 'r ) - _menhir_cell1_non_empty_list_commas_with_tail_pattern_ - _menhir_cell0_DOTDOT, - 'r ) - _menhir_cell1_option___anonymous_18_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0441 - : ( ( ('s, 'r) _menhir_cell1_LBRACKET, + _menhir_cell1_COMMA, 'r ) - _menhir_cell1_non_empty_list_commas_rev_pattern_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0447 - : ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern - _menhir_cell0_COMMA, + _menhir_cell1_map_syntax_key, 'r ) - _menhir_state - | MenhirState0450 - : ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern - _menhir_cell0_COLON, + _menhir_cell1_option_QUESTION_ + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0204 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0451 - : ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern - _menhir_cell0_COLON, + _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_, + 'r ) + _menhir_state + | MenhirState0205 : + ( ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_, 'r ) - _menhir_state - | MenhirState0454 - : (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_EQUAL, 'r) _menhir_state - | MenhirState0463 - : ( ('s, 'r) _menhir_cell1_constr_pat_argument _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0468 - : ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0470 - : ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_COLON, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0212 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_map_syntax_key, + 'r ) + _menhir_state + | MenhirState0214 : + ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_map_syntax_key, 'r ) - _menhir_state - | MenhirState0471 - : ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, + _menhir_cell1_option_QUESTION_ + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0223 : + ( ('s, 'r) _menhir_cell1_DOTDOT _menhir_cell0_LIDENT _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0226 : + ( ( 's _menhir_cell0_COMMA, 'r ) - _menhir_state - | MenhirState0472 - : ( ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list_commas_rev_array_sub_pattern_, + 'r ) + _menhir_state + | MenhirState0227 : + ( ( ( 's _menhir_cell0_COMMA, 'r ) - _menhir_cell1_EQUAL, + _menhir_cell1_non_empty_list_commas_rev_array_sub_pattern_, 'r ) - _menhir_state - | MenhirState0475 - : ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern - _menhir_cell0_EQUAL, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0232 : + (('s, 'r) _menhir_cell1_DOTDOT _menhir_cell0_COMMA, 'r) _menhir_state + | MenhirState0236 : + ( ('s, 'r) _menhir_cell1_DOTDOT _menhir_cell0_LIDENT _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0241 : + ( ('s, 'r) _menhir_cell1_array_sub_pattern _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0245 : + ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern + _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0247 : + ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_pattern_, + 'r ) + _menhir_state + | MenhirState0248 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_pattern_, 'r ) - _menhir_state - | MenhirState0477 - : ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0253 : + ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0254 : + ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0478 - : ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState0479 - : ( ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_cell1_EQUAL, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0257 : (('s, 'r) _menhir_cell1_range_expr, 'r) _menhir_state + | MenhirState0261 : + ( ('s, 'r) _menhir_cell1_prefix_expr _menhir_cell0_RANGE_INCLUSIVE, + 'r ) + _menhir_state + | MenhirState0263 : + ( ('s, 'r) _menhir_cell1_non_empty_list_rev_multiline_string_, + 'r ) + _menhir_state + | MenhirState0267 : + (('s, 'r) _menhir_cell1_fn_header_no_binder, 'r) _menhir_state + | MenhirState0270 : + ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_multi_pattern_case_, + 'r ) + _menhir_state + | MenhirState0271 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_multi_pattern_case_, 'r ) - _menhir_state - | MenhirState0481 : (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_state - | MenhirState0482 - : ((('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, 'r) _menhir_state - | MenhirState0484 - : ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_EQUAL, + _menhir_cell1_SEMI, + 'r ) + _menhir_state + | MenhirState0273 : + ( ('s, 'r) _menhir_cell1_non_empty_list_commas_pattern_ _menhir_cell0_IF, + 'r ) + _menhir_state + | MenhirState0276 : + (('s, 'r) _menhir_cell1_pipe_expr _menhir_cell0_PIPE, 'r) _menhir_state + | MenhirState0277 : + ( ( ('s, 'r) _menhir_cell1_pipe_expr _menhir_cell0_PIPE, 'r ) - _menhir_state - | MenhirState0487 - : ( ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_EQUAL, - 'r ) - _menhir_cell1_infix_expr - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0278 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_PLUS, + 'r ) + _menhir_state + | MenhirState0279 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_PLUS, 'r ) - _menhir_state - | MenhirState0491 - : ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0280 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX4, + 'r ) + _menhir_state + | MenhirState0284 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX3, + 'r ) + _menhir_state + | MenhirState0285 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX3, 'r ) - _menhir_state - | MenhirState0492 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0286 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_MINUS, + 'r ) + _menhir_state + | MenhirState0287 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_MINUS, 'r ) - _menhir_state - | MenhirState0495 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0288 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX2, + 'r ) + _menhir_state + | MenhirState0289 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX2, 'r ) - _menhir_state - | MenhirState0498 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0290 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX1, + 'r ) + _menhir_state + | MenhirState0291 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_INFIX1, 'r ) - _menhir_state - | MenhirState0500 - : ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_expr_ - _menhir_cell0_COMMA, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0292 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_CARET, + 'r ) + _menhir_state + | MenhirState0293 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_CARET, 'r ) - _menhir_state - | MenhirState0504 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0294 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_AMPER, + 'r ) + _menhir_state + | MenhirState0295 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_AMPER, 'r ) - _menhir_state - | MenhirState0507 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0296 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_BARBAR, + 'r ) + _menhir_state + | MenhirState0297 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_BARBAR, 'r ) - _menhir_state - | MenhirState0510 - : ( ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0298 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_BAR, + 'r ) + _menhir_state + | MenhirState0299 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_BAR, 'r ) - _menhir_state - | MenhirState0512 - : ( ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0300 : + ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_AMPERAMPER, + 'r ) + _menhir_state + | MenhirState0301 : + ( ( (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_cell1_AMPERAMPER, 'r ) - _menhir_state - | MenhirState0515 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0304 : + ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_WHILE, + 'r ) + _menhir_state + | MenhirState0305 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_WHILE, 'r ) - _menhir_state - | MenhirState0517 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0306 : + ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_WHILE, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_infix_expr, 'r ) - _menhir_state - | MenhirState0520 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, + _menhir_cell1_block_expr, + 'r ) + _menhir_state + | MenhirState0307 : + ( (('s, 'r) _menhir_cell1_block_expr, 'r) _menhir_cell1_ELSE, + 'r ) + _menhir_state + | MenhirState0310 : + ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_LOOP, + 'r ) + _menhir_state + | MenhirState0311 : + (('s, 'r) _menhir_cell1_non_empty_list_commas_rev_expr_, 'r) _menhir_state + | MenhirState0312 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_expr_, 'r ) - _menhir_state - | MenhirState0522 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0314 : (('s, 'r) _menhir_cell1_infix_expr, 'r) _menhir_state + | MenhirState0320 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_LOOP, 'r ) - _menhir_state - | MenhirState0525 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, + _menhir_cell1_non_empty_list_commas_no_trailing_expr_ + _menhir_cell0_LBRACE, + 'r ) + _menhir_state + | MenhirState0325 : + ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + 'r ) + _menhir_state + | MenhirState0328 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_state - | MenhirState0527 - : ( ( ('s _menhir_cell0_LBRACE, 'r) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_LIDENT + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0330 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_state - | MenhirState0532 - : ( ( 's _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list_commas_rev_foreach_binder_, + 'r ) + _menhir_state + | MenhirState0331 : + ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, + _menhir_cell1_non_empty_list_commas_rev_foreach_binder_, 'r ) - _menhir_state - | MenhirState0534 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0338 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_state - | MenhirState0535 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, + _menhir_cell1_non_empty_list_commas_rev___anonymous_10_ + _menhir_cell0_COMMA + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0342 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_state - | MenhirState0537 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN, + 'r ) + _menhir_state + | MenhirState0343 : + ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_RAISE, + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN, 'r ) - _menhir_state - | MenhirState0540 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, + _menhir_cell1_expr, + 'r ) + _menhir_state + | MenhirState0344 : + ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN, 'r ) - _menhir_cell1_CONTINUE, + _menhir_cell1_expr, 'r ) - _menhir_state - | MenhirState0542 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, + _menhir_cell1_block_expr, + 'r ) + _menhir_state + | MenhirState0348 : + ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_state - | MenhirState0545 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_for_binders, + 'r ) + _menhir_state + | MenhirState0349 : + ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_for_binders, 'r ) - _menhir_state - | MenhirState0548 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_SEMI, + 'r ) + _menhir_state + | MenhirState0353 : + ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_for_binders, 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, + _menhir_cell1_SEMI, 'r ) - _menhir_state - | MenhirState0550 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0358 : + ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_for_binders, 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_SEMI, 'r ) - _menhir_state - | MenhirState0553 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_non_empty_list_commas_rev___anonymous_11_ + _menhir_cell0_COMMA + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0361 : + ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_for_binders, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, + _menhir_cell1_SEMI, 'r ) - _menhir_state - | MenhirState0555 - : ( ( ( ( 's _menhir_cell0_LBRACE, + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_list_commas_no_trailing___anonymous_11_, + 'r ) + _menhir_state + | MenhirState0362 : + ( ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, + _menhir_cell1_for_binders, 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_SEMI, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_list_commas_no_trailing___anonymous_11_, 'r ) - _menhir_state - | MenhirState0558 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, + _menhir_cell1_block_expr, + 'r ) + _menhir_state + | MenhirState0364 : + ( ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_for_binders, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, + _menhir_cell1_SEMI, 'r ) - _menhir_state - | MenhirState0560 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0365 : + ( ( ( ('s, 'r) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_for_binders, 'r ) - _menhir_state - | MenhirState0563 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, + _menhir_cell1_block_expr, + 'r ) + _menhir_state + | MenhirState0369 : + ( ('s, 'r) _menhir_cell1_non_empty_list_commas_pattern_ + _menhir_cell0_option___anonymous_9_ + _menhir_cell0_FAT_ARROW, + 'r ) + _menhir_state + | MenhirState0374 : (('s, 'r) _menhir_cell1_CONTINUE, 'r) _menhir_state + | MenhirState0375 : + ( (('s, 'r) _menhir_cell1_CONTINUE, 'r) _menhir_cell1_POST_LABEL, + 'r ) + _menhir_state + | MenhirState0379 : (('s, 'r) _menhir_cell1_BREAK, 'r) _menhir_state + | MenhirState0380 : + ( (('s, 'r) _menhir_cell1_BREAK, 'r) _menhir_cell1_POST_LABEL, + 'r ) + _menhir_state + | MenhirState0385 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0386 : + ( ( 's _menhir_cell0_LPAREN, 'r ) - _menhir_state - | MenhirState0565 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_rev_argument_, + 'r ) + _menhir_state + | MenhirState0387 : + ( ( ( 's _menhir_cell0_LPAREN, 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_non_empty_list_commas_rev_argument_, 'r ) - _menhir_state - | MenhirState0570 - : ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_infix_expr - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0574 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0575 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0395 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, + 'r ) + _menhir_state + | MenhirState0397 : + ( ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, 'r ) - _menhir_state - | MenhirState0576 : (('s, 'r) _menhir_cell1_THIN_ARROW, 'r) _menhir_state - | MenhirState0579 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ + _menhir_cell1_option_expr_ + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0403 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0407 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0412 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_QUESTION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0415 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0419 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0423 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0430 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_QUESTION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0433 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0437 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0441 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN, + 'r ) + _menhir_state + | MenhirState0446 : + (('s, 'r) _menhir_cell1_left_value _menhir_cell0_EQUAL, 'r) _menhir_state + | MenhirState0448 : + ( ('s, 'r) _menhir_cell1_left_value _menhir_cell0_AUGMENTED_ASSIGNMENT, + 'r ) + _menhir_state + | MenhirState0456 : + ( ('s, 'r) _menhir_cell1_prefix_expr _menhir_cell0_RANGE_EXCLUSIVE, + 'r ) + _menhir_state + | MenhirState0460 : + ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, + 'r ) + _menhir_state + | MenhirState0466 : + ( ( ('s, 'r) _menhir_cell1_type_name _menhir_cell0_COLONCOLON _menhir_cell0_LBRACE, 'r ) - _menhir_state - | MenhirState0582 : (('s, 'r) _menhir_cell1_CONTINUE, 'r) _menhir_state - | MenhirState0584 : (('s, 'r) _menhir_cell1_BREAK, 'r) _menhir_state - | MenhirState0588 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState0591 - : ( ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0593 - : ( ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0596 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0598 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0601 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0603 - : ( ('s, 'r) _menhir_cell1_simple_expr _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0606 - : ( ('s, 'r) _menhir_cell1_qual_ident _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0608 - : ( ('s, 'r) _menhir_cell1_qual_ident _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0611 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ + _menhir_cell1_DOTDOT, + 'r ) + _menhir_state + | MenhirState0469 : + ( ( ( ('s, 'r) _menhir_cell1_type_name _menhir_cell0_COLONCOLON _menhir_cell0_LBRACE, 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0618 - : ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0620 - : ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, + _menhir_cell1_DOTDOT, 'r ) - _menhir_state - | MenhirState0621 - : ( ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, + _menhir_cell1_expr + _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0471 : + ( ( (('s, 'r) _menhir_cell1_DOTDOT, 'r) _menhir_cell1_expr + _menhir_cell0_COMMA, 'r ) - _menhir_state - | MenhirState0622 - : ( ( ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_cell1_EQUAL, + _menhir_cell1_non_empty_list_commas_rev_record_defn_single_, + 'r ) + _menhir_state + | MenhirState0472 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_record_defn_single_, 'r ) - _menhir_state - | MenhirState0626 - : ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0479 : + ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_record_defn_single_, + 'r ) + _menhir_state + | MenhirState0484 : (('s, 'r) _menhir_cell1_LET, 'r) _menhir_state + | MenhirState0487 : + ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0489 : + ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0490 : + ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0627 - : ( ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0491 : + ( ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT _menhir_cell0_COLON, 'r ) _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0628 - : (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state - | MenhirState0629 - : ( ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState0632 - : ( ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_parameter_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0636 - : ( ('s, 'r) _menhir_cell1_fn_label _menhir_cell0_QUESTION + _menhir_cell1_EQUAL, + 'r ) + _menhir_state + | MenhirState0494 : + ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0496 : + ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0497 : + ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0637 - : ( ( ('s, 'r) _menhir_cell1_fn_label _menhir_cell0_QUESTION + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0498 : + ( ( ( (('s, 'r) _menhir_cell1_LET, 'r) _menhir_cell1_pattern _menhir_cell0_COLON, 'r ) _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0638 - : (('s, 'r) _menhir_cell1_fn_label _menhir_cell0_EQUAL, 'r) _menhir_state - | MenhirState0640 - : (('s, 'r) _menhir_cell1_fn_label _menhir_cell0_COLON, 'r) _menhir_state - | MenhirState0641 - : ( ( ('s, 'r) _menhir_cell1_fn_label _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState0642 - : ( ( ( ('s, 'r) _menhir_cell1_fn_label _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_cell1_EQUAL, + _menhir_cell1_EQUAL, + 'r ) + _menhir_state + | MenhirState0500 : (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_state + | MenhirState0501 : + ((('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, 'r) _menhir_state + | MenhirState0503 : + ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, 'r ) - _menhir_state - | MenhirState0645 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LPAREN, + _menhir_cell1_pattern + _menhir_cell0_EQUAL, + 'r ) + _menhir_state + | MenhirState0504 : + ( ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_pattern + _menhir_cell0_EQUAL, 'r ) - _menhir_state - | MenhirState0647 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LPAREN, + _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0506 : + ( ( ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_LET, 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_pattern + _menhir_cell0_EQUAL, 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, + _menhir_cell1_infix_expr, 'r ) - _menhir_state - | MenhirState0650 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_ELSE + _menhir_cell0_LBRACE, + 'r ) + _menhir_state + | MenhirState0511 : + (('s, 'r) _menhir_cell1_pattern _menhir_cell0_IF, 'r) _menhir_state + | MenhirState0514 : + ( ('s, 'r) _menhir_cell1_pattern _menhir_cell0_option___anonymous_8_ + _menhir_cell0_FAT_ARROW, + 'r ) + _menhir_state + | MenhirState0518 : + ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_single_pattern_case_, + 'r ) + _menhir_state + | MenhirState0519 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_single_pattern_case_, 'r ) - _menhir_state - | MenhirState0653 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT _menhir_cell0_LBRACE, + _menhir_cell1_SEMI, + 'r ) + _menhir_state + | MenhirState0523 : + ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0524 : + ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_infix_expr, 'r ) - _menhir_state - | MenhirState0658 - : ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_ELSE, + 'r ) + _menhir_state + | MenhirState0526 : (('s, 'r) _menhir_cell1_FN, 'r) _menhir_state + | MenhirState0527 : + ((('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_LIDENT, 'r) _menhir_state + | MenhirState0528 : + ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_LIDENT, 'r ) - _menhir_state - | MenhirState0660 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, + 'r ) + _menhir_state + | MenhirState0530 : + ( ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_LIDENT, 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_optional_bang, 'r ) - _menhir_state - | MenhirState0661 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, + 'r ) + _menhir_state + | MenhirState0531 : + ( ( ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_LIDENT, 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_RETURN, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0663 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_THIN_ARROW, + 'r ) + _menhir_state + | MenhirState0533 : + ( ( ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_LIDENT, 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_RAISE, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0666 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, + _menhir_cell1_option___anonymous_7_, + 'r ) + _menhir_state + | MenhirState0535 : (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_state + | MenhirState0536 : + ((('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r) _menhir_state + | MenhirState0537 : + ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_state - | MenhirState0668 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_LIDENT, + 'r ) + _menhir_state + | MenhirState0538 : + ( ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_cell1_BREAK, + _menhir_cell1_LIDENT, 'r ) - _menhir_state - | MenhirState0671 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, + 'r ) + _menhir_state + | MenhirState0539 : + ( ( ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_LIDENT, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_optional_bang, 'r ) - _menhir_state - | MenhirState0674 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, + 'r ) + _menhir_state + | MenhirState0540 : + ( ( ( ( ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_FN, 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_LIDENT, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0676 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_option___anonymous_7_, + 'r ) + _menhir_state + | MenhirState0542 : + ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_fn_header_no_binder, + 'r ) + _menhir_state + | MenhirState0545 : + ( (('s, 'r) _menhir_cell1_ASYNC, 'r) _menhir_cell1_fn_header, + 'r ) + _menhir_state + | MenhirState0550 : + ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_statement_, + 'r ) + _menhir_state + | MenhirState0551 : + ( ( ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_statement_, 'r ) - _menhir_state - | MenhirState0679 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, + _menhir_cell1_SEMI, + 'r ) + _menhir_state + | MenhirState0554 : (('s, 'r) _menhir_cell1_fn_header, 'r) _menhir_state + | MenhirState0563 : + (('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, 'r) _menhir_state + | MenhirState0564 : + ( ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0681 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0565 : + ( ( ( ('s, 'r) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_type_, 'r ) - _menhir_state - | MenhirState0684 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, + _menhir_cell1_EQUAL, + 'r ) + _menhir_state + | MenhirState0569 : + ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0570 : + ( ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_QUESTION + _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0686 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0571 : + (('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r) _menhir_state + | MenhirState0572 : + ( ( ('s, 'r) _menhir_cell1_LIDENT _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0689 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0574 : + ( ( ('s, 'r) _menhir_cell1_LPAREN, 'r ) - _menhir_state - | MenhirState0691 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_rev_parameter_, + 'r ) + _menhir_state + | MenhirState0575 : + ( ( ( ('s, 'r) _menhir_cell1_LPAREN, 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_non_empty_list_commas_rev_parameter_, 'r ) - _menhir_state - | MenhirState0695 - : ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0581 : + ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_optional_bang, 'r ) - _menhir_state - | MenhirState0696 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_parameters, + 'r ) + _menhir_state + | MenhirState0582 : + ( ( ( (('s, 'r) _menhir_cell1_FN, 'r) _menhir_cell1_optional_bang, 'r ) - _menhir_cell1_RETURN, + _menhir_cell1_parameters, 'r ) - _menhir_state - | MenhirState0698 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, + _menhir_cell1_option___anonymous_14_, + 'r ) + _menhir_state + | MenhirState0584 : + ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0586 : + ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr, 'r ) - _menhir_state - | MenhirState0701 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, + _menhir_cell1_block_expr + _menhir_cell0_ELSE, + 'r ) + _menhir_state + | MenhirState0590 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS, + 'r ) + _menhir_state + | MenhirState0595 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT + _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0597 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0598 : + ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT + _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0703 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_expr, + 'r ) + _menhir_state + | MenhirState0599 : + ( ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT + _menhir_cell0_COLON, 'r ) - _menhir_cell1_BREAK, + _menhir_cell1_expr, 'r ) - _menhir_state - | MenhirState0706 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0602 : + ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_DOTDOT, + 'r ) + _menhir_state + | MenhirState0605 : + ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_DOTDOT, 'r ) - _menhir_state - | MenhirState0709 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, + _menhir_cell1_expr + _menhir_cell0_COMMA, + 'r ) + _menhir_state + | MenhirState0613 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0711 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_non_empty_list_semi_rev_aux_statement_, + 'r ) + _menhir_state + | MenhirState0615 : + ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_state - | MenhirState0714 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_, + 'r ) + _menhir_state + | MenhirState0616 : + ( ( ( ('s, 'r) _menhir_cell1_LBRACE, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, + _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_, 'r ) - _menhir_state - | MenhirState0716 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0618 : + ( ('s, 'r) _menhir_cell1_map_syntax_key _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0626 : (('s, 'r) _menhir_cell1_DOTDOT, 'r) _menhir_state + | MenhirState0629 : + ( ( ('s, 'r) _menhir_cell1_LBRACKET, 'r ) - _menhir_state - | MenhirState0719 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_, + 'r ) + _menhir_state + | MenhirState0630 : + ( ( ( ('s, 'r) _menhir_cell1_LBRACKET, 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, + _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_, 'r ) - _menhir_state - | MenhirState0721 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0640 : + ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr, + 'r ) + _menhir_state + | MenhirState0641 : + ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr, 'r ) - _menhir_state - | MenhirState0724 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, + _menhir_cell1_LBRACE, + 'r ) + _menhir_state + | MenhirState0645 : + ( ( ('s, 'r) _menhir_cell1_LPAREN, 'r ) - _menhir_state - | MenhirState0726 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, + _menhir_cell1_non_empty_list_commas_rev_expr_, + 'r ) + _menhir_state + | MenhirState0646 : + ( ( ( ('s, 'r) _menhir_cell1_LPAREN, 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, + _menhir_cell1_non_empty_list_commas_rev_expr_, 'r ) - _menhir_state - | MenhirState0730 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_COMMA, + 'r ) + _menhir_state + | MenhirState0652 : + ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_expr + _menhir_cell0_COLON, + 'r ) + _menhir_state + | MenhirState0653 : + ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_expr + _menhir_cell0_COLON, 'r ) - _menhir_state - | MenhirState0731 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, + _menhir_cell1_type_, + 'r ) + _menhir_state + | MenhirState0662 : + ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr + _menhir_cell0_catch_keyword, + 'r ) + _menhir_state + | MenhirState0666 : + ( ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr + _menhir_cell0_catch_keyword, 'r ) - _menhir_state - | MenhirState0733 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0736 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0740 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_state - | MenhirState0742 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0745 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0748 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0752 - : (('s, 'r) _menhir_cell1_FN _menhir_cell0_LBRACE, 'r) _menhir_state - | MenhirState0757 - : ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0759 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState0760 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState0762 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState0765 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState0767 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState0770 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState0773 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0775 - : ( ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0778 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0780 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0783 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0785 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0788 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0790 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0794 - : ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState0795 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState0797 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState0800 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState0802 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState0805 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState0808 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0810 - : ( ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0813 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0815 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0818 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0820 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0823 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0825 - : ( ( ( 's _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState0829 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION + _menhir_cell1_single_pattern_cases + _menhir_cell0_RBRACE + _menhir_cell0_ELSE + _menhir_cell0_LBRACE, + 'r ) + _menhir_state + | MenhirState0672 : ('s, _menhir_box_structure) _menhir_state + | MenhirState0673 : + ( ('s, _menhir_box_structure) _menhir_cell1_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0674 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0675 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_state + | MenhirState0678 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__, + _menhir_box_structure ) + _menhir_state + | MenhirState0679 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__, + _menhir_box_structure ) + _menhir_cell1_COMMA, + _menhir_box_structure ) + _menhir_state + | MenhirState0687 : + ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0688 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState0690 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0692 : + ( ('s, _menhir_box_structure) _menhir_cell1_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0694 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState0696 : + ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState0697 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0698 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0702 : + ( ('s, _menhir_box_structure) _menhir_cell1_tvar_constraint + _menhir_cell0_PLUS, + _menhir_box_structure ) + _menhir_state + | MenhirState0707 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0708 : + ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState0709 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0710 : + ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_state + | MenhirState0712 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__, + _menhir_box_structure ) + _menhir_state + | MenhirState0713 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__, + _menhir_box_structure ) + _menhir_cell1_COMMA, + _menhir_box_structure ) + _menhir_state + | MenhirState0716 : + ( ('s, _menhir_box_structure) _menhir_cell1_luident _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0723 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_state + | MenhirState0725 : + ( ('s, _menhir_box_structure) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0726 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_POST_LABEL + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0727 : + ( ('s, _menhir_box_structure) _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0729 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters _menhir_cell0_LPAREN, - 'r ) - _menhir_state - | MenhirState0830 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_state - | MenhirState0832 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0835 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0839 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_trait_method_param_, + _menhir_box_structure ) + _menhir_state + | MenhirState0730 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_state - | MenhirState0841 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0844 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0847 - : ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0852 - : ( ( (('s, 'r) _menhir_cell1_GUARD, 'r) _menhir_cell1_infix_expr - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0856 - : ( ( ('s, 'r) _menhir_cell1_ELSE _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0861 - : ( ( ( ( ('s, 'r) _menhir_cell1_FOR, - 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - 'r ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0862 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_FOR, - 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - 'r ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0864 - : ( ( ( ( ('s, 'r) _menhir_cell1_FOR, - 'r ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - 'r ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE, - 'r ) - _menhir_state - | MenhirState0868 - : ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0872 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0874 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_trait_method_param_, + _menhir_box_structure ) + _menhir_cell1_COMMA, + _menhir_box_structure ) + _menhir_state + | MenhirState0736 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_list_commas_trait_method_param_ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW, + _menhir_box_structure ) + _menhir_state + | MenhirState0743 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0875 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0878 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0879 - : ( ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0881 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_, + _menhir_box_structure ) + _menhir_state + | MenhirState0744 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE, - 'r ) - _menhir_state - | MenhirState0886 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_rev___anonymous_12_ - _menhir_cell0_COMMA + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_, + _menhir_box_structure ) + _menhir_cell1_SEMI, + _menhir_box_structure ) + _menhir_state + | MenhirState0749 : + ( ('s, _menhir_box_structure) _menhir_cell1_TEST, + _menhir_box_structure ) + _menhir_state + | MenhirState0751 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_, + _menhir_box_structure ) + _menhir_state + | MenhirState0753 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_, + _menhir_box_structure ) + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState0754 : + ( ('s, _menhir_box_structure) _menhir_cell1_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0755 : + ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0756 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0757 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0759 : + ( ('s, _menhir_box_structure) _menhir_cell1_DERIVE _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_state + | MenhirState0761 : + ( ('s, _menhir_box_structure) _menhir_cell1_type_name _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_state + | MenhirState0764 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_DERIVE _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_deriving_directive_, + _menhir_box_structure ) + _menhir_state + | MenhirState0765 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_DERIVE _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_deriving_directive_, + _menhir_box_structure ) + _menhir_cell1_COMMA, + _menhir_box_structure ) + _menhir_state + | MenhirState0773 : + ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState0775 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0776 : + ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_state + | MenhirState0782 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr, + _menhir_box_structure ) + _menhir_state + | MenhirState0786 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr, + _menhir_box_structure ) + _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0787 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr, + _menhir_box_structure ) + _menhir_cell1_option_MUTABLE_ _menhir_cell0_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState0889 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0890 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0893 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0894 - : ( ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0896 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE, - 'r ) - _menhir_state - | MenhirState0899 - : ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0900 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0903 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0904 - : ( ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState0906 - : ( ( (('s, 'r) _menhir_cell1_FOR, 'r) _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE, - 'r ) - _menhir_state - | MenhirState0911 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0915 - : ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_state - | MenhirState0917 - : ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0920 - : ( ( ( ( ('s, 'r) _menhir_cell1_FN _menhir_cell0_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - 'r ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0924 - : ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState0926 - : ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_state - | MenhirState0927 - : ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_state - | MenhirState0930 - : ( ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0935 - : ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0937 - : ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_state - | MenhirState0938 - : ( ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_state - | MenhirState0941 - : ( ( ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0946 - : ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_state - | MenhirState0947 - : ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_state - | MenhirState0950 - : ( ( ( ( (('s, 'r) _menhir_cell1_IF, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE - _menhir_cell0_ELSE, - 'r ) - _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState0956 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_STRING - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0959 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS, - 'r ) - _menhir_state - | MenhirState0961 - : ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS, - 'r ) - _menhir_cell1_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0964 - : ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_MINUS, - 'r ) - _menhir_cell1_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0968 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0970 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0972 - : ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_LIDENT - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_expr - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0976 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_INT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0979 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0982 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_FALSE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0984 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_DOTDOT, - 'r ) - _menhir_state - | MenhirState0987 - : ( ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_DOTDOT, - 'r ) - _menhir_cell1_expr - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState0992 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_CHAR - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0995 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTES - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState0998 - : ( (('s, 'r) _menhir_cell1_LBRACE, 'r) _menhir_cell1_BYTE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1003 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState1009 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1012 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_STRING _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1016 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0788 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, + _menhir_box_structure ) + _menhir_state + | MenhirState0791 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, + _menhir_box_structure ) + _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0792 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, + _menhir_box_structure ) + _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1019 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0796 : + ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0797 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1022 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_INT + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0800 : + ( ( 's _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_, + _menhir_box_structure ) + _menhir_state + | MenhirState0801 : + ( ( ( 's _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_, + _menhir_box_structure ) + _menhir_cell1_SEMI, + _menhir_box_structure ) + _menhir_state + | MenhirState0805 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_record_decl_field_ + _menhir_cell0_RBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0807 : + ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState0809 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0811 : + ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_state + | MenhirState0812 : + ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_box_structure ) + _menhir_state + | MenhirState0814 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_box_structure ) + _menhir_cell1_POST_LABEL + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0815 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_box_structure ) + _menhir_cell1_POST_LABEL _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1025 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1028 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1031 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1034 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1037 - : ( ( ('s, 'r) _menhir_cell1_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1041 - : ( (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_cell1_DOTDOT, - 'r ) - _menhir_state - | MenhirState1044 - : ( ( ('s, 'r) _menhir_cell1_LBRACKET, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState1045 - : ( ( ( ('s, 'r) _menhir_cell1_LBRACKET, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_ - _menhir_cell0_COMMA, - 'r ) - _menhir_cell1_DOTDOT, - 'r ) - _menhir_state - | MenhirState1052 - : ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1057 - : ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState1059 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState1060 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState1062 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState1065 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState1067 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState1070 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState1073 - : ( ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1075 - : ( ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1078 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1080 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1083 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1085 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1088 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1090 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1094 - : ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState1095 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState1097 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState1100 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState1102 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState1105 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState1108 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1110 - : ( ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1113 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1115 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1118 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1120 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1123 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1125 - : ( ( ( ( ('s, 'r) _menhir_cell1_LOOP, - 'r ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1131 - : ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1134 - : ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState1135 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState1137 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState1140 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState1142 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState1145 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState1148 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1150 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1153 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1155 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1158 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1160 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1163 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1165 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1171 - : ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState1173 - : ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_state - | MenhirState1174 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RETURN, - 'r ) - _menhir_state - | MenhirState1176 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_RAISE, - 'r ) - _menhir_state - | MenhirState1179 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_CONTINUE, - 'r ) - _menhir_state - | MenhirState1181 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_BREAK, - 'r ) - _menhir_state - | MenhirState1184 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_state - | MenhirState1187 - : ( ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1189 - : ( ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - 'r ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1192 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1194 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1197 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1199 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1202 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL, - 'r ) - _menhir_state - | MenhirState1204 - : ( ( ( ( (('s, 'r) _menhir_cell1_MATCH, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - 'r ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT, - 'r ) - _menhir_state - | MenhirState1208 - : ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1212 - : ( ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1216 - : ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr _menhir_cell0_CATCH - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1220 - : ( ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1224 - : ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr _menhir_cell0_CATCH - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1228 - : ( ( (('s, 'r) _menhir_cell1_TRY, 'r) _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1233 - : ( ( ('s, 'r) _menhir_cell1_LPAREN, - 'r ) - _menhir_cell1_non_empty_list_commas_rev_expr_ - _menhir_cell0_COMMA, - 'r ) - _menhir_state - | MenhirState1237 - : ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_expr - _menhir_cell0_COLON, - 'r ) - _menhir_state - | MenhirState1238 - : ( ( (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_expr - _menhir_cell0_COLON, - 'r ) - _menhir_cell1_type_, - 'r ) - _menhir_state - | MenhirState1242 - : ( (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_state - | MenhirState1243 - : ( ( (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState1246 - : ( ( (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_state - | MenhirState1247 - : ( ( ( (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - 'r ) - _menhir_cell1_RBRACE, - 'r ) - _menhir_state - | MenhirState1249 - : ( ( (('s, 'r) _menhir_cell1_WHILE, 'r) _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - 'r ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE, - 'r ) - _menhir_state - | MenhirState1254 : ('s, _menhir_box_structure) _menhir_state - | MenhirState1255 - : ( ('s, _menhir_box_structure) _menhir_cell1_TYPEALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1256 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPEALIAS, - _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0816 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, _menhir_box_structure ) - _menhir_state - | MenhirState1257 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0817 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_LPAREN, _menhir_box_structure ) - _menhir_state - | MenhirState1260 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET, + _menhir_cell1_non_empty_list_commas_rev_constructor_param_, + _menhir_box_structure ) + _menhir_state + | MenhirState0818 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_LPAREN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__ - _menhir_cell0_COMMA, + _menhir_cell1_non_empty_list_commas_rev_constructor_param_, _menhir_box_structure ) - _menhir_state - | MenhirState1268 - : ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_cell1_COMMA, + _menhir_box_structure ) + _menhir_state + | MenhirState0830 : + ( ( 's, _menhir_box_structure ) - _menhir_state - | MenhirState1269 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_, + _menhir_box_structure ) + _menhir_state + | MenhirState0831 : + ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_, _menhir_box_structure ) - _menhir_state - | MenhirState1271 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_cell1_SEMI, + _menhir_box_structure ) + _menhir_state + | MenhirState0835 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_luident + _menhir_cell0_LBRACE, _menhir_box_structure ) - _menhir_state - | MenhirState1273 - : ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0841 : + ( ('s, _menhir_box_structure) _menhir_cell1_local_type_decl + _menhir_cell0_SEMI, + _menhir_box_structure ) + _menhir_state + | MenhirState0845 : + ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState0846 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, _menhir_box_structure ) - _menhir_state - | MenhirState1274 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0848 : + ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_state + | MenhirState0850 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1275 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0851 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_COLON, - _menhir_box_structure ) - _menhir_state - | MenhirState1278 - : ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_QUESTION - _menhir_cell0_PLUS, + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1281 - : ( ('s, _menhir_box_structure) _menhir_cell1_qual_ident_ty - _menhir_cell0_PLUS, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0853 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1285 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0854 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1287 - : ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_state - | MenhirState1288 - : ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1290 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState0856 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__ - _menhir_cell0_COMMA, + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1292 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__ - _menhir_cell0_COMMA, - _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_COLON, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0858 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1297 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0860 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_COLON, + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1299 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState0862 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1302 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState0863 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_state - | MenhirState1303 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0865 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1304 - : ( ('s, _menhir_box_structure) _menhir_cell1_THIN_ARROW, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1308 - : ( ('s, _menhir_box_structure) _menhir_cell1_POST_LABEL - _menhir_cell0_COLON, + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0868 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1309 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_POST_LABEL - _menhir_cell0_COLON, + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState0869 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, _menhir_box_structure ) - _menhir_state - | MenhirState1311 - : ( ('s, _menhir_box_structure) _menhir_cell1_LABEL _menhir_cell0_COLON, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0873 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1312 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LABEL _menhir_cell0_COLON, + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0874 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1313 - : ( ('s, _menhir_box_structure) _menhir_cell1_type_, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0875 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1316 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState0876 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_trait_method_param_ - _menhir_cell0_COMMA, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_state - | MenhirState1319 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0879 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_trait_method_param_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1323 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1324 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState0880 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1327 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0881 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_trait_method_param_ - _menhir_cell0_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1333 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_luident, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0882 : + ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1337 - : ( ('s, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, - _menhir_box_structure ) - _menhir_state - | MenhirState1338 - : ( ('s, _menhir_box_structure) _menhir_cell1_LPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1343 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1344 - : ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, - _menhir_box_structure ) - _menhir_state - | MenhirState1346 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, - _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1348 - : ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_state - | MenhirState1354 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_THIN_ARROW, + _menhir_box_structure ) + _menhir_state + | MenhirState0884 : + ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_pub_attr, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1358 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState0889 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_pub_attr, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1359 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState0890 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_pub_attr, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState1360 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, - _menhir_box_structure ) - _menhir_state - | MenhirState1363 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1364 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0892 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1368 - : ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_state - | MenhirState1369 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState0893 : + ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1373 - : ( ( 's _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0894 : + ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1376 - : ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0895 : + ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1378 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_cell1_THIN_ARROW, + _menhir_box_structure ) + _menhir_state + | MenhirState0897 : + ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_LBRACE, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1380 - : ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_LPAREN, + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState0899 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1381 - : ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState0904 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1383 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState0905 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_POST_LABEL - _menhir_cell0_COLON, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1384 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0906 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_POST_LABEL - _menhir_cell0_COLON, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1386 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0907 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_LABEL - _menhir_cell0_COLON, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1387 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState0908 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_LABEL - _menhir_cell0_COLON, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_cell1_THIN_ARROW, + _menhir_box_structure ) + _menhir_state + | MenhirState0912 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1388 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0913 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1390 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_UIDENT _menhir_cell0_LPAREN, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0914 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_constructor_param_ - _menhir_cell0_COMMA, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState0917 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1400 - : ( ( 's, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState0918 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1403 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState0919 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1406 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0920 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1410 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0921 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1414 - : ( ( 's _menhir_cell0_LBRACE, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState0922 : + ( ( ( ( ( ( 's _menhir_cell0_STRING _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_local_type_decl_ - _menhir_cell0_SEMI, + _menhir_cell1_option_parameters_, _menhir_box_structure ) - _menhir_state - | MenhirState1417 - : ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_cell1_THIN_ARROW, + _menhir_box_structure ) + _menhir_state + | MenhirState0925 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1418 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState0926 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, _menhir_box_structure ) - _menhir_state - | MenhirState1420 - : ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0930 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1423 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0931 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_LET - _menhir_cell0_LIDENT + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1424 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_LET - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0933 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_state - | MenhirState1425 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState0934 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1426 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState0935 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1430 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0936 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1432 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0937 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1434 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState0940 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0941 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPEALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1436 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0943 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0944 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState0946 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0948 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState0950 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState0952 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState0953 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0955 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1439 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState0958 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState0959 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0963 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState0964 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0965 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState0966 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0969 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1443 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState0970 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1446 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0971 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1448 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0972 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1451 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState0974 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1455 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState0975 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1460 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState0977 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1462 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState0978 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1464 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0979 : + ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1467 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0980 : + ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1471 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState0982 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState0983 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState0984 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1474 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0985 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1476 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0986 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1479 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState0989 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState0990 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState0991 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1483 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState0994 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState0995 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState0996 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1487 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState0997 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1489 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState0998 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1491 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1000 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState1001 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1005 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1006 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1008 : + ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1009 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1010 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1493 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1011 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1496 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1012 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1016 : + ( ('s, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1017 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1018 : + ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState1019 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1022 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1500 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1023 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1503 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1024 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1505 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1025 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1508 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState1027 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1512 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState1028 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1517 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1030 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1519 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1031 : + ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1521 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1032 : + ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1524 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1033 : + ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1528 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState1035 : + ( ('s, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1036 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1037 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1038 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1531 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1039 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1533 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1042 : + ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1043 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1044 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1536 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState1047 : + ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1048 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1049 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1540 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1050 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1543 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1051 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1544 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1053 : + ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState1054 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1058 : + ( ('s, _menhir_box_structure) _menhir_cell1_CONST _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1059 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_CONST _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1062 : + ( ('s, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1063 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1064 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1065 : + ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1547 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1066 : + ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1549 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1069 : + ( ('s, _menhir_box_structure) _menhir_cell1_val_header _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1071 : + ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1072 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1074 : + ( ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1076 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1077 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_option_type__, + _menhir_box_structure ) + _menhir_state + | MenhirState1079 : + ( ('s, _menhir_box_structure) _menhir_cell1_type_header, + _menhir_box_structure ) + _menhir_state + | MenhirState1080 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1084 : + ( ('s, _menhir_box_structure) _menhir_cell1_type_alias_header + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1085 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_type_alias_header + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1090 : + ( ('s, _menhir_box_structure) _menhir_cell1_struct_header + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1092 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_struct_header + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_record_decl_field_ + _menhir_cell0_RBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1096 : + ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_, + _menhir_box_structure ) + _menhir_state + | MenhirState1097 : + ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_, + _menhir_box_structure ) + _menhir_cell1_SEMI, + _menhir_box_structure ) + _menhir_state + | MenhirState1102 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1103 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1105 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1106 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState1108 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1110 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1112 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1114 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState1115 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1117 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1551 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1120 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST, + _menhir_box_structure ) + _menhir_state + | MenhirState1121 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_, + _menhir_box_structure ) + _menhir_state + | MenhirState1122 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_option_loced_string_, _menhir_box_structure ) - _menhir_state - | MenhirState1553 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1124 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState1125 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1127 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_state + | MenhirState1129 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1130 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1556 - : ( ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1132 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1133 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1560 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState1135 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1563 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1137 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1139 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, _menhir_box_structure ) - _menhir_state - | MenhirState1565 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1141 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState1142 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_state - | MenhirState1568 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1144 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1572 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1147 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState1148 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, _menhir_box_structure ) - _menhir_state - | MenhirState1577 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1152 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1153 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1579 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1154 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState1155 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_state - | MenhirState1581 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1158 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1584 - : ( ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1159 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1588 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1160 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1591 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1161 : + ( ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1593 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState1163 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1596 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState1164 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1600 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1166 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1604 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1167 : + ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty + _menhir_cell1_type_name _menhir_cell0_FOR, _menhir_box_structure ) _menhir_cell1_type_, _menhir_box_structure ) _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1606 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1168 : + ( ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty + _menhir_cell1_type_name _menhir_cell0_FOR, _menhir_box_structure ) _menhir_cell1_type_, _menhir_box_structure ) _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1608 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1169 : + ( ( ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty + _menhir_cell1_type_name _menhir_cell0_FOR, _menhir_box_structure ) _menhir_cell1_type_, _menhir_box_structure ) _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1610 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState1171 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1172 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1613 - : ( ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1173 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1617 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1174 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1620 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1175 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_pub_attr + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1622 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1178 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1179 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1625 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1180 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1629 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState1183 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1184 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1634 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1185 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1636 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1186 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1638 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1187 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1641 - : ( ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1189 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState1190 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, _menhir_box_structure ) - _menhir_state - | MenhirState1645 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1194 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1195 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1648 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1197 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1198 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1650 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1199 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1653 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1200 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1657 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1201 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1204 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1205 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1207 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1208 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION, + _menhir_box_structure ) + _menhir_state + | MenhirState1210 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1660 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1212 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_state + | MenhirState1214 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1216 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_state + | MenhirState1217 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1219 : + ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1222 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_state + | MenhirState1223 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1227 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1228 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1229 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState1230 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_state - | MenhirState1665 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1233 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1666 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1234 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1667 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1235 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1668 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1236 : + ( ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1669 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_THIN_ARROW, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1672 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState1238 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1673 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState1239 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1677 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1678 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1241 : + ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1679 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1242 : + ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1680 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1243 : + ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1681 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1244 : + ( ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_fun_binder, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_option_parameters_, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState1246 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1247 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1682 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1248 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_option_parameters_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_THIN_ARROW, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1685 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1249 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV _menhir_cell0_FN, _menhir_box_structure ) _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1686 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1250 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV _menhir_cell0_FN, _menhir_box_structure ) _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1690 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_CONST - _menhir_cell0_UIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_state - | MenhirState1691 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_CONST - _menhir_cell0_UIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState1693 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPEALIAS, - _menhir_box_structure ) - _menhir_state - | MenhirState1694 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPEALIAS, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1696 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1253 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1254 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1697 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_state - | MenhirState1699 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1255 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_pub_attr + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN _menhir_cell0_TYPE, _menhir_box_structure ) _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1701 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT, + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState1258 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1259 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1702 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1260 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1704 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1261 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1708 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_STRUCT, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1709 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1262 : + ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_STRUCT, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_luident, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1711 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1264 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState1265 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV _menhir_cell0_ENUM, _menhir_box_structure ) - _menhir_state - | MenhirState1712 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1715 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPEALIAS, - _menhir_box_structure ) - _menhir_state - | MenhirState1716 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_TYPEALIAS, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1718 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_state - | MenhirState1719 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_state - | MenhirState1721 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1723 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_state - | MenhirState1724 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1726 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1730 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_STRUCT, - _menhir_box_structure ) - _menhir_state - | MenhirState1731 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_STRUCT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1733 - : ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, - _menhir_box_structure ) - _menhir_state - | MenhirState1734 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState1738 - : ( ('s, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1269 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1270 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_CONST + _menhir_cell0_UIDENT _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1739 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState1740 - : ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_state - | MenhirState1741 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1272 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1273 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1745 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1274 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1747 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1275 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1749 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1276 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1751 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1280 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1281 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1754 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1282 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_state + | MenhirState1283 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1286 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1758 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1287 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1761 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1288 : + ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1763 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1289 : + ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1766 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_option___anonymous_4_, + _menhir_box_structure ) + _menhir_state + | MenhirState1291 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1770 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_state + | MenhirState1292 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_state - | MenhirState1775 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1294 : + ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_state - | MenhirState1777 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_state + | MenhirState1295 : + ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_state - | MenhirState1779 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1296 : + ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1782 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1297 : + ( ( ( ( ( ( ( ( ( 's, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_WITH + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1786 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_option___anonymous_3_, + _menhir_box_structure ) + _menhir_state + | MenhirState1299 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1300 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1789 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1301 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1791 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1302 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1794 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1303 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1798 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1306 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_state + | MenhirState1307 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_state - | MenhirState1802 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1308 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_luident, _menhir_box_structure ) - _menhir_state - | MenhirState1804 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters_no_constraints, + _menhir_box_structure ) + _menhir_state + | MenhirState1311 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1312 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1313 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1806 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1314 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1808 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1315 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1811 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1815 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1818 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1820 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1823 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1827 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1832 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1834 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1836 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1839 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1843 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1846 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1848 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1851 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1855 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1858 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_state - | MenhirState1859 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState1862 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1864 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1866 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1868 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1871 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1875 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1878 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1880 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1883 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1887 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1892 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1894 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1896 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1899 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1903 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1906 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1908 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1911 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1915 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1919 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1921 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState1923 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1925 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1928 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1317 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_state + | MenhirState1318 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ENUM, _menhir_box_structure ) - _menhir_state - | MenhirState1932 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_state + | MenhirState1322 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, + _menhir_box_structure ) + _menhir_state + | MenhirState1323 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON, _menhir_box_structure ) - _menhir_state - | MenhirState1935 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_state + | MenhirState1325 : + ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_state + | MenhirState1326 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_state - | MenhirState1937 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_state + | MenhirState1327 : + ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_state - | MenhirState1940 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_state + | MenhirState1328 : + ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_state - | MenhirState1944 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_state + | MenhirState1329 : + ( ( ( ( ( ( 's, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_state - | MenhirState1949 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_state + | MenhirState1331 : + ( ('s, _menhir_box_structure) _menhir_cell1_fun_header, + _menhir_box_structure ) + _menhir_state + | MenhirState1332 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_fun_header, _menhir_box_structure ) - _menhir_state - | MenhirState1951 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type + _menhir_cell1_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1341 : + ( ('s, _menhir_box_structure) _menhir_cell1_extern_fun_header + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_state + | MenhirState1345 : + ( ('s, _menhir_box_structure) _menhir_cell1_enum_header + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_state + | MenhirState1347 : + ( ( ('s, _menhir_box_structure) _menhir_cell1_enum_header _menhir_cell0_LBRACE, _menhir_box_structure ) - _menhir_state - | MenhirState1953 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1956 - : ( ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1960 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1963 - : ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState1965 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState1968 - : ( ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1972 - : ( ( ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState1975 - : ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_state - | MenhirState1976 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_state - | MenhirState1977 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_state - | MenhirState1978 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_state - | MenhirState1979 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1981 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_state - | MenhirState1982 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1986 - : ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_state - | MenhirState1987 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_state - | MenhirState1988 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_state - | MenhirState1989 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_state - | MenhirState1990 - : ( ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1992 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_state - | MenhirState1993 - : ( ( ( ( ('s, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_state - | MenhirState1996 - : ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, - _menhir_box_structure ) - _menhir_state - | MenhirState1997 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_state - | MenhirState2001 - : ( ('s, _menhir_box_structure) _menhir_cell1_CONST _menhir_cell0_UIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_state - | MenhirState2002 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_CONST _menhir_cell0_UIDENT - _menhir_cell0_COLON, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState2004 - : ( ('s, _menhir_box_structure) _menhir_cell1_val_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_state - | MenhirState2006 - : ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_state - | MenhirState2007 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2008 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2010 - : ( ('s, _menhir_box_structure) _menhir_cell1_DERIVE _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState2013 - : ( ('s, _menhir_box_structure) _menhir_cell1_qual_ident_ty - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_state - | MenhirState2018 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_DERIVE _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_deriving_directive_ - _menhir_cell0_COMMA, - _menhir_box_structure ) - _menhir_state - | MenhirState2025 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_enum_constructor_ - _menhir_cell0_RBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2027 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState2028 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_option_type__, - _menhir_box_structure ) - _menhir_state - | MenhirState2030 - : ( ('s, _menhir_box_structure) _menhir_cell1_type_header, - _menhir_box_structure ) - _menhir_state - | MenhirState2031 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_type_header, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState2035 - : ( ('s, _menhir_box_structure) _menhir_cell1_type_alias_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_state - | MenhirState2036 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_type_alias_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_state - | MenhirState2041 - : ( ('s, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2042 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2045 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_record_decl_field_ - _menhir_cell0_RBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2050 - : ( ( 's, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState2053 - : ( ('s, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2055 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_state - | MenhirState2058 - : ( ( ( ('s, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState2062 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - _menhir_box_structure ) - _menhir_state - | MenhirState2065 - : ( ('s, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_state - | MenhirState2073 - : ( ('s, _menhir_box_structure) _menhir_cell1_extern_fun_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_state - | MenhirState2077 - : ( ('s, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2078 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE, - _menhir_box_structure ) - _menhir_state - | MenhirState2081 - : ( ( ('s, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_enum_constructor_ - _menhir_cell0_RBRACE, - _menhir_box_structure ) - _menhir_state + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE, + _menhir_box_structure ) + _menhir_state + +and ('s, 'r) _menhir_cell1_array_sub_pattern = + | MenhirCell1_array_sub_pattern of + 's * ('s, 'r) _menhir_state * Parsing_syntax.array_pattern + +and ('s, 'r) _menhir_cell1_block_expr = + | MenhirCell1_block_expr of + 's * ('s, 'r) _menhir_state * Parsing_syntax.expr * Lexing.position + +and 's _menhir_cell0_catch_keyword = + | MenhirCell0_catch_keyword of 's * (bool * Rloc.t) + +and ('s, 'r) _menhir_cell1_constr = + | MenhirCell1_constr of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.constructor + * Lexing.position + * Lexing.position and ('s, 'r) _menhir_cell1_constr_pat_argument = | MenhirCell1_constr_pat_argument of @@ -8019,7 +5019,8 @@ and ('s, 'r) _menhir_cell1_enum_header = | MenhirCell1_enum_header of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.visibility + * (Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) @@ -8040,11 +5041,19 @@ and ('s, 'r) _menhir_cell1_extern_fun_header = * (Parsing_syntax.string_literal * Parsing_syntax.fun_decl) * Lexing.position -and ('s, 'r) _menhir_cell1_fn_label = - | MenhirCell1_fn_label of +and ('s, 'r) _menhir_cell1_fn_header = + | MenhirCell1_fn_header of + 's + * ('s, 'r) _menhir_state + * (Parsing_syntax.binder * Rloc.t option) + * Lexing.position + * Lexing.position + +and ('s, 'r) _menhir_cell1_fn_header_no_binder = + | MenhirCell1_fn_header_no_binder of 's * ('s, 'r) _menhir_state - * Parsing_syntax.label + * Rloc.t option * Lexing.position * Lexing.position @@ -8072,55 +5081,101 @@ and ('s, 'r) _menhir_cell1_infix_expr = * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_left_value = + | MenhirCell1_left_value of + 's + * ('s, 'r) _menhir_state + * [ `Array_access of Parsing_syntax.expr * Parsing_syntax.expr + | `Field_access of Parsing_syntax.expr * Parsing_syntax.accessor + | `Var of Parsing_syntax.var ] + * Lexing.position + +and ('s, 'r) _menhir_cell1_list_commas_trait_method_param_ = + | MenhirCell1_list_commas_trait_method_param_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.trait_method_param list + +and 's _menhir_cell0_list_commas_no_trailing___anonymous_11_ = + | MenhirCell0_list_commas_no_trailing___anonymous_11_ of + 's * (Parsing_syntax.binder * Parsing_syntax.expr) list + +and ('s, 'r) _menhir_cell1_list_semis_enum_constructor_ = + | MenhirCell1_list_semis_enum_constructor_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.constr_decl list + +and ('s, 'r) _menhir_cell1_list_semis_record_decl_field_ = + | MenhirCell1_list_semis_record_decl_field_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.field_decl list + +and ('s, 'r) _menhir_cell1_local_type_decl = + | MenhirCell1_local_type_decl of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.local_type_decl + * Lexing.position + * Lexing.position + +and ('s, 'r) _menhir_cell1_loop_label_colon = + | MenhirCell1_loop_label_colon of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.label option + * Lexing.position + * Lexing.position + and ('s, 'r) _menhir_cell1_luident = | MenhirCell1_luident of 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_map_syntax_key = + | MenhirCell1_map_syntax_key of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.constant + * Lexing.position + * Lexing.position + +and ('s, 'r) _menhir_cell1_non_empty_list___anonymous_5_ = + | MenhirCell1_non_empty_list___anonymous_5_ of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.attribute list + * Lexing.position + * Lexing.position + and ('s, 'r) _menhir_cell1_non_empty_list_commas_foreach_binder_ = | MenhirCell1_non_empty_list_commas_foreach_binder_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.binder option list -and ('s, 'r) _menhir_cell1_non_empty_list_commas_parameter_ = - | MenhirCell1_non_empty_list_commas_parameter_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.parameters - and ('s, 'r) _menhir_cell1_non_empty_list_commas_pattern_ = | MenhirCell1_non_empty_list_commas_pattern_ of - 's - * ('s, 'r) _menhir_state - * Parsing_syntax.pattern list - * Lexing.position - -and ('s, 'r) _menhir_cell1_non_empty_list_commas_trait_method_param_ = - | MenhirCell1_non_empty_list_commas_trait_method_param_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.trait_method_param list + 's * ('s, 'r) _menhir_state * Parsing_syntax.pattern list and ('s, 'r) _menhir_cell1_non_empty_list_commas_type__ = | MenhirCell1_non_empty_list_commas_type__ of 's * ('s, 'r) _menhir_state * Parsing_syntax.typ list -and 's _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ = - | MenhirCell0_non_empty_list_commas_no_trailing___anonymous_12_ of - 's * (Parsing_syntax.binder * Parsing_syntax.expr) list - and ('s, 'r) _menhir_cell1_non_empty_list_commas_no_trailing_expr_ = | MenhirCell1_non_empty_list_commas_no_trailing_expr_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.expr list * Lexing.position -and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev___anonymous_11_ = - | MenhirCell1_non_empty_list_commas_rev___anonymous_11_ of +and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev___anonymous_10_ = + | MenhirCell1_non_empty_list_commas_rev___anonymous_10_ of 's * ('s, 'r) _menhir_state * (Parsing_syntax.binder * Parsing_syntax.expr) list -and 's _menhir_cell0_non_empty_list_commas_rev___anonymous_12_ = - | MenhirCell0_non_empty_list_commas_rev___anonymous_12_ of +and 's _menhir_cell0_non_empty_list_commas_rev___anonymous_11_ = + | MenhirCell0_non_empty_list_commas_rev___anonymous_11_ of 's * (Parsing_syntax.binder * Parsing_syntax.expr) list and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_argument_ = | MenhirCell1_non_empty_list_commas_rev_argument_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.argument list +and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_array_sub_pattern_ = + | MenhirCell1_non_empty_list_commas_rev_array_sub_pattern_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.array_pattern list + and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_constructor_param_ = | MenhirCell1_non_empty_list_commas_rev_constructor_param_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.constr_param list @@ -8163,10 +5218,7 @@ and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_parameter_ = and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_pattern_ = | MenhirCell1_non_empty_list_commas_rev_pattern_ of - 's - * ('s, 'r) _menhir_state - * Parsing_syntax.pattern list - * Lexing.position + 's * ('s, 'r) _menhir_state * Parsing_syntax.pattern list and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ = | MenhirCell1_non_empty_list_commas_rev_record_defn_single_ of @@ -8184,66 +5236,44 @@ and ('s, 'r) _menhir_cell1_non_empty_list_commas_rev_type__ = | MenhirCell1_non_empty_list_commas_rev_type__ of 's * ('s, 'r) _menhir_state * Parsing_syntax.typ list -and ('s, 'r) _menhir_cell1_non_empty_list_commas_with_tail_pattern_ = - | MenhirCell1_non_empty_list_commas_with_tail_pattern_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.pattern list - -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ = - | MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern list * Parsing_syntax.expr) list +and ('s, 'r) _menhir_cell1_non_empty_list_commas_with_tail_fields_pat_single_ = + | MenhirCell1_non_empty_list_commas_with_tail_fields_pat_single_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.field_pat list -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ = - | MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern list * Parsing_syntax.expr) list - * Lexing.position - * Lexing.position +and ('s, 'r) _menhir_cell1_non_empty_list_commas_with_tail_map_elem_pat_ = + | MenhirCell1_non_empty_list_commas_with_tail_map_elem_pat_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.map_pat_elem list -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ = - | MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ of +and ('s, 'r) _menhir_cell1_non_empty_list_rev_multiline_string_ = + | MenhirCell1_non_empty_list_rev_multiline_string_ of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern list * Parsing_syntax.expr) list + * Parsing_syntax.multiline_string_elem list * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ = - | MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern * Parsing_syntax.expr) list - -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ = - | MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern * Parsing_syntax.expr) list - and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_ = | MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.constr_decl list -and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_local_type_decl_ = - | MenhirCell1_non_empty_list_semi_rev_aux_local_type_decl_ of - 's - * ('s, 'r) _menhir_state - * Parsing_syntax.local_type_decl list - * Lexing.position +and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_multi_pattern_case_ = + | MenhirCell1_non_empty_list_semi_rev_aux_multi_pattern_case_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.multi_arg_case list and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_ = | MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.field_decl list +and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_single_pattern_case_ = + | MenhirCell1_non_empty_list_semi_rev_aux_single_pattern_case_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.case list + and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_statement_ = | MenhirCell1_non_empty_list_semi_rev_aux_statement_ of 's * ('s, 'r) _menhir_state * Parsing_compact.semi_expr_prop list * Lexing.position - * Lexing.position and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_ = | MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ of @@ -8253,21 +5283,6 @@ and ('s, 'r) _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_ = | MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.trait_method_decl list -and ('s, 'r) _menhir_cell1_non_empty_list_semis_enum_constructor_ = - | MenhirCell1_non_empty_list_semis_enum_constructor_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.constr_decl list - -and ('s, 'r) _menhir_cell1_non_empty_list_semis_local_type_decl_ = - | MenhirCell1_non_empty_list_semis_local_type_decl_ of - 's - * ('s, 'r) _menhir_state - * Parsing_syntax.local_type_decl list - * Lexing.position - -and ('s, 'r) _menhir_cell1_non_empty_list_semis_record_decl_field_ = - | MenhirCell1_non_empty_list_semis_record_decl_field_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.field_decl list - and ('s, 'r) _menhir_cell1_option_MUTABLE_ = | MenhirCell1_option_MUTABLE_ of 's @@ -8276,32 +5291,60 @@ and ('s, 'r) _menhir_cell1_option_MUTABLE_ = * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_option___anonymous_15_ = - | MenhirCell1_option___anonymous_15_ of +and ('s, 'r) _menhir_cell1_option_QUESTION_ = + | MenhirCell1_option_QUESTION_ of 's * ('s, 'r) _menhir_state * unit option + +and ('s, 'r) _menhir_cell1_option___anonymous_14_ = + | MenhirCell1_option___anonymous_14_ of 's * ('s, 'r) _menhir_state * (Parsing_syntax.typ * Parsing_syntax.error_typ) option -and ('s, 'r) _menhir_cell1_option___anonymous_18_ = - | MenhirCell1_option___anonymous_18_ of - 's * ('s, 'r) _menhir_state * Parsing_syntax.binder option +and 's _menhir_cell0_option___anonymous_16_ = + | MenhirCell0_option___anonymous_16_ of + 's * Parsing_syntax.constr_param list option and ('s, 'r) _menhir_cell1_option___anonymous_2_ = | MenhirCell1_option___anonymous_2_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.tvar_constraint list option -and ('s, 'r) _menhir_cell1_option___anonymous_6_ = - | MenhirCell1_option___anonymous_6_ of +and ('s, 'r) _menhir_cell1_option___anonymous_3_ = + | MenhirCell1_option___anonymous_3_ of + 's + * ('s, 'r) _menhir_state + * (Parsing_syntax.typ * Parsing_syntax.error_typ) option + * Lexing.position + +and ('s, 'r) _menhir_cell1_option___anonymous_4_ = + | MenhirCell1_option___anonymous_4_ of + 's + * ('s, 'r) _menhir_state + * (Parsing_syntax.typ * Parsing_syntax.error_typ) option + * Lexing.position + +and ('s, 'r) _menhir_cell1_option___anonymous_7_ = + | MenhirCell1_option___anonymous_7_ of 's * ('s, 'r) _menhir_state * (Parsing_syntax.typ * Parsing_syntax.error_typ) option +and 's _menhir_cell0_option___anonymous_8_ = + | MenhirCell0_option___anonymous_8_ of 's * Parsing_syntax.expr option + +and 's _menhir_cell0_option___anonymous_9_ = + | MenhirCell0_option___anonymous_9_ of 's * Parsing_syntax.expr option + +and ('s, 'r) _menhir_cell1_option_expr_ = + | MenhirCell1_option_expr_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.expr option * Lexing.position + and ('s, 'r) _menhir_cell1_option_infix_expr_ = | MenhirCell1_option_infix_expr_ of 's * ('s, 'r) _menhir_state * Parsing_syntax.expr option -and 's _menhir_cell0_option_loced_string_ = - | MenhirCell0_option_loced_string_ of 's * Parsing_syntax.test_name +and ('s, 'r) _menhir_cell1_option_loced_string_ = + | MenhirCell1_option_loced_string_ of + 's * ('s, 'r) _menhir_state * Parsing_syntax.test_name and ('s, 'r) _menhir_cell1_option_parameters_ = | MenhirCell1_option_parameters_ of @@ -8315,10 +5358,31 @@ and ('s, 'r) _menhir_cell1_option_type__ = | MenhirCell1_option_type__ of 's * ('s, 'r) _menhir_state * Parsing_syntax.typ option +and ('s, 'r) _menhir_cell1_optional_bang = + | MenhirCell1_optional_bang of 's * ('s, 'r) _menhir_state * Rloc.t option + +and 's _menhir_cell0_optional_question = + | MenhirCell0_optional_question of 's * Rloc.t option + and ('s, 'r) _menhir_cell1_optional_type_parameters = | MenhirCell1_optional_type_parameters of 's * ('s, 'r) _menhir_state * Parsing_syntax.tvar_binder list +and ('s, 'r) _menhir_cell1_optional_type_parameters_no_constraints = + | MenhirCell1_optional_type_parameters_no_constraints of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.type_decl_binder list + * Lexing.position + +and ('s, 'r) _menhir_cell1_parameters = + | MenhirCell1_parameters of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.parameters + * Lexing.position + * Lexing.position + and ('s, 'r) _menhir_cell1_pattern = | MenhirCell1_pattern of 's @@ -8347,19 +5411,19 @@ and ('s, 'r) _menhir_cell1_pub_attr = | MenhirCell1_pub_attr of 's * ('s, 'r) _menhir_state * string option * Lexing.position -and ('s, 'r) _menhir_cell1_qual_ident = - | MenhirCell1_qual_ident of +and ('s, 'r) _menhir_cell1_qual_ident_ty = + | MenhirCell1_qual_ident_ty of 's * ('s, 'r) _menhir_state * Parsing_syntax.longident * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_qual_ident_ty = - | MenhirCell1_qual_ident_ty of +and ('s, 'r) _menhir_cell1_range_expr = + | MenhirCell1_range_expr of 's * ('s, 'r) _menhir_state - * Parsing_syntax.longident + * Parsing_syntax.expr * Lexing.position * Lexing.position @@ -8371,13 +5435,6 @@ and ('s, 'r) _menhir_cell1_range_pattern = * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_return_type = - | MenhirCell1_return_type of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.typ * Parsing_syntax.error_typ) - * Lexing.position - and ('s, 'r) _menhir_cell1_simple_expr = | MenhirCell1_simple_expr of 's @@ -8396,20 +5453,23 @@ and ('s, 'r) _menhir_cell1_simple_pattern = and ('s, 'r) _menhir_cell1_single_pattern_cases = | MenhirCell1_single_pattern_cases of - 's - * ('s, 'r) _menhir_state - * (Parsing_syntax.pattern * Parsing_syntax.expr) list + 's * ('s, 'r) _menhir_state * Parsing_syntax.case list and ('s, 'r) _menhir_cell1_struct_header = | MenhirCell1_struct_header of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.visibility + * (Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) * Lexing.position +and ('s, 'r) _menhir_cell1_tvar_constraint = + | MenhirCell1_tvar_constraint of + 's * ('s, 'r) _menhir_state * Parsing_syntax.tvar_constraint + and ('s, 'r) _menhir_cell1_type_ = | MenhirCell1_type_ of 's @@ -8422,7 +5482,8 @@ and ('s, 'r) _menhir_cell1_type_alias_header = | MenhirCell1_type_alias_header of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.visibility + * (Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) @@ -8432,86 +5493,81 @@ and ('s, 'r) _menhir_cell1_type_header = | MenhirCell1_type_header of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.visibility + * (Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) * Lexing.position + * Lexing.position and ('s, 'r) _menhir_cell1_type_header_bang = | MenhirCell1_type_header_bang of 's * ('s, 'r) _menhir_state - * (Parsing_syntax.visibility * string * Rloc.t) + * (Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) + * Lexing.position + * Lexing.position + +and ('s, 'r) _menhir_cell1_type_name = + | MenhirCell1_type_name of + 's + * ('s, 'r) _menhir_state + * Parsing_syntax.type_name + * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_val_header = | MenhirCell1_val_header of 's * ('s, 'r) _menhir_state - * (bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) + * (Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) * Lexing.position -and 's _menhir_cell0_AMPER = - | MenhirCell0_AMPER of 's * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_AMPER = + | MenhirCell1_AMPER of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position + +and ('s, 'r) _menhir_cell1_AMPERAMPER = + | MenhirCell1_AMPERAMPER of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position + +and ('s, 'r) _menhir_cell1_ASYNC = + | MenhirCell1_ASYNC of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position -and 's _menhir_cell0_AMPERAMPER = - | MenhirCell0_AMPERAMPER of 's * Lexing.position * Lexing.position +and 's _menhir_cell0_ASYNC = + | MenhirCell0_ASYNC of 's * Lexing.position * Lexing.position and 's _menhir_cell0_AUGMENTED_ASSIGNMENT = | MenhirCell0_AUGMENTED_ASSIGNMENT of 's * string * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_BAR = + | MenhirCell1_BAR of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position + and 's _menhir_cell0_BAR = | MenhirCell0_BAR of 's * Lexing.position * Lexing.position -and 's _menhir_cell0_BARBAR = - | MenhirCell0_BARBAR of 's * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_BARBAR = + | MenhirCell1_BARBAR of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_BREAK = | MenhirCell1_BREAK of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_BYTE = - | MenhirCell1_BYTE of - 's - * ('s, 'r) _menhir_state - * Lex_literal.byte_literal - * Lexing.position - * Lexing.position - -and 's _menhir_cell0_BYTE = - | MenhirCell0_BYTE of - 's * Lex_literal.byte_literal * Lexing.position * Lexing.position - -and ('s, 'r) _menhir_cell1_BYTES = - | MenhirCell1_BYTES of - 's - * ('s, 'r) _menhir_state - * Lex_literal.bytes_literal - * Lexing.position - * Lexing.position - -and 's _menhir_cell0_BYTES = - | MenhirCell0_BYTES of - 's * Lex_literal.bytes_literal * Lexing.position * Lexing.position - -and 's _menhir_cell0_CARET = - | MenhirCell0_CARET of 's * Lexing.position * Lexing.position - -and 's _menhir_cell0_CATCH = MenhirCell0_CATCH of 's * Lexing.position - -and ('s, 'r) _menhir_cell1_CHAR = - | MenhirCell1_CHAR of - 's - * ('s, 'r) _menhir_state - * Lex_literal.char_literal - * Lexing.position - * Lexing.position - -and 's _menhir_cell0_CHAR = - | MenhirCell0_CHAR of - 's * Lex_literal.char_literal * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_CARET = + | MenhirCell1_CARET of + 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_COLON = | MenhirCell1_COLON of 's * ('s, 'r) _menhir_state * Lexing.position @@ -8529,6 +5585,8 @@ and 's _menhir_cell0_COMMA = MenhirCell0_COMMA of 's * Lexing.position and ('s, 'r) _menhir_cell1_CONST = | MenhirCell1_CONST of 's * ('s, 'r) _menhir_state * Lexing.position +and 's _menhir_cell0_CONST = MenhirCell0_CONST of 's * Lexing.position + and ('s, 'r) _menhir_cell1_CONTINUE = | MenhirCell1_CONTINUE of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position @@ -8543,15 +5601,9 @@ and ('s, 'r) _menhir_cell1_DOTDOT = and 's _menhir_cell0_DOTDOT = | MenhirCell0_DOTDOT of 's * Lexing.position * Lexing.position -and 's _menhir_cell0_DOT_INT = - | MenhirCell0_DOT_INT of 's * int * Lexing.position * Lexing.position - and 's _menhir_cell0_DOT_LIDENT = | MenhirCell0_DOT_LIDENT of 's * string * Lexing.position * Lexing.position -and 's _menhir_cell0_DOT_UIDENT = - | MenhirCell0_DOT_UIDENT of 's * string * Lexing.position * Lexing.position - and ('s, 'r) _menhir_cell1_ELSE = | MenhirCell1_ELSE of 's * ('s, 'r) _menhir_state * Lexing.position @@ -8577,31 +5629,16 @@ and 's _menhir_cell0_EXCLAMATION = and ('s, 'r) _menhir_cell1_EXTERN = | MenhirCell1_EXTERN of 's * ('s, 'r) _menhir_state * Lexing.position -and ('s, 'r) _menhir_cell1_FALSE = - | MenhirCell1_FALSE of - 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position - -and 's _menhir_cell0_FALSE = - | MenhirCell0_FALSE of 's * Lexing.position * Lexing.position - +and 's _menhir_cell0_EXTERN = MenhirCell0_EXTERN of 's * Lexing.position and 's _menhir_cell0_FAT_ARROW = MenhirCell0_FAT_ARROW of 's * Lexing.position -and ('s, 'r) _menhir_cell1_FLOAT = - | MenhirCell1_FLOAT of - 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position - -and 's _menhir_cell0_FLOAT = - | MenhirCell0_FLOAT of 's * string * Lexing.position * Lexing.position - and ('s, 'r) _menhir_cell1_FN = | MenhirCell1_FN of 's * ('s, 'r) _menhir_state * Lexing.position and 's _menhir_cell0_FN = MenhirCell0_FN of 's * Lexing.position -and ('s, 'r) _menhir_cell1_FOR = - | MenhirCell1_FOR of 's * ('s, 'r) _menhir_state * Lexing.position - -and 's _menhir_cell0_FOR = MenhirCell0_FOR of 's * Lexing.position +and 's _menhir_cell0_FOR = + | MenhirCell0_FOR of 's * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_GUARD = | MenhirCell1_GUARD of @@ -8611,32 +5648,29 @@ and ('s, 'r) _menhir_cell1_IF = | MenhirCell1_IF of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position +and 's _menhir_cell0_IF = + | MenhirCell0_IF of 's * Lexing.position * Lexing.position + and ('s, 'r) _menhir_cell1_IMPL = | MenhirCell1_IMPL of 's * ('s, 'r) _menhir_state * Lexing.position +and 's _menhir_cell0_IMPL = MenhirCell0_IMPL of 's * Lexing.position and 's _menhir_cell0_IN = MenhirCell0_IN of 's * Lexing.position -and 's _menhir_cell0_INFIX1 = - | MenhirCell0_INFIX1 of 's * string * Lexing.position * Lexing.position - -and 's _menhir_cell0_INFIX2 = - | MenhirCell0_INFIX2 of 's * string * Lexing.position * Lexing.position - -and 's _menhir_cell0_INFIX3 = - | MenhirCell0_INFIX3 of 's * string * Lexing.position * Lexing.position - -and 's _menhir_cell0_INFIX4 = - | MenhirCell0_INFIX4 of 's * string * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_INFIX1 = + | MenhirCell1_INFIX1 of + 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_INT = - | MenhirCell1_INT of +and ('s, 'r) _menhir_cell1_INFIX2 = + | MenhirCell1_INFIX2 of 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position -and 's _menhir_cell0_INT = - | MenhirCell0_INT of 's * string * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_INFIX3 = + | MenhirCell1_INFIX3 of + 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_LABEL = - | MenhirCell1_LABEL of +and ('s, 'r) _menhir_cell1_INFIX4 = + | MenhirCell1_INFIX4 of 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_LBRACE = @@ -8656,6 +5690,8 @@ and 's _menhir_cell0_LBRACKET = and ('s, 'r) _menhir_cell1_LET = | MenhirCell1_LET of 's * ('s, 'r) _menhir_state * Lexing.position +and 's _menhir_cell0_LET = MenhirCell0_LET of 's * Lexing.position + and ('s, 'r) _menhir_cell1_LIDENT = | MenhirCell1_LIDENT of 's * ('s, 'r) _menhir_state * string * Lexing.position * Lexing.position @@ -8663,9 +5699,8 @@ and ('s, 'r) _menhir_cell1_LIDENT = and 's _menhir_cell0_LIDENT = | MenhirCell0_LIDENT of 's * string * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_LOOP = - | MenhirCell1_LOOP of - 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position +and 's _menhir_cell0_LOOP = + | MenhirCell0_LOOP of 's * Lexing.position * Lexing.position and ('s, 'r) _menhir_cell1_LPAREN = | MenhirCell1_LPAREN of @@ -8682,9 +5717,6 @@ and ('s, 'r) _menhir_cell1_MINUS = | MenhirCell1_MINUS of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position -and 's _menhir_cell0_MINUS = - | MenhirCell0_MINUS of 's * Lexing.position * Lexing.position - and ('s, 'r) _menhir_cell1_MUTABLE = | MenhirCell1_MUTABLE of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position @@ -8710,9 +5742,13 @@ and ('s, 'r) _menhir_cell1_PRIV = | MenhirCell1_PRIV of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position +and 's _menhir_cell0_PRIV = + | MenhirCell0_PRIV of 's * Lexing.position * Lexing.position + and ('s, 'r) _menhir_cell1_PUB = - | MenhirCell1_PUB of - 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position + | MenhirCell1_PUB of 's * ('s, 'r) _menhir_state * Lexing.position + +and 's _menhir_cell0_PUB = MenhirCell0_PUB of 's * Lexing.position and 's _menhir_cell0_QUESTION = | MenhirCell0_QUESTION of 's * Lexing.position * Lexing.position @@ -8727,11 +5763,7 @@ and 's _menhir_cell0_RANGE_EXCLUSIVE = and 's _menhir_cell0_RANGE_INCLUSIVE = | MenhirCell0_RANGE_INCLUSIVE of 's * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_RBRACE = - | MenhirCell1_RBRACE of 's * ('s, 'r) _menhir_state * Lexing.position - and 's _menhir_cell0_RBRACE = MenhirCell0_RBRACE of 's * Lexing.position -and 's _menhir_cell0_RBRACKET = MenhirCell0_RBRACKET of 's * Lexing.position and ('s, 'r) _menhir_cell1_RETURN = | MenhirCell1_RETURN of @@ -8741,15 +5773,11 @@ and ('s, 'r) _menhir_cell1_RPAREN = | MenhirCell1_RPAREN of 's * ('s, 'r) _menhir_state * Lexing.position and 's _menhir_cell0_RPAREN = MenhirCell0_RPAREN of 's * Lexing.position -and 's _menhir_cell0_SEMI = MenhirCell0_SEMI of 's * bool * Lexing.position -and ('s, 'r) _menhir_cell1_STRING = - | MenhirCell1_STRING of - 's - * ('s, 'r) _menhir_state - * Lex_literal.string_literal - * Lexing.position - * Lexing.position +and ('s, 'r) _menhir_cell1_SEMI = + | MenhirCell1_SEMI of 's * ('s, 'r) _menhir_state * bool * Lexing.position + +and 's _menhir_cell0_SEMI = MenhirCell0_SEMI of 's * bool * Lexing.position and 's _menhir_cell0_STRING = | MenhirCell0_STRING of @@ -8763,20 +5791,24 @@ and 's _menhir_cell0_STRUCT = MenhirCell0_STRUCT of 's * Lexing.position and ('s, 'r) _menhir_cell1_TEST = | MenhirCell1_TEST of 's * ('s, 'r) _menhir_state * Lexing.position +and 's _menhir_cell0_TEST = MenhirCell0_TEST of 's * Lexing.position + and ('s, 'r) _menhir_cell1_THIN_ARROW = - | MenhirCell1_THIN_ARROW of 's * ('s, 'r) _menhir_state + | MenhirCell1_THIN_ARROW of 's * ('s, 'r) _menhir_state * Lexing.position + +and 's _menhir_cell0_THIN_ARROW = + | MenhirCell0_THIN_ARROW of 's * Lexing.position and ('s, 'r) _menhir_cell1_TRAIT = | MenhirCell1_TRAIT of 's * ('s, 'r) _menhir_state * Lexing.position and 's _menhir_cell0_TRAIT = MenhirCell0_TRAIT of 's * Lexing.position -and ('s, 'r) _menhir_cell1_TRUE = - | MenhirCell1_TRUE of - 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position +and ('s, 'r) _menhir_cell1_TRAITALIAS = + | MenhirCell1_TRAITALIAS of 's * ('s, 'r) _menhir_state * Lexing.position -and 's _menhir_cell0_TRUE = - | MenhirCell0_TRUE of 's * Lexing.position * Lexing.position +and 's _menhir_cell0_TRAITALIAS = + | MenhirCell0_TRAITALIAS of 's * Lexing.position and ('s, 'r) _menhir_cell1_TRY = | MenhirCell1_TRY of @@ -8799,10 +5831,13 @@ and ('s, 'r) _menhir_cell1_UIDENT = and 's _menhir_cell0_UIDENT = | MenhirCell0_UIDENT of 's * string * Lexing.position * Lexing.position -and ('s, 'r) _menhir_cell1_WHILE = - | MenhirCell1_WHILE of +and ('s, 'r) _menhir_cell1_UNDERSCORE = + | MenhirCell1_UNDERSCORE of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position +and 's _menhir_cell0_WHILE = + | MenhirCell0_WHILE of 's * Lexing.position * Lexing.position + and ('s, 'r) _menhir_cell1_WITH = | MenhirCell1_WITH of 's * ('s, 'r) _menhir_state @@ -8812,31 +5847,8 @@ and _menhir_box_structure = MenhirBox_structure of Parsing_syntax.impls and _menhir_box_expression = MenhirBox_expression of Parsing_syntax.expr [@@unboxed] -let _menhir_action_002 _endpos__1_ _endpos_name_ _startpos__1_ _startpos_name_ - arg_value name = - let is_question = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Some (i _sloc) - in - let label = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } - in - (let arg_kind = - match is_question with - | Some question_loc -> - Parsing_syntax.Labelled_option { label; question_loc } - | None -> Labelled label - in - { Parsing_syntax.arg_value; arg_kind } - : Parsing_syntax.argument) - -let _menhir_action_003 _endpos_name_ _startpos_name_ arg_value name = - let is_question = None in +let _menhir_action_002 _endpos_name_ _startpos_name_ arg_value is_question name + = let label = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in @@ -8852,50 +5864,11 @@ let _menhir_action_003 _endpos_name_ _startpos_name_ arg_value name = { Parsing_syntax.arg_value; arg_kind } : Parsing_syntax.argument) -let _menhir_action_004 _endpos__1_ _endpos_label_ _startpos__1_ _startpos_label_ - label = - let is_question = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Some (i _sloc) - in - let _loc_label_ = (_startpos_label_, _endpos_label_) in - (let arg_value = - Parsing_util.label_to_expr - ~loc_:(Rloc.trim_first_char (i _loc_label_)) - label - in - let arg_kind = - match is_question with - | Some question_loc -> - Parsing_syntax.Labelled_option_pun { label; question_loc } - | None -> Labelled_pun label - in - { Parsing_syntax.arg_value; arg_kind } - : Parsing_syntax.argument) - -let _menhir_action_005 _endpos_label_ _startpos_label_ label = - let is_question = None in - let _loc_label_ = (_startpos_label_, _endpos_label_) in - (let arg_value = - Parsing_util.label_to_expr - ~loc_:(Rloc.trim_first_char (i _loc_label_)) - label - in - let arg_kind = - match is_question with - | Some question_loc -> - Parsing_syntax.Labelled_option_pun { label; question_loc } - | None -> Labelled_pun label - in - { Parsing_syntax.arg_value; arg_kind } +let _menhir_action_003 arg_value = + ({ Parsing_syntax.arg_value; arg_kind = Positional } : Parsing_syntax.argument) -let _menhir_action_006 arg_value : Parsing_syntax.argument = - { Parsing_syntax.arg_value; arg_kind = Positional } - -let _menhir_action_007 _endpos_label_ _startpos_label_ label = +let _menhir_action_004 _endpos_label_ _startpos_label_ label = let _loc_label_ = (_startpos_label_, _endpos_label_) in (let label = { Parsing_syntax.label_name = label; loc_ = i _loc_label_ } in let arg_value = @@ -8906,7 +5879,7 @@ let _menhir_action_007 _endpos_label_ _startpos_label_ label = { Parsing_syntax.arg_value; arg_kind = Labelled_pun label } : Parsing_syntax.argument) -let _menhir_action_008 _endpos__2_ _endpos_id_ _startpos__2_ _startpos_id_ id = +let _menhir_action_005 _endpos__2_ _endpos_id_ _startpos__2_ _startpos_id_ id = let _loc_id_ = (_startpos_id_, _endpos_id_) in let _loc__2_ = (_startpos__2_, _endpos__2_) in (let loc_ = i _loc_id_ in @@ -8918,110 +5891,253 @@ let _menhir_action_008 _endpos__2_ _endpos_id_ _startpos__2_ _startpos_id_ id = } : Parsing_syntax.argument) -let _menhir_action_009 () : Parsing_syntax.array_pattern = Closed [] - -let _menhir_action_010 b = - let _2 = None in - let b = b in - (Open ([], [], b) : Parsing_syntax.array_pattern) - -let _menhir_action_011 b x = - let _2 = Some x in - let b = b in - (Open ([], [], b) : Parsing_syntax.array_pattern) +let _menhir_action_006 _1 = + (Parsing_syntax.Pattern _1 : Parsing_syntax.array_pattern) -let _menhir_action_012 ps : Parsing_syntax.array_pattern = Closed ps +let _menhir_action_007 _2 = + (Parsing_syntax.String_spread _2 : Parsing_syntax.array_pattern) -let _menhir_action_013 b ps = - let b = b in - (Open ([], ps, b) : Parsing_syntax.array_pattern) +let _menhir_action_008 _endpos_b_ _startpos__1_ _startpos_b_ b = + let _endpos = _endpos_b_ in + let _symbolstartpos = _startpos__1_ in + let _loc_b_ = (_startpos_b_, _endpos_b_) in + let _sloc = (_symbolstartpos, _endpos) in + (String_spread_const + { + binder = { binder_name = b; loc_ = i _loc_b_ }; + pkg = None; + loc_ = i _sloc; + } + : Parsing_syntax.array_pattern) -let _menhir_action_014 b ps = - let _3 = None in - let b = b in - (Open (ps, [], b) : Parsing_syntax.array_pattern) +let _menhir_action_009 _endpos_b_ _startpos__1_ _startpos_b_ b pkg = + let _endpos = _endpos_b_ in + let _symbolstartpos = _startpos__1_ in + let _loc_b_ = (_startpos_b_, _endpos_b_) in + let _sloc = (_symbolstartpos, _endpos) in + (String_spread_const + { + binder = { binder_name = b; loc_ = i _loc_b_ }; + pkg = Some pkg; + loc_ = i _sloc; + } + : Parsing_syntax.array_pattern) -let _menhir_action_015 b ps x = - let _3 = Some x in - let b = b in - (Open (ps, [], b) : Parsing_syntax.array_pattern) +let _menhir_action_010 () = (Closed [] : Parsing_syntax.array_patterns) +let _menhir_action_011 p = (Closed [ p ] : Parsing_syntax.array_patterns) -let _menhir_action_016 b ps1 ps2 = - let b = b in - (Open (ps1, ps2, b) : Parsing_syntax.array_pattern) +let _menhir_action_012 p rest = + (match rest with + | Parsing_syntax.Closed ps -> Closed (p :: ps) + | Open (ps1, ps2, b) -> Open (p :: ps1, ps2, b) + : Parsing_syntax.array_patterns) -let _menhir_action_017 _endpos_name_ _startpos_name_ name pat = - let label = +let _menhir_action_013 _endpos_name_ _startpos_name_ name rest = + let b = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (Parsing_syntax.Constr_pat_arg { pat; kind = Labelled label } - : Parsing_syntax.constr_pat_arg) + let _2 = None in + (Open ([], rest, Some b) : Parsing_syntax.array_patterns) -let _menhir_action_018 _endpos_label_ _startpos_label_ label = - let _endpos = _endpos_label_ in - let _symbolstartpos = _startpos_label_ in - let _sloc = (_symbolstartpos, _endpos) in - (let pat = - Parsing_util.label_to_pat ~loc_:(Rloc.trim_first_char (i _sloc)) label - in - Parsing_syntax.Constr_pat_arg { pat; kind = Labelled_pun label } - : Parsing_syntax.constr_pat_arg) +let _menhir_action_014 _endpos_name_ _startpos_name_ name rest x = + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let _2 = Some x in + (Open ([], rest, Some b) : Parsing_syntax.array_patterns) -let _menhir_action_019 _endpos_id_ _startpos_id_ id = - let _loc_id_ = (_startpos_id_, _endpos_id_) in - (let loc_ = i _loc_id_ in - let label = { Parsing_syntax.label_name = id; loc_ } in - let pat = Parsing_util.label_to_pat ~loc_:(Rloc.trim_last_char loc_) label in - Parsing_syntax.Constr_pat_arg { pat; kind = Labelled_pun label } - : Parsing_syntax.constr_pat_arg) +let _menhir_action_015 rest = + (Open ([], rest, None) : Parsing_syntax.array_patterns) -let _menhir_action_020 pat : Parsing_syntax.constr_pat_arg = - Parsing_syntax.Constr_pat_arg { pat; kind = Positional } +let _menhir_action_016 _endpos_name_ _startpos_name_ name = + let _4 = None in + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let _2 = None in + (Open ([], [], Some b) : Parsing_syntax.array_patterns) -let _menhir_action_021 _1 = +let _menhir_action_017 _endpos_name_ _startpos_name_ name x = + let _4 = Some x in + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in let _2 = None in - (([ _1 ], false) : Parsing_syntax.constr_pat_arg list * bool) + (Open ([], [], Some b) : Parsing_syntax.array_patterns) -let _menhir_action_022 _1 x = +let _menhir_action_018 _endpos_name_ _startpos_name_ name x = + let _4 = None in + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in let _2 = Some x in - (([ _1 ], false) : Parsing_syntax.constr_pat_arg list * bool) + (Open ([], [], Some b) : Parsing_syntax.array_patterns) + +let _menhir_action_019 _endpos_name_ _startpos_name_ name x x_inlined1 = + let _4 = + let x = x_inlined1 in + Some x + in + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let _2 = Some x in + (Open ([], [], Some b) : Parsing_syntax.array_patterns) -let _menhir_action_023 () = +let _menhir_action_020 () = let _2 = None in - (([], true) : Parsing_syntax.constr_pat_arg list * bool) + (Open ([], [], None) : Parsing_syntax.array_patterns) -let _menhir_action_024 x = +let _menhir_action_021 x = let _2 = Some x in - (([], true) : Parsing_syntax.constr_pat_arg list * bool) + (Open ([], [], None) : Parsing_syntax.array_patterns) -let _menhir_action_025 arg rest : Parsing_syntax.constr_pat_arg list * bool = - let args, is_open = rest in - (arg :: args, is_open) +let _menhir_action_022 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Pexpr_constant ~loc_:(i _sloc) _1 : Parsing_syntax.expr) -let _menhir_action_026 mut ty : Parsing_syntax.constr_param = - { - Parsing_syntax.cparam_typ = ty; - cparam_mut = Option.is_some mut; - cparam_label = None; - } +let _menhir_action_023 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_multiline_string { loc_ = i _sloc; elems = _1 } + : Parsing_syntax.expr) -let _menhir_action_027 _endpos_label_name_ _startpos_label_name_ label_name mut - typ = - let _loc_label_name_ = (_startpos_label_name_, _endpos_label_name_) in - (let label : Parsing_syntax.label = - { label_name; loc_ = Rloc.trim_first_char (i _loc_label_name_) } - in - { - Parsing_syntax.cparam_typ = typ; - cparam_mut = Option.is_some mut; - cparam_label = Some label; +let _menhir_action_024 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Pexpr_interp ~loc_:(i _sloc) _1 : Parsing_syntax.expr) + +let _menhir_action_025 _endpos__3_ _startpos__1_ ls = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_compact.compact_rev ls (i _sloc) : Parsing_syntax.expr) + +let _menhir_action_026 block = + (block : Parsing_syntax.local_type_decl list * Parsing_syntax.expr) + +let _menhir_action_027 _endpos__2_ _startpos__1_ = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + ((false, i _sloc) : bool * Rloc.t) + +let _menhir_action_028 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + ((false, i _sloc) : bool * Rloc.t) + +let _menhir_action_029 _endpos__3_ _startpos__1_ = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + ((true, i _sloc) : bool * Rloc.t) + +let _menhir_action_030 _endpos_name_ _startpos_name_ name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _loc = (_startpos, _endpos) in + ({ + Parsing_syntax.constr_name = { name; loc_ = i _loc_name_ }; + extra_info = No_extra_info; + loc_ = i _loc; + } + : Parsing_syntax.constructor) + +let _menhir_action_031 _endpos_constr_name_ _startpos_constr_name_ + _startpos_pkg_ constr_name pkg = + let _endpos = _endpos_constr_name_ in + let _symbolstartpos = _startpos_pkg_ in + let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in + let _sloc = (_symbolstartpos, _endpos) in + ({ + Parsing_syntax.constr_name = + { name = constr_name; loc_ = i _loc_constr_name_ }; + extra_info = Package pkg; + loc_ = i _sloc; + } + : Parsing_syntax.constructor) + +let _menhir_action_032 _endpos_constr_name_ _startpos_constr_name_ + _startpos_type_name_ constr_name type_name = + let _endpos = _endpos_constr_name_ in + let _symbolstartpos = _startpos_type_name_ in + let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in + let _sloc = (_symbolstartpos, _endpos) in + ({ + Parsing_syntax.constr_name = + { name = constr_name; loc_ = i _loc_constr_name_ }; + extra_info = Type_name type_name; + loc_ = i _sloc; + } + : Parsing_syntax.constructor) + +let _menhir_action_033 _endpos_name_ _startpos_name_ name pat = + let label = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } + in + (Parsing_syntax.Constr_pat_arg { pat; kind = Labelled label } + : Parsing_syntax.constr_pat_arg) + +let _menhir_action_034 _endpos_id_ _startpos_id_ id = + let _loc_id_ = (_startpos_id_, _endpos_id_) in + (let loc_ = i _loc_id_ in + let label = { Parsing_syntax.label_name = id; loc_ } in + let pat = Parsing_util.label_to_pat ~loc_:(Rloc.trim_last_char loc_) label in + Parsing_syntax.Constr_pat_arg { pat; kind = Labelled_pun label } + : Parsing_syntax.constr_pat_arg) + +let _menhir_action_035 pat = + (Parsing_syntax.Constr_pat_arg { pat; kind = Positional } + : Parsing_syntax.constr_pat_arg) + +let _menhir_action_036 _1 = + (([ _1 ], false) : Parsing_syntax.constr_pat_arg list * bool) + +let _menhir_action_037 () = + (([], true) : Parsing_syntax.constr_pat_arg list * bool) + +let _menhir_action_038 arg rest = + (let args, is_open = rest in + (arg :: args, is_open) + : Parsing_syntax.constr_pat_arg list * bool) + +let _menhir_action_039 mut ty = + ({ + Parsing_syntax.cparam_typ = ty; + cparam_mut = (match mut with Some _ -> true | _ -> false); + cparam_label = None; } : Parsing_syntax.constr_param) -let _menhir_action_028 _endpos_label_name_ _startpos_label_name_ label_name mut +let _menhir_action_040 _endpos_label_name_ _startpos_label_name_ label_name mut typ = let _loc_label_name_ = (_startpos_label_name_, _endpos_label_name_) in (let label : Parsing_syntax.label = @@ -9029,21 +6145,12 @@ let _menhir_action_028 _endpos_label_name_ _startpos_label_name_ label_name mut in { Parsing_syntax.cparam_typ = typ; - cparam_mut = Option.is_some mut; + cparam_mut = (match mut with Some _ -> true | _ -> false); cparam_label = Some label; } : Parsing_syntax.constr_param) -let _menhir_action_029 _endpos_name_ _startpos_name_ name = - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let _endpos_type_name_, _startpos_type_name_ = - (_endpos_name_, _startpos_name_) - in +let _menhir_action_041 _endpos_type_name_ _startpos_type_name_ type_name = let _endpos = _endpos_type_name_ in let _symbolstartpos = _startpos_type_name_ in let _sloc = (_symbolstartpos, _endpos) in @@ -9051,31 +6158,7 @@ let _menhir_action_029 _endpos_name_ _startpos_name_ name = : Parsing_syntax.deriving_directive) : Parsing_syntax.deriving_directive) -let _menhir_action_030 _endpos__4_ _endpos_name_ _startpos_name_ name = - let args = [] in - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let _startpos_type_name_ = _startpos_name_ in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos_type_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (({ type_name_ = type_name; loc_ = i _sloc; args } - : Parsing_syntax.deriving_directive) - : Parsing_syntax.deriving_directive) - -let _menhir_action_031 _1 _endpos__4_ _endpos_name_ _startpos_name_ name = - let args = _1 in - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let _startpos_type_name_ = _startpos_name_ in +let _menhir_action_042 _endpos__4_ _startpos_type_name_ args type_name = let _endpos = _endpos__4_ in let _symbolstartpos = _startpos_type_name_ in let _sloc = (_symbolstartpos, _endpos) in @@ -9083,40 +6166,38 @@ let _menhir_action_031 _1 _endpos__4_ _endpos_name_ _startpos_name_ name = : Parsing_syntax.deriving_directive) : Parsing_syntax.deriving_directive) -let _menhir_action_032 () : Parsing_syntax.deriving_directive list = [] +let _menhir_action_043 () = ([] : Parsing_syntax.deriving_directive list) +let _menhir_action_044 _3 = (_3 : Parsing_syntax.deriving_directive list) -let _menhir_action_033 () = - let _3 = [] in - (_3 : Parsing_syntax.deriving_directive list) - -let _menhir_action_034 _1_inlined1 = - let _3 = - let _1 = _1_inlined1 in - _1 - in - (_3 : Parsing_syntax.deriving_directive list) - -let _menhir_action_035 _endpos_id_ _endpos_opt_ _startpos_id_ id opt = - let _endpos = _endpos_opt_ in +let _menhir_action_045 _endpos_constr_tag_ _endpos_id_ _startpos_id_ constr_args + constr_tag id = + let _endpos = _endpos_constr_tag_ in let _symbolstartpos = _startpos_id_ in let _loc_id_ = (_startpos_id_, _endpos_id_) in let _sloc = (_symbolstartpos, _endpos) in (let constr_name : Parsing_syntax.constr_name = { name = id; loc_ = i _loc_id_ } in - { Parsing_syntax.constr_name; constr_args = opt; constr_loc_ = i _sloc } + { + Parsing_syntax.constr_name; + constr_args; + constr_tag; + constr_loc_ = i _sloc; + } : Parsing_syntax.constr_decl) -let _menhir_action_036 _endpos_tycon_ _startpos_tycon_ params tycon = +let _menhir_action_046 _endpos_tycon_ _startpos_tycon_ params tycon = let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) -let _menhir_action_037 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ +let _menhir_action_047 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ params tycon = let vis = let _endpos = _endpos__1_ in @@ -9124,14 +6205,16 @@ let _menhir_action_037 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ let _sloc = (_symbolstartpos, _endpos) in Parsing_syntax.Vis_priv { loc_ = i _sloc } in + let attrs = [] in let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) -let _menhir_action_038 _endpos_attr_ _endpos_tycon_ _startpos__1_ +let _menhir_action_048 _endpos_attr_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ attr params tycon = let vis = let _endpos = _endpos_attr_ in @@ -9139,27 +6222,177 @@ let _menhir_action_038 _endpos_attr_ _endpos_tycon_ _startpos__1_ let _sloc = (_symbolstartpos, _endpos) in Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in + let attrs = [] in let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility * string * Rloc.t * Parsing_syntax.type_decl_binder list) -let _menhir_action_039 _1 : Parsing_syntax.expr = _1 -let _menhir_action_040 _1 : Parsing_syntax.expr = _1 -let _menhir_action_041 _1 : Parsing_syntax.expr = _1 -let _menhir_action_042 _1 : Parsing_syntax.expr = _1 -let _menhir_action_043 _1 : Parsing_syntax.expr = _1 -let _menhir_action_044 _1 : Parsing_syntax.expr = _1 -let _menhir_action_045 _1 : Parsing_syntax.expr = _1 -let _menhir_action_046 _1 : Parsing_syntax.expr = _1 -let _menhir_action_047 _1 : Parsing_syntax.expr = _1 - -let _menhir_action_048 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts = - let has_error = true in - let pub = None in +let _menhir_action_049 _1 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) + +let _menhir_action_050 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) + +let _menhir_action_051 _1 _endpos_attr_ _endpos_tycon_ _startpos__1_inlined1_ + _startpos_tycon_ attr params tycon = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) + +let _menhir_action_052 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_053 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_054 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_055 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_056 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_057 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_058 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_059 _1 = (_1 : Parsing_syntax.expr) + +let _menhir_action_060 _endpos_arg_ _endpos_label_ _startpos__1_ + _startpos_label_ arg label = + let _endpos = _endpos_arg_ in + let _symbolstartpos = _startpos__1_ in + let _loc_label_ = (_startpos_label_, _endpos_label_) in + let _sloc = (_symbolstartpos, _endpos) in + (let label = { Parsing_syntax.label_name = label; loc_ = i _loc_label_ } in + Parsing_syntax.Pexpr_break { arg; label = Some label; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_061 _endpos_arg_ _startpos__1_ arg = + let _endpos = _endpos_arg_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_break { arg; label = None; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_062 _endpos_args_ _endpos_label_ _startpos__1_ + _startpos_label_ args label = + let _endpos = _endpos_args_ in + let _symbolstartpos = _startpos__1_ in + let _loc_label_ = (_startpos_label_, _endpos_label_) in + let _sloc = (_symbolstartpos, _endpos) in + (let label = { Parsing_syntax.label_name = label; loc_ = i _loc_label_ } in + Parsing_syntax.Pexpr_continue { args; label = Some label; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_063 _endpos_args_ _startpos__1_ args = + let _endpos = _endpos_args_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_continue { args; label = None; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_064 _endpos_expr_ _startpos__1_ expr = + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_065 _endpos_expr_ _startpos__1_ expr = + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } + : Parsing_syntax.expr) + +let _menhir_action_066 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } + : Parsing_syntax.expr) + +let _menhir_action_067 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_lv_ e + lv = + let _1 = + let op = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } + in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_lv_ in + let _sloc = (_symbolstartpos, _endpos) in + let loc_ = i _sloc in + match lv with + | `Var var -> + Parsing_syntax.Pexpr_assign + { var; expr = e; augmented_by = Some op; loc_ } + | `Field_access (record, accessor) -> + Parsing_syntax.Pexpr_mutate + { record; accessor; field = e; augmented_by = Some op; loc_ } + | `Array_access (array, index) -> + Pexpr_array_augmented_set { op; array; index; value = e; loc_ } + in + (_1 : Parsing_syntax.expr) + +let _menhir_action_068 _endpos_e_ _startpos_lv_ e lv = + let _1 = + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_lv_ in + let _sloc = (_symbolstartpos, _endpos) in + let loc_ = i _sloc in + match lv with + | `Var var -> + Parsing_syntax.Pexpr_assign { var; expr = e; augmented_by = None; loc_ } + | `Field_access (record, accessor) -> + Parsing_syntax.Pexpr_mutate + { record; accessor; field = e; augmented_by = None; loc_ } + | `Array_access (array, index) -> + Pexpr_array_set { array; index; value = e; loc_ } + in + (_1 : Parsing_syntax.expr) + +let _menhir_action_069 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_070 _1 = (_1 : Parsing_syntax.expr) + +let _menhir_action_071 _endpos_ps_ _startpos_ps_ fun_binder has_error language + ps quants ts = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in ( language, @@ -9167,19 +6400,75 @@ let _menhir_action_048 _endpos_ps_ _startpos_ps_ fun_binder language ps quants Parsing_syntax.type_name; name = f; has_error; + is_async = false; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } ) : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) -let _menhir_action_049 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts = - let has_error = false in - let pub = None in +let _menhir_action_072 _endpos__1_ _endpos_ps_ _startpos__1_ _startpos_ps_ + fun_binder has_error language ps quants ts = + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + ( language, + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async = false; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } ) + : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) + +let _menhir_action_073 _endpos_attr_ _endpos_ps_ _startpos__1_ _startpos_ps_ + attr fun_binder has_error language ps quants ts = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = [] in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + ( language, + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async = false; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } ) + : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) + +let _menhir_action_074 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error + language ps quants ts = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in ( language, @@ -9187,19 +6476,30 @@ let _menhir_action_049 _endpos_ps_ _startpos_ps_ fun_binder language ps quants Parsing_syntax.type_name; name = f; has_error; + is_async = false; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } ) : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) -let _menhir_action_050 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts x = - let has_error = true in - let pub = Some x in +let _menhir_action_075 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error language ps quants + ts = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = _1 in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in ( language, @@ -9207,19 +6507,27 @@ let _menhir_action_050 _endpos_ps_ _startpos_ps_ fun_binder language ps quants Parsing_syntax.type_name; name = f; has_error; + is_async = false; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } ) : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) -let _menhir_action_051 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts x = - let has_error = false in - let pub = Some x in +let _menhir_action_076 _1 _endpos_attr_ _endpos_ps_ _startpos__1_inlined1_ + _startpos_ps_ attr fun_binder has_error language ps quants ts = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in ( language, @@ -9227,16 +6535,18 @@ let _menhir_action_051 _endpos_ps_ _startpos_ps_ fun_binder language ps quants Parsing_syntax.type_name; name = f; has_error; + is_async = false; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } ) : Parsing_syntax.string_literal * Parsing_syntax.fun_decl) -let _menhir_action_052 _endpos_name_ _endpos_p_ _startpos_name_ name p = +let _menhir_action_077 _endpos_name_ _endpos_p_ _startpos_name_ name p = let _1 = let l = let _endpos = _endpos_name_ in @@ -9252,7 +6562,7 @@ let _menhir_action_052 _endpos_name_ _endpos_p_ _startpos_name_ name p = in (_1 : Parsing_syntax.field_pat) -let _menhir_action_053 _endpos_name_ _startpos_name_ name = +let _menhir_action_078 _endpos_name_ _startpos_name_ name = let _1 = let l = let _endpos = _endpos_name_ in @@ -9268,245 +6578,47 @@ let _menhir_action_053 _endpos_name_ _startpos_name_ name = in (_1 : Parsing_syntax.field_pat) -let _menhir_action_054 _1 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - ({ Parsing_syntax.label_name = _1; loc_ = i _sloc } : Parsing_syntax.label) - -let _menhir_action_055 () = - let binders = [] in - (binders : (Parsing_syntax.binder * Parsing_syntax.expr) list) - -let _menhir_action_056 _1 = - let binders = _1 in - (binders : (Parsing_syntax.binder * Parsing_syntax.expr) list) - -let _menhir_action_057 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let continue_block = [] in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) - -let _menhir_action_058 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let continue_block = [] in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) - -let _menhir_action_059 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else x xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) +let _menhir_action_079 _endpos_name_ _startpos_name_ has_error name = + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - let continue_block = [] in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) + ((binder, has_error) : Parsing_syntax.binder * Rloc.t option) -let _menhir_action_060 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let continue_block = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) +let _menhir_action_080 has_error = (has_error : Rloc.t option) -let _menhir_action_061 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let continue_block = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) +let _menhir_action_081 binders = + (binders : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_062 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else x xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let continue_block = - let _1 = _1_inlined1 in - _1 - in +let _menhir_action_082 _endpos_for_else_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body condition continue_block for_else label = let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { loc_ = i _sloc; binders; condition; continue_block; body; for_else } - : Parsing_syntax.expr) - -let _menhir_action_063 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + let _symbolstartpos = + if _startpos_label_ != _endpos_label_ then _startpos_label_ + else _startpos__2_ in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Parsing_syntax.Pexpr_for { loc_ = i _sloc; binders; - condition = None; - continue_block = []; + condition; + continue_block; body; for_else; + label; } : Parsing_syntax.expr) -let _menhir_action_064 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in +let _menhir_action_083 _endpos_for_else_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body for_else label = let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_for - { - loc_ = i _sloc; - binders; - condition = None; - continue_block = []; - body; - for_else; - } - : Parsing_syntax.expr) - -let _menhir_action_065 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + let _symbolstartpos = + if _startpos_label_ != _endpos_label_ then _startpos_label_ + else _startpos__2_ in - let _endpos = _endpos_for_else_ in - let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Parsing_syntax.Pexpr_for { @@ -9516,10 +6628,11 @@ let _menhir_action_065 _endpos__3_ _endpos_for_else_ _startpos__1_ continue_block = []; body; for_else; + label; } : Parsing_syntax.expr) -let _menhir_action_066 _endpos_name_ _startpos_name_ name = +let _menhir_action_084 _endpos_name_ _startpos_name_ name = let _1 = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in @@ -9528,85 +6641,22 @@ let _menhir_action_066 _endpos_name_ _startpos_name_ name = in (Some _1 : Parsing_syntax.binder option) -let _menhir_action_067 () : Parsing_syntax.binder option = None - -let _menhir_action_068 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_else_block_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_foreach - { binders; expr; body; else_block; loc_ = i _sloc } - : Parsing_syntax.expr) +let _menhir_action_085 () = (None : Parsing_syntax.binder option) -let _menhir_action_069 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in +let _menhir_action_086 _endpos_else_block_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body else_block expr label = let _endpos = _endpos_else_block_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_foreach - { binders; expr; body; else_block; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_070 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr x xs = - let body = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + let _symbolstartpos = + if _startpos_label_ != _endpos_label_ then _startpos_label_ + else _startpos__2_ in - let _endpos = _endpos_else_block_ in - let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Parsing_syntax.Pexpr_foreach - { binders; expr; body; else_block; loc_ = i _sloc } + { binders; expr; body; else_block; label; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_071 _endpos_func_name_ _endpos_name_ _startpos_func_name_ - _startpos_name_ func_name name = - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in +let _menhir_action_087 _endpos_func_name_ _startpos_func_name_ func_name + type_name = let _loc_func_name_ = (_startpos_func_name_, _endpos_func_name_) in (let binder : Parsing_syntax.binder = { binder_name = func_name; loc_ = i _loc_func_name_ } @@ -9614,7 +6664,7 @@ let _menhir_action_071 _endpos_func_name_ _endpos_name_ _startpos_func_name_ (Some type_name, binder) : Parsing_syntax.type_name option * Parsing_syntax.binder) -let _menhir_action_072 _endpos_name_ _startpos_name_ name = +let _menhir_action_088 _endpos_name_ _startpos_name_ name = let _1 = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in @@ -9623,606 +6673,379 @@ let _menhir_action_072 _endpos_name_ _startpos_name_ name = in ((None, _1) : Parsing_syntax.type_name option * Parsing_syntax.binder) -let _menhir_action_073 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts = - let has_error = true in - let pub = None in +let _menhir_action_089 _endpos_ps_ _startpos_ps_ fun_binder has_error ps quants + ts = + let is_async = true in + let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in { Parsing_syntax.type_name; name = f; has_error; + is_async; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } : Parsing_syntax.fun_decl) -let _menhir_action_074 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts = - let has_error = false in - let pub = None in +let _menhir_action_090 _endpos_ps_ _startpos_ps_ fun_binder has_error ps quants + ts = + let is_async = false in + let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in { Parsing_syntax.type_name; name = f; has_error; + is_async; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } : Parsing_syntax.fun_decl) -let _menhir_action_075 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts x = - let has_error = true in - let pub = Some x in +let _menhir_action_091 _endpos__1_ _endpos_ps_ _startpos__1_ _startpos_ps_ + fun_binder has_error ps quants ts = + let is_async = true in + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in { Parsing_syntax.type_name; name = f; has_error; + is_async; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } : Parsing_syntax.fun_decl) -let _menhir_action_076 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts x = - let has_error = false in - let pub = Some x in +let _menhir_action_092 _endpos__1_ _endpos_ps_ _startpos__1_ _startpos_ps_ + fun_binder has_error ps quants ts = + let is_async = false in + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in (let type_name, f = fun_binder in { Parsing_syntax.type_name; name = f; has_error; + is_async; quantifiers = quants; decl_params = ps; params_loc_ = i _loc_ps_; return_type = ts; - is_pub = pub <> None; + vis; doc_ = Docstring.empty; + attrs; } : Parsing_syntax.fun_decl) -let _menhir_action_077 _endpos_cond_ _startpos__1_ cond = - let _endpos = _endpos_cond_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard { cond; otherwise = None; loc = i _sloc } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_078 _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined1_ - cond = - let else_ = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_else__ = _endpos__3_inlined1_ in - let _endpos = _endpos_else__ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard { cond; otherwise = Some else_; loc = i _sloc } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_079 _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined1_ - cond xs = - let else_ = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in +let _menhir_action_093 _endpos_attr_ _endpos_ps_ _startpos__1_ _startpos_ps_ + attr fun_binder has_error ps quants ts = + let is_async = true in + let vis = + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _endpos_else__ = _endpos__3_inlined1_ in - let _endpos = _endpos_else__ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard { cond; otherwise = Some else_; loc = i _sloc } - : Parsing_compact.semi_expr_prop) + let attrs = [] in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_080 _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined1_ - cond x xs = - let else_ = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined1_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in +let _menhir_action_094 _endpos_attr_ _endpos_ps_ _startpos__1_ _startpos_ps_ + attr fun_binder has_error ps quants ts = + let is_async = false in + let vis = + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _endpos_else__ = _endpos__3_inlined1_ in - let _endpos = _endpos_else__ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard { cond; otherwise = Some else_; loc = i _sloc } - : Parsing_compact.semi_expr_prop) + let attrs = [] in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_081 _endpos_expr_ _startpos__1_ expr pat = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard_let { pat; expr; otherwise = None; loc = i _sloc } - : Parsing_compact.semi_expr_prop) +let _menhir_action_095 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error ps + quants ts = + let is_async = true in + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_082 _endpos__9_ _startpos__1_ cases expr pat = - let _endpos = _endpos__9_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_compact.Stmt_guard_let - { pat; expr; otherwise = Some cases; loc = i _sloc } - : Parsing_compact.semi_expr_prop) +let _menhir_action_096 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error ps + quants ts = + let is_async = false in + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_083 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b = - let ifnot = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) +let _menhir_action_097 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error ps quants ts = + let is_async = true in + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) - -let _menhir_action_084 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b xs = - let ifnot = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) - -let _menhir_action_085 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs = - let ifnot = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_086 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b xs = - let ifnot = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 +let _menhir_action_098 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error ps quants ts = + let is_async = false in + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - let _endpos = _endpos__3_ in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_087 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b xs xs_inlined1 = - let ifnot = - let _endpos__3_, _startpos__1_, xs = - (_endpos__3_inlined1_, _startpos__1_inlined2_, xs_inlined1) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = +let _menhir_action_099 _1 _endpos_attr_ _endpos_ps_ _startpos__1_inlined1_ + _startpos_ps_ attr fun_binder has_error ps quants ts = + let is_async = true in + let vis = let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_088 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs xs_inlined1 = - let ifnot = - let _endpos__3_, _startpos__1_, xs = - (_endpos__3_inlined1_, _startpos__1_inlined2_, xs_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = +let _menhir_action_100 _1 _endpos_attr_ _endpos_ps_ _startpos__1_inlined1_ + _startpos_ps_ attr fun_binder has_error ps quants ts = + let is_async = false in + let vis = let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _endpos = _endpos_ifnot_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + let attrs = _1 in + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + (let type_name, f = fun_binder in + { + Parsing_syntax.type_name; + name = f; + has_error; + is_async; + quantifiers = quants; + decl_params = ps; + params_loc_ = i _loc_ps_; + return_type = ts; + vis; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.fun_decl) -let _menhir_action_089 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs = - let ifnot = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in +let _menhir_action_101 _endpos_cond_ _startpos__1_ cond = + let _endpos = _endpos_cond_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + (Parsing_compact.Stmt_guard { cond; otherwise = None; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_090 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs xs_inlined1 = - let ifnot = - let _endpos__3_, _startpos__1_, xs = - (_endpos__3_inlined1_, _startpos__1_inlined2_, xs_inlined1) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in +let _menhir_action_102 _endpos_else__ _startpos__1_ cond else_ = + let _endpos = _endpos_else__ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + (Parsing_compact.Stmt_guard { cond; otherwise = Some else_; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_091 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x x_inlined1 xs xs_inlined1 - = - let ifnot = - let _endpos__3_, _startpos__1_, x, xs = - (_endpos__3_inlined1_, _startpos__1_inlined2_, x_inlined1, xs_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifnot_ = _endpos__3_inlined1_ in - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in +let _menhir_action_103 _endpos_expr_ _startpos__1_ expr pat = + let _endpos = _endpos_expr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + (Parsing_compact.Stmt_guard_let { pat; expr; otherwise = None; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_092 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_ifnot_ in +let _menhir_action_104 _endpos__9_ _startpos__1_ cases expr pat = + let _endpos = _endpos__9_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } - : Parsing_syntax.expr) + (Parsing_compact.Stmt_guard_let + { pat; expr; otherwise = Some cases; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_093 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot xs = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in +let _menhir_action_105 _endpos_ifnot_ _startpos__1_ b ifnot ifso = let _endpos = _endpos_ifnot_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } : Parsing_syntax.expr) -let _menhir_action_094 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot x xs = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in +let _menhir_action_106 _endpos_ifnot_ _startpos__1_ b ifnot ifso = let _endpos = _endpos_ifnot_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = Some ifnot } : Parsing_syntax.expr) -let _menhir_action_095 _endpos__3_ _startpos__1_ _startpos__1_inlined1_ b = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifso_ = _endpos__3_ in +let _menhir_action_107 _endpos_ifso_ _startpos__1_ b ifso = let _endpos = _endpos_ifso_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in (Parsing_syntax.Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = None } : Parsing_syntax.expr) -let _menhir_action_096 _endpos__3_ _startpos__1_ _startpos__1_inlined1_ b xs = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifso_ = _endpos__3_ in - let _endpos = _endpos_ifso_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = None } - : Parsing_syntax.expr) +let _menhir_action_108 block = + (let local_types, expr = block in + Parsing_syntax.Decl_body { expr; local_types } + : Parsing_syntax.decl_body) -let _menhir_action_097 _endpos__3_ _startpos__1_ _startpos__1_inlined1_ b x xs = - let ifso = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_ifso_ = _endpos__3_ in - let _endpos = _endpos_ifso_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_if { loc_ = i _sloc; cond = b; ifso; ifnot = None } - : Parsing_syntax.expr) +let _menhir_action_109 code = + (Parsing_syntax.Decl_stubs + (Embedded { language = None; code = Code_string code }) + : Parsing_syntax.decl_body) -let _menhir_action_098 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ +let _menhir_action_110 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10235,7 +7058,7 @@ let _menhir_action_098 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_099 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ +let _menhir_action_111 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10248,7 +7071,7 @@ let _menhir_action_099 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_100 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ +let _menhir_action_112 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10261,7 +7084,7 @@ let _menhir_action_100 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_101 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ +let _menhir_action_113 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10274,7 +7097,7 @@ let _menhir_action_101 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_102 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_114 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10287,7 +7110,7 @@ let _menhir_action_102 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_103 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_115 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10300,7 +7123,7 @@ let _menhir_action_103 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_104 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_116 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10313,7 +7136,7 @@ let _menhir_action_104 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_105 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_117 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10326,7 +7149,7 @@ let _menhir_action_105 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_106 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_118 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10339,7 +7162,7 @@ let _menhir_action_106 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_107 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_119 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10352,7 +7175,7 @@ let _menhir_action_107 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_108 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs +let _menhir_action_120 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs rhs = let op = let _endpos = _endpos__1_ in @@ -10365,116 +7188,194 @@ let _menhir_action_108 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs let _sloc = (_symbolstartpos, _endpos) in (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_109 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs - rhs = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident "..<"; loc_ = i _sloc } - in - let _endpos = _endpos_rhs_ in - let _symbolstartpos = _startpos_lhs_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) +let _menhir_action_121 _1 = (_1 : Parsing_syntax.expr) -let _menhir_action_110 _endpos__1_ _endpos_rhs_ _startpos__1_ _startpos_lhs_ lhs - rhs = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident "..="; loc_ = i _sloc } +let _menhir_action_122 _endpos_name_ _startpos_name_ name = + let var = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.var_name = name; loc_ = i _loc } in - let _endpos = _endpos_rhs_ in - let _symbolstartpos = _startpos_lhs_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_infix { op; lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_111 _1 : Parsing_syntax.expr = _1 + (`Var var + : [ `Array_access of Parsing_syntax.expr * Parsing_syntax.expr + | `Field_access of Parsing_syntax.expr * Parsing_syntax.accessor + | `Var of Parsing_syntax.var ]) -let _menhir_action_112 _endpos_tycon_ _startpos_tycon_ tycon = - let fs = [] in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - (({ - local_tycon = tycon; - local_tycon_loc_ = i _loc_tycon_; - local_components = Ptd_record fs; - } - : Parsing_syntax.local_type_decl) - : Parsing_syntax.local_type_decl) +let _menhir_action_123 _endpos_name_ _startpos_name_ name record = + let acc = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + if name = "_" then Parsing_syntax.Newtype + else Parsing_syntax.Label { label_name = name; loc_ = i _loc } + in + (`Field_access (record, acc) + : [ `Array_access of Parsing_syntax.expr * Parsing_syntax.expr + | `Field_access of Parsing_syntax.expr * Parsing_syntax.accessor + | `Var of Parsing_syntax.var ]) -let _menhir_action_113 _1_inlined1 _endpos_tycon_ _startpos_tycon_ tycon = - let fs = - let _1 = _1_inlined1 in - _1 +let _menhir_action_124 _endpos_index_ _startpos_index_ index record = + let acc = + let _endpos = _endpos_index_ in + let _startpos = _startpos_index_ in + let _loc = (_startpos, _endpos) in + Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } in + (`Field_access (record, acc) + : [ `Array_access of Parsing_syntax.expr * Parsing_syntax.expr + | `Field_access of Parsing_syntax.expr * Parsing_syntax.accessor + | `Var of Parsing_syntax.var ]) + +let _menhir_action_125 ind obj = + (`Array_access (obj, ind) + : [ `Array_access of Parsing_syntax.expr * Parsing_syntax.expr + | `Field_access of Parsing_syntax.expr * Parsing_syntax.accessor + | `Var of Parsing_syntax.var ]) + +let _menhir_action_126 () = ([] : Parsing_syntax.argument list) +let _menhir_action_127 _1 = (_1 : Parsing_syntax.argument list) +let _menhir_action_128 () = ([] : Parsing_syntax.deriving_directive list) +let _menhir_action_129 _1 = (_1 : Parsing_syntax.deriving_directive list) +let _menhir_action_130 () = ([] : Parsing_syntax.expr list) +let _menhir_action_131 _1 = (_1 : Parsing_syntax.expr list) +let _menhir_action_132 () = ([] : Parsing_syntax.map_expr_elem list) +let _menhir_action_133 _1 = (_1 : Parsing_syntax.map_expr_elem list) +let _menhir_action_134 () = ([] : Parsing_syntax.parameters) +let _menhir_action_135 _1 = (_1 : Parsing_syntax.parameters) +let _menhir_action_136 () = ([] : Parsing_syntax.field_def list) +let _menhir_action_137 _1 = (_1 : Parsing_syntax.field_def list) +let _menhir_action_138 () = ([] : Parsing_syntax.spreadable_elem list) +let _menhir_action_139 _1 = (_1 : Parsing_syntax.spreadable_elem list) +let _menhir_action_140 () = ([] : Parsing_syntax.trait_method_param list) +let _menhir_action_141 _1 = (_1 : Parsing_syntax.trait_method_param list) + +let _menhir_action_142 () = + ([] : (Parsing_syntax.binder * Parsing_syntax.expr) list) + +let _menhir_action_143 _1 = + (_1 : (Parsing_syntax.binder * Parsing_syntax.expr) list) + +let _menhir_action_144 () = + ([] : (Parsing_syntax.binder * Parsing_syntax.expr) list) + +let _menhir_action_145 _1 = + (_1 : (Parsing_syntax.binder * Parsing_syntax.expr) list) + +let _menhir_action_146 () = ([] : Parsing_syntax.expr list) +let _menhir_action_147 _1 = (_1 : Parsing_syntax.expr list) +let _menhir_action_148 () = (([], false) : Parsing_syntax.field_def list * bool) +let _menhir_action_149 _1 = (_1 : Parsing_syntax.field_def list * bool) +let _menhir_action_150 () = ([] : Parsing_syntax.constr_decl list) +let _menhir_action_151 _1 = (_1 : Parsing_syntax.constr_decl list) +let _menhir_action_152 () = ([] : Parsing_syntax.multi_arg_case list) +let _menhir_action_153 _1 = (_1 : Parsing_syntax.multi_arg_case list) +let _menhir_action_154 () = ([] : Parsing_syntax.field_decl list) +let _menhir_action_155 _1 = (_1 : Parsing_syntax.field_decl list) +let _menhir_action_156 () = ([] : Parsing_syntax.case list) +let _menhir_action_157 _1 = (_1 : Parsing_syntax.case list) +let _menhir_action_158 () = ([] : Parsing_syntax.impls) +let _menhir_action_159 _1 = (_1 : Parsing_syntax.impls) +let _menhir_action_160 () = ([] : Parsing_syntax.trait_method_decl list) +let _menhir_action_161 _1 = (_1 : Parsing_syntax.trait_method_decl list) +let _menhir_action_162 () = ([] : Parsing_compact.semi_expr_prop list) +let _menhir_action_163 _1 = (_1 : Parsing_compact.semi_expr_prop list) + +let _menhir_action_164 _endpos_tycon_ _startpos_tycon_ deriving_ fs tycon = let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in (({ local_tycon = tycon; local_tycon_loc_ = i _loc_tycon_; local_components = Ptd_record fs; + deriving_; } : Parsing_syntax.local_type_decl) : Parsing_syntax.local_type_decl) -let _menhir_action_114 _endpos_tycon_ _startpos_tycon_ tycon = - let cs = [] in +let _menhir_action_165 _endpos_tycon_ _startpos_tycon_ cs deriving_ tycon = let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in (({ local_tycon = tycon; local_tycon_loc_ = i _loc_tycon_; local_components = Ptd_variant cs; + deriving_; } : Parsing_syntax.local_type_decl) : Parsing_syntax.local_type_decl) -let _menhir_action_115 _1_inlined1 _endpos_tycon_ _startpos_tycon_ tycon = - let cs = - let _1 = _1_inlined1 in - _1 - in +let _menhir_action_166 _endpos_tycon_ _startpos_tycon_ deriving_ ty tycon = let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in (({ local_tycon = tycon; local_tycon_loc_ = i _loc_tycon_; - local_components = Ptd_variant cs; + local_components = Ptd_newtype ty; + deriving_; } : Parsing_syntax.local_type_decl) : Parsing_syntax.local_type_decl) -let _menhir_action_116 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ args = - let body = [] in - let args = args in - let _endpos_args_, _startpos_args_ = (_endpos__3_inlined1_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_args_ in - let _loc_args_ = (_startpos_args_, _endpos_args_) in +let _menhir_action_167 _endpos_t_ _startpos_t_ t = + let _endpos = _endpos_t_ in + let _symbolstartpos = _startpos_t_ in let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_loop - { args; body; loc_ = i _sloc; loop_loc_ = i _loc_args_ } - : Parsing_syntax.expr) + (([ t ], Parsing_syntax.Pexpr_unit { loc_ = i _sloc; faked = true }) + : Parsing_syntax.local_type_decl list * Parsing_syntax.expr) -let _menhir_action_117 _1_inlined1 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ args = - let body = - let _1 = _1_inlined1 in - _1 +let _menhir_action_168 _endpos_ls_ _startpos_ls_ ls = + let _endpos = _endpos_ls_ in + let _symbolstartpos = + if _startpos_ls_ != _endpos_ls_ then _startpos_ls_ else _endpos in + let _sloc = (_symbolstartpos, _endpos) in + (([], Parsing_compact.compact_rev ls (i _sloc)) + : Parsing_syntax.local_type_decl list * Parsing_syntax.expr) + +let _menhir_action_169 rest t = + ((t :: fst rest, snd rest) + : Parsing_syntax.local_type_decl list * Parsing_syntax.expr) + +let _menhir_action_170 _endpos__3_ _endpos__4_ _endpos_label_ _startpos__1_ + _startpos_label_ args body label = let args = args in - let _endpos_args_, _startpos_args_ = (_endpos__3_inlined1_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_args_ in + let _endpos_args_, _startpos_args_ = (_endpos__3_, _startpos__1_) in + let _endpos = _endpos__4_ in + let _symbolstartpos = + if _startpos_label_ != _endpos_label_ then _startpos_label_ + else _startpos_args_ + in let _loc_args_ = (_startpos_args_, _endpos_args_) in let _sloc = (_symbolstartpos, _endpos) in (Parsing_syntax.Pexpr_loop - { args; body; loc_ = i _sloc; loop_loc_ = i _loc_args_ } + { args; body; label; loc_ = i _sloc; loop_loc_ = i _loc_args_ } : Parsing_syntax.expr) -let _menhir_action_118 i : string = i -let _menhir_action_119 i : string = i +let _menhir_action_171 _endpos_label_ _startpos_label_ label = + let _loc_label_ = (_startpos_label_, _endpos_label_) in + (Some { Parsing_syntax.label_name = label; loc_ = i _loc_label_ } + : Parsing_syntax.label option) + +let _menhir_action_172 () = (None : Parsing_syntax.label option) +let _menhir_action_173 i = (i : string) +let _menhir_action_174 i = (i : string) + +let _menhir_action_175 _endpos_expr_ _endpos_key_ _startpos_key_ expr key = + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos_key_ in + let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Map_expr_elem + { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + : Parsing_syntax.map_expr_elem) + +let _menhir_action_176 _1 = (_1 : Parsing_syntax.constant) + +let _menhir_action_177 _2 = + (Parsing_util.make_int ("-" ^ _2) : Parsing_syntax.constant) -let _menhir_action_120 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ e mat = +let _menhir_action_178 _2 = + (Parsing_syntax.Const_double ("-" ^ _2) : Parsing_syntax.constant) + +let _menhir_action_179 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ e mat = let e = e in let _endpos_e_, _startpos_e_ = (_endpos__3_inlined1_, _startpos__1_) in let _endpos = _endpos__3_ in @@ -10484,7 +7385,7 @@ let _menhir_action_120 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ e mat = (Pexpr_match { loc_ = i _sloc; expr = e; cases = mat; match_loc_ = i _loc_e_ } : Parsing_syntax.expr) -let _menhir_action_121 _endpos__2_ _endpos__3_ _startpos__1_ e = +let _menhir_action_180 _endpos__2_ _endpos__3_ _startpos__1_ e = let e = e in let _endpos_e_, _startpos_e_ = (_endpos__3_, _startpos__1_) in let _endpos = _endpos__2_ in @@ -10495,158 +7396,62 @@ let _menhir_action_121 _endpos__2_ _endpos__3_ _startpos__1_ e = { loc_ = i _sloc; expr = e; cases = []; match_loc_ = i _loc_e_ } : Parsing_syntax.expr) -let _menhir_action_122 fps : Parsing_syntax.field_pat list * bool = (fps, true) - -let _menhir_action_123 fps = - let _3 = None in - ((fps, false) : Parsing_syntax.field_pat list * bool) - -let _menhir_action_124 fps x = - let _3 = Some x in - ((fps, false) : Parsing_syntax.field_pat list * bool) +let _menhir_action_181 body guard pats = + (({ patterns = pats; guard; body } : Parsing_syntax.multi_arg_case) + : Parsing_syntax.multi_arg_case) -let _menhir_action_125 xs : string list = List.rev xs +let _menhir_action_182 _1 = + (Parsing_syntax.Multiline_string _1 : Parsing_syntax.multiline_string_elem) -let _menhir_action_126 xs : Parsing_syntax.multiline_string_elem list = - List.rev xs +let _menhir_action_183 _1 = + (Parsing_syntax.Multiline_interp (make_interps _1) + : Parsing_syntax.multiline_string_elem) -let _menhir_action_127 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.argument list) +let _menhir_action_184 fps = + ((fps, true) : Parsing_syntax.field_pat list * bool) -let _menhir_action_128 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.argument list) +let _menhir_action_185 fps = + ((fps, false) : Parsing_syntax.field_pat list * bool) -let _menhir_action_129 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.constr_param list) +let _menhir_action_186 xs = (List.rev xs : string list) +let _menhir_action_187 xs = (List.rev xs : Parsing_syntax.attribute list) -let _menhir_action_130 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.constr_param list) +let _menhir_action_188 xs = + (List.rev xs : Parsing_syntax.multiline_string_elem list) -let _menhir_action_131 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.deriving_directive list) +let _menhir_action_189 xs = (List.rev xs : Parsing_syntax.argument list) +let _menhir_action_190 xs = (List.rev xs : Parsing_syntax.array_pattern list) +let _menhir_action_191 xs = (List.rev xs : Parsing_syntax.constr_param list) -let _menhir_action_132 x xs = - let _2 = Some x in +let _menhir_action_192 xs = (List.rev xs : Parsing_syntax.deriving_directive list) -let _menhir_action_133 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.expr list) - -let _menhir_action_134 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.expr list) - -let _menhir_action_135 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.field_pat list) - -let _menhir_action_136 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.field_pat list) - -let _menhir_action_137 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.binder option list) - -let _menhir_action_138 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.binder option list) - -let _menhir_action_139 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.tvar_binder list) - -let _menhir_action_140 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.tvar_binder list) - -let _menhir_action_141 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.type_decl_binder list) - -let _menhir_action_142 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.type_decl_binder list) - -let _menhir_action_143 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.map_pat_elem list) - -let _menhir_action_144 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.map_pat_elem list) - -let _menhir_action_145 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.map_expr_elem list) - -let _menhir_action_146 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.map_expr_elem list) - -let _menhir_action_147 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.parameters) - -let _menhir_action_148 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.parameters) - -let _menhir_action_149 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.pattern list) - -let _menhir_action_150 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.pattern list) - -let _menhir_action_151 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.field_def list) - -let _menhir_action_152 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.field_def list) - -let _menhir_action_153 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.spreadable_elem list) - -let _menhir_action_154 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.spreadable_elem list) - -let _menhir_action_155 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.trait_method_param list) - -let _menhir_action_156 x xs = - let _2 = Some x in +let _menhir_action_193 xs = (List.rev xs : Parsing_syntax.expr list) +let _menhir_action_194 xs = (List.rev xs : Parsing_syntax.field_pat list) +let _menhir_action_195 xs = (List.rev xs : Parsing_syntax.binder option list) +let _menhir_action_196 xs = (List.rev xs : Parsing_syntax.tvar_binder list) +let _menhir_action_197 xs = (List.rev xs : Parsing_syntax.type_decl_binder list) +let _menhir_action_198 xs = (List.rev xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_199 xs = (List.rev xs : Parsing_syntax.map_expr_elem list) +let _menhir_action_200 xs = (List.rev xs : Parsing_syntax.parameters) +let _menhir_action_201 xs = (List.rev xs : Parsing_syntax.pattern list) +let _menhir_action_202 xs = (List.rev xs : Parsing_syntax.field_def list) +let _menhir_action_203 xs = (List.rev xs : Parsing_syntax.spreadable_elem list) + +let _menhir_action_204 xs = (List.rev xs : Parsing_syntax.trait_method_param list) -let _menhir_action_157 xs = - let _2 = None in - (List.rev xs : Parsing_syntax.typ list) - -let _menhir_action_158 x xs = - let _2 = Some x in - (List.rev xs : Parsing_syntax.typ list) +let _menhir_action_205 xs = (List.rev xs : Parsing_syntax.typ list) -let _menhir_action_159 xs : (Parsing_syntax.binder * Parsing_syntax.expr) list = - List.rev xs +let _menhir_action_206 xs = + (List.rev xs : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_160 xs : (Parsing_syntax.binder * Parsing_syntax.expr) list = - List.rev xs +let _menhir_action_207 xs = + (List.rev xs : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_161 xs : Parsing_syntax.expr list = List.rev xs +let _menhir_action_208 xs = (List.rev xs : Parsing_syntax.expr list) -let _menhir_action_162 _endpos_name_ _startpos_name_ e name = +let _menhir_action_209 _endpos_name_ _startpos_name_ e name = let x = let b = let _endpos = _endpos_name_ in @@ -10658,7 +7463,7 @@ let _menhir_action_162 _endpos_name_ _startpos_name_ e name = in ([ x ] : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_163 _endpos_name_ _startpos_name_ e name xs = +let _menhir_action_210 _endpos_name_ _startpos_name_ e name xs = let x = let b = let _endpos = _endpos_name_ in @@ -10670,7 +7475,7 @@ let _menhir_action_163 _endpos_name_ _startpos_name_ e name xs = in (x :: xs : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_164 _endpos_name_ _startpos_name_ e name = +let _menhir_action_211 _endpos_name_ _startpos_name_ e name = let x = let b = let _endpos = _endpos_name_ in @@ -10682,7 +7487,7 @@ let _menhir_action_164 _endpos_name_ _startpos_name_ e name = in ([ x ] : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_165 _endpos_name_ _startpos_name_ e name xs = +let _menhir_action_212 _endpos_name_ _startpos_name_ e name xs = let x = let b = let _endpos = _endpos_name_ in @@ -10694,127 +7499,40 @@ let _menhir_action_165 _endpos_name_ _startpos_name_ e name xs = in (x :: xs : (Parsing_syntax.binder * Parsing_syntax.expr) list) -let _menhir_action_166 x : Parsing_syntax.argument list = [ x ] -let _menhir_action_167 x xs : Parsing_syntax.argument list = x :: xs -let _menhir_action_168 x : Parsing_syntax.constr_param list = [ x ] -let _menhir_action_169 x xs : Parsing_syntax.constr_param list = x :: xs -let _menhir_action_170 x : Parsing_syntax.deriving_directive list = [ x ] -let _menhir_action_171 x xs : Parsing_syntax.deriving_directive list = x :: xs -let _menhir_action_172 x : Parsing_syntax.expr list = [ x ] -let _menhir_action_173 x xs : Parsing_syntax.expr list = x :: xs -let _menhir_action_174 x : Parsing_syntax.field_pat list = [ x ] -let _menhir_action_175 x xs : Parsing_syntax.field_pat list = x :: xs -let _menhir_action_176 x : Parsing_syntax.binder option list = [ x ] -let _menhir_action_177 x xs : Parsing_syntax.binder option list = x :: xs - -let _menhir_action_178 _endpos_name_ _startpos_name_ name = - let x = - let _1 = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = name; tvar_constraints = []; loc_ = i _loc } - in - _1 - in - ([ x ] : Parsing_syntax.tvar_binder list) - -let _menhir_action_179 _endpos_name_ _startpos_name_ constraints name = - let x = - let _1 = - let _loc_name_ = (_startpos_name_, _endpos_name_) in - { - Parsing_syntax.tvar_name = name; - tvar_constraints = constraints; - loc_ = i _loc_name_; - } - in - _1 - in +let _menhir_action_213 x = ([ x ] : Parsing_syntax.argument list) +let _menhir_action_214 x xs = (x :: xs : Parsing_syntax.argument list) +let _menhir_action_215 x = ([ x ] : Parsing_syntax.array_pattern list) +let _menhir_action_216 x xs = (x :: xs : Parsing_syntax.array_pattern list) +let _menhir_action_217 x = ([ x ] : Parsing_syntax.constr_param list) +let _menhir_action_218 x xs = (x :: xs : Parsing_syntax.constr_param list) +let _menhir_action_219 x = ([ x ] : Parsing_syntax.deriving_directive list) +let _menhir_action_220 x xs = (x :: xs : Parsing_syntax.deriving_directive list) +let _menhir_action_221 x = ([ x ] : Parsing_syntax.expr list) +let _menhir_action_222 x xs = (x :: xs : Parsing_syntax.expr list) +let _menhir_action_223 x = ([ x ] : Parsing_syntax.field_pat list) +let _menhir_action_224 x xs = (x :: xs : Parsing_syntax.field_pat list) +let _menhir_action_225 x = ([ x ] : Parsing_syntax.binder option list) +let _menhir_action_226 x xs = (x :: xs : Parsing_syntax.binder option list) + +let _menhir_action_227 _1 = + let x = _1 in ([ x ] : Parsing_syntax.tvar_binder list) -let _menhir_action_180 _endpos_name_ _startpos_name_ name xs = - let x = - let _1 = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = name; tvar_constraints = []; loc_ = i _loc } - in - _1 - in - (x :: xs : Parsing_syntax.tvar_binder list) - -let _menhir_action_181 _endpos_name_ _startpos_name_ constraints name xs = - let x = - let _1 = - let _loc_name_ = (_startpos_name_, _endpos_name_) in - { - Parsing_syntax.tvar_name = name; - tvar_constraints = constraints; - loc_ = i _loc_name_; - } - in - _1 - in +let _menhir_action_228 _1 xs = + let x = _1 in (x :: xs : Parsing_syntax.tvar_binder list) -let _menhir_action_182 _endpos_name_ _startpos_name_ name = - let x = - let _1 = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = Some name; loc_ = i _loc } - in - _1 - in - ([ x ] : Parsing_syntax.type_decl_binder list) - -let _menhir_action_183 _endpos__1_ _startpos__1_ = - let x = - let _1 = - let _endpos = _endpos__1_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = None; loc_ = i _loc } - in - _1 - in +let _menhir_action_229 _1 = + let x = _1 in ([ x ] : Parsing_syntax.type_decl_binder list) -let _menhir_action_184 _endpos_name_ _startpos_name_ name xs = - let x = - let _1 = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = Some name; loc_ = i _loc } - in - _1 - in - (x :: xs : Parsing_syntax.type_decl_binder list) - -let _menhir_action_185 _endpos__1_ _startpos__1_ xs = - let x = - let _1 = - let _endpos = _endpos__1_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.tvar_name = None; loc_ = i _loc } - in - _1 - in +let _menhir_action_230 _1 xs = + let x = _1 in (x :: xs : Parsing_syntax.type_decl_binder list) -let _menhir_action_186 _endpos__1_ _endpos_pat_ _startpos__1_ pat = +let _menhir_action_231 _endpos_key_ _endpos_pat_ _startpos_key_ key pat question + = let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in let _endpos = _endpos_pat_ in let _symbolstartpos = _startpos_key_ in let _loc_key_ = (_startpos_key_, _endpos_key_) in @@ -10823,21 +7541,16 @@ let _menhir_action_186 _endpos__1_ _endpos_pat_ _startpos__1_ pat = { key; pat; - match_absent = Option.is_some question; + match_absent = (match question with Some _ -> true | _ -> false); key_loc_ = i _loc_key_; loc_ = i _sloc; } in ([ x ] : Parsing_syntax.map_pat_elem list) -let _menhir_action_187 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = +let _menhir_action_232 _endpos_key_ _endpos_pat_ _startpos_key_ key pat question + xs = let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in let _endpos = _endpos_pat_ in let _symbolstartpos = _startpos_key_ in let _loc_key_ = (_startpos_key_, _endpos_key_) in @@ -10846,178475 +7559,38827 @@ let _menhir_action_187 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = { key; pat; - match_absent = Option.is_some question; + match_absent = (match question with Some _ -> true | _ -> false); key_loc_ = i _loc_key_; loc_ = i _sloc; } in - ([ x ] : Parsing_syntax.map_pat_elem list) + (x :: xs : Parsing_syntax.map_pat_elem list) -let _menhir_action_188 _endpos__1_ _endpos_pat_ _startpos__1_ pat = +let _menhir_action_233 x = ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_234 x xs = (x :: xs : Parsing_syntax.map_expr_elem list) +let _menhir_action_235 x = ([ x ] : Parsing_syntax.parameter list) +let _menhir_action_236 x xs = (x :: xs : Parsing_syntax.parameter list) +let _menhir_action_237 x = ([ x ] : Parsing_syntax.pattern list) +let _menhir_action_238 x xs = (x :: xs : Parsing_syntax.pattern list) +let _menhir_action_239 x = ([ x ] : Parsing_syntax.field_def list) +let _menhir_action_240 x xs = (x :: xs : Parsing_syntax.field_def list) +let _menhir_action_241 x = ([ x ] : Parsing_syntax.spreadable_elem list) +let _menhir_action_242 x xs = (x :: xs : Parsing_syntax.spreadable_elem list) +let _menhir_action_243 x = ([ x ] : Parsing_syntax.trait_method_param list) +let _menhir_action_244 x xs = (x :: xs : Parsing_syntax.trait_method_param list) +let _menhir_action_245 x = ([ x ] : Parsing_syntax.typ list) +let _menhir_action_246 x xs = (x :: xs : Parsing_syntax.typ list) +let _menhir_action_247 xs = (List.rev xs : Parsing_syntax.field_pat list) +let _menhir_action_248 xs = (List.rev xs : Parsing_syntax.map_pat_elem list) + +let _menhir_action_249 comma xs = + ((List.rev xs, match comma with Some _ -> true | _ -> false) + : Parsing_syntax.field_def list * bool) + +let _menhir_action_250 x = ([ x ] : string list) +let _menhir_action_251 x xs = (x :: xs : string list) + +let _menhir_action_252 _1 _endpos__1_ _startpos__1_ = let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + make_attribute ~loc_:(i _sloc) _1 in - ([ x ] : Parsing_syntax.map_pat_elem list) + ([ x ] : Parsing_syntax.attribute list) -let _menhir_action_189 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = +let _menhir_action_253 _1 _endpos__1_ _startpos__1_ xs = let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + make_attribute ~loc_:(i _sloc) _1 in - ([ x ] : Parsing_syntax.map_pat_elem list) + (x :: xs : Parsing_syntax.attribute list) -let _menhir_action_190 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_254 x = ([ x ] : Parsing_syntax.multiline_string_elem list) + +let _menhir_action_255 x xs = + (x :: xs : Parsing_syntax.multiline_string_elem list) + +let _menhir_action_256 x = ([ x ] : Parsing_syntax.constr_decl list) +let _menhir_action_257 x xs = (x :: xs : Parsing_syntax.constr_decl list) +let _menhir_action_258 x = ([ x ] : Parsing_syntax.multi_arg_case list) +let _menhir_action_259 x xs = (x :: xs : Parsing_syntax.multi_arg_case list) +let _menhir_action_260 x = ([ x ] : Parsing_syntax.field_decl list) +let _menhir_action_261 x xs = (x :: xs : Parsing_syntax.field_decl list) +let _menhir_action_262 x = ([ x ] : Parsing_syntax.case list) +let _menhir_action_263 x xs = (x :: xs : Parsing_syntax.case list) +let _menhir_action_264 x = ([ x ] : Parsing_compact.semi_expr_prop list) +let _menhir_action_265 x xs = (x :: xs : Parsing_compact.semi_expr_prop list) +let _menhir_action_266 x = ([ x ] : Parsing_syntax.impl list) +let _menhir_action_267 x xs = (x :: xs : Parsing_syntax.impl list) +let _menhir_action_268 x = ([ x ] : Parsing_syntax.trait_method_decl list) +let _menhir_action_269 x xs = (x :: xs : Parsing_syntax.trait_method_decl list) +let _menhir_action_270 _1 = (List.rev _1 : Parsing_syntax.constr_decl list) +let _menhir_action_271 _1 = (List.rev _1 : Parsing_syntax.multi_arg_case list) +let _menhir_action_272 _1 = (List.rev _1 : Parsing_syntax.field_decl list) +let _menhir_action_273 _1 = (List.rev _1 : Parsing_syntax.case list) +let _menhir_action_274 _1 = (List.rev _1 : Parsing_syntax.impls) + +let _menhir_action_275 _1 = + (List.rev _1 : Parsing_syntax.trait_method_decl list) + +let _menhir_action_276 xs = (xs : Parsing_syntax.constr_decl list) +let _menhir_action_277 xs = (xs : Parsing_syntax.multi_arg_case list) +let _menhir_action_278 xs = (xs : Parsing_syntax.field_decl list) +let _menhir_action_279 xs = (xs : Parsing_syntax.case list) +let _menhir_action_280 xs = (xs : Parsing_compact.semi_expr_prop list) +let _menhir_action_281 xs = (xs : Parsing_syntax.impl list) +let _menhir_action_282 xs = (xs : Parsing_syntax.trait_method_decl list) + +let _menhir_action_283 _1 = + ((_1, true) : Parsing_syntax.map_pat_elem list * bool) + +let _menhir_action_284 _1 = + ((_1, false) : Parsing_syntax.map_pat_elem list * bool) + +let _menhir_action_285 semi xs = + ((xs, match semi with Some _ -> true | _ -> false) + : Parsing_compact.semi_expr_prop list * bool) + +let _menhir_action_286 () = (None : unit option) +let _menhir_action_287 x = (Some x : unit option) +let _menhir_action_288 () = (None : unit option) +let _menhir_action_289 x = (Some x : unit option) +let _menhir_action_290 () = (None : unit option) +let _menhir_action_291 x = (Some x : unit option) +let _menhir_action_292 () = (None : bool option) +let _menhir_action_293 x = (Some x : bool option) + +let _menhir_action_294 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_295 t = + let x = t in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_296 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_297 t = + let x = t in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_298 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_299 t = + let x = t in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) + +let _menhir_action_300 () = + (None : (Parsing_syntax.constr_pat_arg list * bool) option) + +let _menhir_action_301 t = + let x = t in + (Some x : (Parsing_syntax.constr_pat_arg list * bool) option) + +let _menhir_action_302 () = (None : Parsing_syntax.constr_param list option) + +let _menhir_action_303 ts = + let x = ts in + (Some x : Parsing_syntax.constr_param list option) + +let _menhir_action_304 () = (None : (string * Rloc.t) option) -let _menhir_action_191 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = +let _menhir_action_305 _endpos_tag_ _startpos_tag_ tag = let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + let _loc_tag_ = (_startpos_tag_, _endpos_tag_) in + (tag, i _loc_tag_) in - ([ x ] : Parsing_syntax.map_pat_elem list) + (Some x : (string * Rloc.t) option) -let _menhir_action_192 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_306 () = (None : Parsing_syntax.tvar_constraint list option) -let _menhir_action_193 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_307 _2 = + let x = _2 in + (Some x : Parsing_syntax.tvar_constraint list option) -let _menhir_action_194 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_308 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_195 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_309 _2 = + let x = _2 in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_196 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_util.make_int _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_310 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_197 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = - let _1 = Parsing_util.make_int _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_311 _2 = + let x = _2 in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_198 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_util.make_float _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_312 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_199 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = - let _1 = Parsing_util.make_float _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_313 t = + let x = t in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_200 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_314 () = + (None : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_201 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_315 t = + let x = t in + (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) -let _menhir_action_202 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = Parsing_util.make_int ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_316 () = (None : Parsing_syntax.expr option) -let _menhir_action_203 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = Parsing_util.make_int ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_317 e = + let x = e in + (Some x : Parsing_syntax.expr option) -let _menhir_action_204 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat = - let x = - let question = None in - let key = Parsing_syntax.Const_double ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_318 () = (None : Parsing_syntax.expr option) -let _menhir_action_205 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat x = - let x = - let question = Some x in - let key = Parsing_syntax.Const_double ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - ([ x ] : Parsing_syntax.map_pat_elem list) +let _menhir_action_319 e = + let x = e in + (Some x : Parsing_syntax.expr option) -let _menhir_action_206 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_320 () = (None : Parsing_syntax.type_decl_binder list option) -let _menhir_action_207 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_321 x = + let x = x in + (Some x : Parsing_syntax.type_decl_binder list option) + +let _menhir_action_322 () = (None : Parsing_syntax.typ list option) + +let _menhir_action_323 x = + let x = x in + (Some x : Parsing_syntax.typ list option) + +let _menhir_action_324 () = (None : Parsing_syntax.expr option) +let _menhir_action_325 x = (Some x : Parsing_syntax.expr option) +let _menhir_action_326 () = (None : Parsing_syntax.expr option) +let _menhir_action_327 x = (Some x : Parsing_syntax.expr option) +let _menhir_action_328 () = (None : Parsing_syntax.test_name) -let _menhir_action_208 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = +let _menhir_action_329 _1 _endpos__1_ _startpos__1_ = let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + { Rloc.v = _1; loc_ = i _sloc } in - (x :: xs : Parsing_syntax.map_pat_elem list) + (Some x : Parsing_syntax.test_name) -let _menhir_action_209 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_330 () = (None : Parsing_syntax.parameters option) +let _menhir_action_331 x = (Some x : Parsing_syntax.parameters option) +let _menhir_action_332 () = (None : Parsing_syntax.typ option) +let _menhir_action_333 x = (Some x : Parsing_syntax.typ option) +let _menhir_action_334 () = (None : Parsing_syntax.tvar_binder list option) +let _menhir_action_335 x = (Some x : Parsing_syntax.tvar_binder list option) + +let _menhir_action_336 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Some (i _sloc) : Rloc.t option) + +let _menhir_action_337 () = (None : Rloc.t option) +let _menhir_action_338 else_ = (Some else_ : Parsing_syntax.expr option) +let _menhir_action_339 () = (None : Parsing_syntax.expr option) + +let _menhir_action_340 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Some (i _sloc) : Rloc.t option) + +let _menhir_action_341 () = (None : Rloc.t option) + +let _menhir_action_342 params = + (match params with None -> [] | Some params -> params + : Parsing_syntax.typ list) + +let _menhir_action_343 params = + (match params with None -> [] | Some params -> params + : Parsing_syntax.tvar_binder list) + +let _menhir_action_344 params = + (match params with None -> [] | Some params -> params + : Parsing_syntax.type_decl_binder list) + +let _menhir_action_345 _endpos_pat2_ _startpos_pat1_ pat1 pat2 = + let _endpos = _endpos_pat2_ in + let _symbolstartpos = _startpos_pat1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_or { loc_ = i _sloc; pat1; pat2 } + : Parsing_syntax.pattern) + +let _menhir_action_346 _1 = (_1 : Parsing_syntax.pattern) + +let _menhir_action_347 _endpos__1_ _startpos__1_ = + let ty = + let _1 = None in + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc__1_ = (_startpos__1_, _endpos__1_) in + (Parsing_syntax.Discard_positional { ty; loc_ = i _loc__1_ } + : Parsing_syntax.parameter) -let _menhir_action_210 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 +let _menhir_action_348 _endpos__1_ _startpos__1_ t = + let ty = + let _1 = + let x = t in + Some x in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc__1_ = (_startpos__1_, _endpos__1_) in + (Parsing_syntax.Discard_positional { ty; loc_ = i _loc__1_ } + : Parsing_syntax.parameter) -let _menhir_action_211 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_349 _endpos_name_ _startpos_name_ name = + let param_annot = + let _1 = None in + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let param_binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + (Parsing_syntax.Positional { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_212 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 +let _menhir_action_350 _endpos_name_ _startpos_name_ name t = + let param_annot = + let _1 = + let x = t in + Some x in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let param_binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + (Parsing_syntax.Positional { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_213 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_351 _endpos_binder_name_ _startpos_binder_name_ binder_name = + let param_annot = + let _1 = None in + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } + in + Parsing_syntax.Labelled { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_214 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 +let _menhir_action_352 _endpos_binder_name_ _startpos_binder_name_ binder_name t + = + let param_annot = + let _1 = + let x = t in + Some x in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } + in + Parsing_syntax.Labelled { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_215 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_353 _endpos_binder_name_ _startpos_binder_name_ binder_name + default = + let param_annot = + let _1 = None in + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } + in + Parsing_syntax.Optional { default; binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_216 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_util.make_int _1 in - _1 +let _menhir_action_354 _endpos_binder_name_ _startpos_binder_name_ binder_name + default t = + let param_annot = + let _1 = + let x = t in + Some x in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } + in + Parsing_syntax.Optional { default; binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_217 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_util.make_int _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_355 _endpos_binder_name_ _startpos_binder_name_ binder_name = + let param_annot = + let _1 = None in + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = i _loc_binder_name_ } + in + Parsing_syntax.Question_optional { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_218 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_util.make_float _1 in - _1 +let _menhir_action_356 _endpos_binder_name_ _startpos_binder_name_ binder_name t + = + let param_annot = + let _1 = + let x = t in + Some x in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } + _1 in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (let param_binder : Parsing_syntax.binder = + { binder_name; loc_ = i _loc_binder_name_ } + in + Parsing_syntax.Question_optional { binder = param_binder; ty = param_annot } + : Parsing_syntax.parameter) -let _menhir_action_219 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_util.make_float _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_357 x = + let _1 = x in + (_1 : Parsing_syntax.parameters) -let _menhir_action_220 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs = - let x = - let question = None in - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } +let _menhir_action_358 _endpos_name_ _startpos_name_ _startpos_p_ name p = + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : Parsing_syntax.map_pat_elem list) + let _endpos_b_ = _endpos_name_ in + let _endpos = _endpos_b_ in + let _symbolstartpos = _startpos_p_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_alias ~loc_:(i _sloc) (p, b) : Parsing_syntax.pattern) -let _menhir_action_221 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs = - let x = - let question = Some x in - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_359 _1 = (_1 : Parsing_syntax.pattern) -let _menhir_action_222 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat xs = - let x = - let _endpos__2_, _2 = (_endpos__2_inlined1_, _2_inlined1) in - let question = None in - let key = Parsing_util.make_int ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_360 _endpos_rhs_ _startpos_lhs_ lhs rhs = + let _endpos = _endpos_rhs_ in + let _symbolstartpos = _startpos_lhs_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_pipe { lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_223 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat x xs = - let x = - let _endpos__2_, _2 = (_endpos__2_inlined1_, _2_inlined1) in - let question = Some x in - let key = Parsing_util.make_int ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_361 _1 = (_1 : Parsing_syntax.expr) -let _menhir_action_224 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat xs = - let x = - let _endpos__2_, _2 = (_endpos__2_inlined1_, _2_inlined1) in - let question = None in - let key = Parsing_syntax.Const_double ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_362 _endpos_trait_ _startpos_expr_ expr trait = + let _endpos = _endpos_trait_ in + let _symbolstartpos = _startpos_expr_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_as { expr; trait; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_225 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat x xs = - let x = - let _endpos__2_, _2 = (_endpos__2_inlined1_, _2_inlined1) in - let question = Some x in - let key = Parsing_syntax.Const_double ("-" ^ _2) in - let _endpos_key_, _startpos_key_ = (_endpos__2_, _startpos__1_) in - let _endpos = _endpos_pat_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_pat_elem - { - key; - pat; - match_absent = Option.is_some question; - key_loc_ = i _loc_key_; - loc_ = i _sloc; - } - in - (x :: xs : Parsing_syntax.map_pat_elem list) +let _menhir_action_363 _endpos_pat_ _startpos_expr_ expr pat = + let _endpos = _endpos_pat_ in + let _symbolstartpos = _startpos_expr_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_is { expr; pat; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_226 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_364 _1 = (_1 : Parsing_syntax.expr) -let _menhir_action_227 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } +let _menhir_action_365 _endpos_e_ _startpos__1_ e = + let op = + let _1 = "+" in + _1 in - ([ x ] : Parsing_syntax.map_expr_elem list) + let _startpos_op_ = _startpos__1_ in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_op_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_uplus ~loc_:(i _sloc) op e : Parsing_syntax.expr) -let _menhir_action_228 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } +let _menhir_action_366 _endpos_e_ _startpos__1_ e = + let op = + let _1 = "-" in + _1 in - ([ x ] : Parsing_syntax.map_expr_elem list) + let _startpos_op_ = _startpos__1_ in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_op_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_uminus ~loc_:(i _sloc) op e : Parsing_syntax.expr) -let _menhir_action_229 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_367 _1 = (_1 : Parsing_syntax.expr) +let _menhir_action_368 () = (None : string option) +let _menhir_action_369 () = (Some "readonly" : string option) +let _menhir_action_370 attr = (Some attr : string option) +let _menhir_action_371 i = (Lident i : Parsing_syntax.longident) -let _menhir_action_230 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_372 id ps = + (Ldot { pkg = ps; id } : Parsing_syntax.longident) -let _menhir_action_231 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_util.make_int _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_373 i = (Lident i : Parsing_syntax.longident) -let _menhir_action_232 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_util.make_float _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_374 id ps = + (Ldot { pkg = ps; id } : Parsing_syntax.longident) -let _menhir_action_233 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr = - let x = - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_375 i = (Lident i : Parsing_syntax.longident) -let _menhir_action_234 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr = - let x = - let key = - let _2 = _2_inlined1 in - Parsing_util.make_int ("-" ^ _2) - in - let _endpos_key_, _startpos_key_ = (_endpos__2_inlined1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_376 id ps = + (Ldot { pkg = ps; id } : Parsing_syntax.longident) -let _menhir_action_235 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr = - let x = - let key = - let _2 = _2_inlined1 in - Parsing_syntax.Const_double ("-" ^ _2) - in - let _endpos_key_, _startpos_key_ = (_endpos__2_inlined1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.map_expr_elem list) +let _menhir_action_377 id ps = + (Ldot { pkg = ps; id } : Parsing_syntax.longident) -let _menhir_action_236 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_bool true in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - (x :: xs : Parsing_syntax.map_expr_elem list) +let _menhir_action_378 _endpos__op_ _endpos_rhs_ _op _startpos__op_ + _startpos_lhs_ lhs rhs = + let _endpos = _endpos_rhs_ in + let _symbolstartpos = _startpos_lhs_ in + let _loc__op_ = (_startpos__op_, _endpos__op_) in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_infix + { + op = { var_name = Lident "..<"; loc_ = i _loc__op_ }; + lhs; + rhs; + loc_ = i _sloc; + } + : Parsing_syntax.expr) -let _menhir_action_237 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_bool false in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } - in - (x :: xs : Parsing_syntax.map_expr_elem list) +let _menhir_action_379 _endpos__op_ _endpos_rhs_ _op _startpos__op_ + _startpos_lhs_ lhs rhs = + let _endpos = _endpos_rhs_ in + let _symbolstartpos = _startpos_lhs_ in + let _loc__op_ = (_startpos__op_, _endpos__op_) in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_infix + { + op = { var_name = Lident "..="; loc_ = i _loc__op_ }; + lhs; + rhs; + loc_ = i _sloc; + } + : Parsing_syntax.expr) -let _menhir_action_238 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_byte _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } +let _menhir_action_380 _1 = (_1 : Parsing_syntax.expr) + +let _menhir_action_381 _endpos_rhs_ _startpos_lhs_ lhs rhs = + let _endpos = _endpos_rhs_ in + let _symbolstartpos = _startpos_lhs_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_range { lhs; rhs; inclusive = false; loc_ = i _sloc } + : Parsing_syntax.pattern) + +let _menhir_action_382 _endpos_rhs_ _startpos_lhs_ lhs rhs = + let _endpos = _endpos_rhs_ in + let _symbolstartpos = _startpos_lhs_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_range { lhs; rhs; inclusive = true; loc_ = i _sloc } + : Parsing_syntax.pattern) + +let _menhir_action_383 _1 = (_1 : Parsing_syntax.pattern) + +let _menhir_action_384 _endpos__0_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ + _startpos_mutflag_ _startpos_name_ mutflag name ty = + let field_vis = Parsing_syntax.Vis_default in + let _endpos_field_vis_, _startpos_field_vis_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_ty_ in + let _symbolstartpos = + if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ + else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ + else _startpos_name_ in - (x :: xs : Parsing_syntax.map_expr_elem list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + ({ + Parsing_syntax.field_name = + { Parsing_syntax.label = name; loc_ = i _loc_name_ }; + field_ty = ty; + field_mut = mutflag <> None; + field_vis; + field_loc_ = i _sloc; + } + : Parsing_syntax.field_decl) -let _menhir_action_239 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_bytes _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in +let _menhir_action_385 _endpos__1_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ + _startpos__1_ _startpos_mutflag_ _startpos_name_ mutflag name ty = + let field_vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let _endpos_field_vis_, _startpos_field_vis_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_ty_ in + let _symbolstartpos = + if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ + else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ + else _startpos_name_ in - (x :: xs : Parsing_syntax.map_expr_elem list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + ({ + Parsing_syntax.field_name = + { Parsing_syntax.label = name; loc_ = i _loc_name_ }; + field_ty = ty; + field_mut = mutflag <> None; + field_vis; + field_loc_ = i _sloc; + } + : Parsing_syntax.field_decl) -let _menhir_action_240 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_char _1 in - _1 - in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in +let _menhir_action_386 _endpos_attr_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ + _startpos__1_ _startpos_mutflag_ _startpos_name_ attr mutflag name ty = + let field_vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let _endpos_field_vis_, _startpos_field_vis_ = + (_endpos_attr_, _startpos__1_) + in + let _endpos = _endpos_ty_ in + let _symbolstartpos = + if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ + else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ + else _startpos_name_ in - (x :: xs : Parsing_syntax.map_expr_elem list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + ({ + Parsing_syntax.field_name = + { Parsing_syntax.label = name; loc_ = i _loc_name_ }; + field_ty = ty; + field_mut = mutflag <> None; + field_vis; + field_loc_ = i _sloc; + } + : Parsing_syntax.field_decl) -let _menhir_action_241 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_util.make_int _1 in - _1 +let _menhir_action_387 _endpos_name_ _startpos_name_ name x = + let l = + let l = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _endpos_l_, _startpos_l_ = (_endpos_name_, _startpos_name_) in + let _endpos = _endpos_l_ in + let _symbolstartpos = _startpos_l_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + make_field_def ~loc_:(i _sloc) l (label_to_expr ~loc_:(i _sloc) l) true in - (x :: xs : Parsing_syntax.map_expr_elem list) + (let fs, trailing = x in + let trailing = + if fs = [] || trailing then Parsing_syntax.Trailing_comma + else Parsing_syntax.Trailing_none + in + (l :: fs, trailing) + : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) -let _menhir_action_242 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_util.make_float _1 in - _1 +let _menhir_action_388 _endpos_e_ _endpos_name_ _startpos_name_ comma e name = + let l = + let l = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _startpos_l_ = _startpos_name_ in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_l_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + make_field_def ~loc_:(i _sloc) l e false in - (x :: xs : Parsing_syntax.map_expr_elem list) + (( [ l ], + match comma with + | Some _ -> Parsing_syntax.Trailing_comma + | _ -> Parsing_syntax.Trailing_none ) + : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) -let _menhir_action_243 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs = - let x = - let key = - let _1 = Parsing_syntax.Const_string _1 in - _1 +let _menhir_action_389 _endpos_e_ _endpos_name_ _startpos_name_ e name x = + let l = + let l = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } in - let _endpos_key_, _startpos_key_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _startpos_l_ = _startpos_name_ in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_l_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + make_field_def ~loc_:(i _sloc) l e false in - (x :: xs : Parsing_syntax.map_expr_elem list) + (match x with + | fs, true -> (l :: fs, Parsing_syntax.Trailing_comma) + | fs, false -> (l :: fs, Parsing_syntax.Trailing_none) + : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) -let _menhir_action_244 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr xs = - let x = - let key = - let _2 = _2_inlined1 in - Parsing_util.make_int ("-" ^ _2) +let _menhir_action_390 _endpos_e_ _endpos_name_ _startpos_name_ e name = + let _1 = + let l = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } in - let _endpos_key_, _startpos_key_ = (_endpos__2_inlined1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _startpos_l_ = _startpos_name_ in + let _endpos = _endpos_e_ in + let _symbolstartpos = _startpos_l_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + make_field_def ~loc_:(i _sloc) l e false in - (x :: xs : Parsing_syntax.map_expr_elem list) + (_1 : Parsing_syntax.field_def) -let _menhir_action_245 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr xs = - let x = - let key = - let _2 = _2_inlined1 in - Parsing_syntax.Const_double ("-" ^ _2) +let _menhir_action_391 _endpos_name_ _startpos_name_ name = + let _1 = + let l = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.label_name = name; loc_ = i _loc } in - let _endpos_key_, _startpos_key_ = (_endpos__2_inlined1_, _startpos__1_) in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_key_ in - let _loc_key_ = (_startpos_key_, _endpos_key_) in + let _endpos_l_, _startpos_l_ = (_endpos_name_, _startpos_name_) in + let _endpos = _endpos_l_ in + let _symbolstartpos = _startpos_l_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Map_expr_elem - { key; expr; key_loc_ = i _loc_key_; loc_ = i _sloc } + make_field_def ~loc_:(i _sloc) l (label_to_expr ~loc_:(i _sloc) l) true in - (x :: xs : Parsing_syntax.map_expr_elem list) + (_1 : Parsing_syntax.field_def) -let _menhir_action_246 x : Parsing_syntax.parameter list = [ x ] -let _menhir_action_247 x xs : Parsing_syntax.parameter list = x :: xs -let _menhir_action_248 x : Parsing_syntax.pattern list = [ x ] -let _menhir_action_249 x xs : Parsing_syntax.pattern list = x :: xs -let _menhir_action_250 x : Parsing_syntax.field_def list = [ x ] -let _menhir_action_251 x xs : Parsing_syntax.field_def list = x :: xs +let _menhir_action_392 t = + ((t, No_error_typ) : Parsing_syntax.typ * Parsing_syntax.error_typ) -let _menhir_action_252 expr = - let x = Parsing_syntax.Elem_regular expr in - ([ x ] : Parsing_syntax.spreadable_elem list) +let _menhir_action_393 _endpos__2_ _startpos__2_ t1 = + let _loc__2_ = (_startpos__2_, _endpos__2_) in + ((t1, Default_error_typ { loc_ = i _loc__2_ }) + : Parsing_syntax.typ * Parsing_syntax.error_typ) -let _menhir_action_253 _endpos_expr_ _startpos__1_ expr = - let x = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Elem_spread { expr; loc_ = i _sloc } - in - ([ x ] : Parsing_syntax.spreadable_elem list) +let _menhir_action_394 t1 t2 = + ((t1, Error_typ { ty = t2 }) : Parsing_syntax.typ * Parsing_syntax.error_typ) -let _menhir_action_254 expr xs = - let x = Parsing_syntax.Elem_regular expr in - (x :: xs : Parsing_syntax.spreadable_elem list) +let _menhir_action_395 x = ([ x ] : Parsing_syntax.tvar_constraint list) +let _menhir_action_396 x xs = (x :: xs : Parsing_syntax.tvar_constraint list) -let _menhir_action_255 _endpos_expr_ _startpos__1_ expr xs = - let x = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Elem_spread { expr; loc_ = i _sloc } - in - (x :: xs : Parsing_syntax.spreadable_elem list) +let _menhir_action_397 () = + (Parsing_syntax.Const_bool true : Parsing_syntax.constant) -let _menhir_action_256 x : Parsing_syntax.trait_method_param list = [ x ] -let _menhir_action_257 x xs : Parsing_syntax.trait_method_param list = x :: xs -let _menhir_action_258 x : Parsing_syntax.typ list = [ x ] -let _menhir_action_259 x xs : Parsing_syntax.typ list = x :: xs -let _menhir_action_260 xs : Parsing_syntax.field_pat list = List.rev xs -let _menhir_action_261 xs : Parsing_syntax.pattern list = List.rev xs +let _menhir_action_398 () = + (Parsing_syntax.Const_bool false : Parsing_syntax.constant) -let _menhir_action_262 xs = - let comma = None in - ((List.rev xs, Option.is_some comma) : Parsing_syntax.field_def list * bool) +let _menhir_action_399 _1 = + (Parsing_syntax.Const_byte _1 : Parsing_syntax.constant) -let _menhir_action_263 x xs = - let comma = Some x in - ((List.rev xs, Option.is_some comma) : Parsing_syntax.field_def list * bool) +let _menhir_action_400 _1 = + (Parsing_syntax.Const_bytes _1 : Parsing_syntax.constant) -let _menhir_action_264 x : string list = [ x ] -let _menhir_action_265 x xs : string list = x :: xs +let _menhir_action_401 _1 = + (Parsing_syntax.Const_char _1 : Parsing_syntax.constant) -let _menhir_action_266 _1 = - let x = Parsing_syntax.Multiline_string _1 in - ([ x ] : Parsing_syntax.multiline_string_elem list) +let _menhir_action_402 _1 = (Parsing_util.make_int _1 : Parsing_syntax.constant) -let _menhir_action_267 _1 = - let x = Parsing_syntax.Multiline_interp (make_interps _1) in - ([ x ] : Parsing_syntax.multiline_string_elem list) +let _menhir_action_403 _1 = + (Parsing_util.make_float _1 : Parsing_syntax.constant) -let _menhir_action_268 _1 xs = - let x = Parsing_syntax.Multiline_string _1 in - (x :: xs : Parsing_syntax.multiline_string_elem list) +let _menhir_action_404 _1 = + (Parsing_syntax.Const_string _1 : Parsing_syntax.constant) -let _menhir_action_269 _1 xs = - let x = Parsing_syntax.Multiline_interp (make_interps _1) in - (x :: xs : Parsing_syntax.multiline_string_elem list) +let _menhir_action_405 _endpos__3_ _startpos__1_ x = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (let fs, trailing = x in + make_Pexpr_record ~loc_:(i _sloc) ~trailing None fs + : Parsing_syntax.expr) -let _menhir_action_270 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_406 _endpos__5_ _startpos_type_name_ type_name x = + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_type_name_ in + let _sloc = (_symbolstartpos, _endpos) in + (let fs, trailing = x in + let trailing = + if trailing then Parsing_syntax.Trailing_comma + else Parsing_syntax.Trailing_none + in + make_Pexpr_record ~loc_:(i _sloc) ~trailing (Some type_name) fs + : Parsing_syntax.expr) -let _menhir_action_271 _endpos_x_ _startpos__1_ pats x = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe = + let type_name = None in + let _endpos_type_name_, _startpos_type_name_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__5_ in + let _symbolstartpos = + if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_record_update { type_name; record = oe; fields = []; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_272 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_408 _endpos__2_inlined1_ _endpos__5_ _startpos__2_ + _startpos_x_ oe x = + let type_name = + let x = x in + Some x in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_273 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) + let _endpos_type_name_, _startpos_type_name_ = + (_endpos__2_inlined1_, _startpos_x_) in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_274 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) + let _endpos = _endpos__5_ in + let _symbolstartpos = + if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_record_update { type_name; record = oe; fields = []; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_275 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs oe = + let type_name = None in + let _endpos_type_name_, _startpos_type_name_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__7_ in + let _symbolstartpos = + if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_276 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pats, body) +let _menhir_action_410 _endpos__2_inlined1_ _endpos__7_ _startpos__2_ + _startpos_x_ fs oe x = + let type_name = + let x = x in + Some x in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_277 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let _endpos_type_name_, _startpos_type_name_ = + (_endpos__2_inlined1_, _startpos_x_) in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_278 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let _endpos = _endpos__7_ in + let _symbolstartpos = + if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_279 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record = +let _menhir_action_411 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ + _startpos__1_ _startpos__1_inlined1_ = let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 + let _endpos__1_, _startpos__1_, _1 = + (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_280 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_281 _endpos_e_ _endpos_name_ _startpos_name_ e name pats = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + let ls, trailing = _1 in + (Parsing_compact.compact_rev ls (i _sloc), trailing) in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (match x with + | ( (Parsing_syntax.Pexpr_ident { id = { var_name = Lident str; loc_ }; _ } + as expr), + trailing ) -> + let label = { Parsing_syntax.label_name = str; loc_ } in + let field = make_field_def ~loc_:(i _sloc) label expr true in + let trailing = + if trailing then Parsing_syntax.Trailing_semi + else Parsing_syntax.Trailing_none + in + make_Pexpr_record ~loc_:(i _sloc) ~trailing None [ field ] + | expr, _ -> Pexpr_group { expr; group = Group_brace; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_282 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_412 _endpos__3_ _startpos__1_ elems = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_map { elems; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_283 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_413 _endpos__1_ _endpos_f_ _endpos_ps_ _startpos__1_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt = + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_f_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_function + { + loc_ = i _sloc; + func = + Lambda + { + parameters = ps; + has_error; + is_async; + params_loc_ = i _loc_ps_; + body = f; + return_type = ty_opt; + kind_ = Lambda; + }; + } + : Parsing_syntax.expr) -let _menhir_action_284 _endpos_e_ _startpos_obj_ e ind obj pats = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ _startpos__2_ + _startpos_ps_ f has_error ps ty_opt = + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_f_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_function + { + loc_ = i _sloc; + func = + Lambda + { + parameters = ps; + has_error; + is_async; + params_loc_ = i _loc_ps_; + body = f; + return_type = ty_opt; + kind_ = Lambda; + }; + } + : Parsing_syntax.expr) -let _menhir_action_285 _1 pats = - let x = - let body = _1 in - (pats, body) +let _menhir_action_415 _endpos__1_ _endpos__4_ _endpos_has_error_ _startpos__1_ + _startpos_has_error_ cases has_error = + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos__4_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos_has_error_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_function + { + loc_ = i _sloc; + func = + Match + { + cases; + has_error; + is_async; + loc_ = i _sloc; + fn_loc_ = i _loc_has_error_; + }; + } + : Parsing_syntax.expr) -let _menhir_action_286 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_416 _endpos__0_ _endpos__4_ _endpos_has_error_ + _startpos_has_error_ cases has_error = + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__4_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos_has_error_ in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_function + { + loc_ = i _sloc; + func = + Match + { + cases; + has_error; + is_async; + loc_ = i _sloc; + fn_loc_ = i _loc_has_error_; + }; + } + : Parsing_syntax.expr) -let _menhir_action_287 _endpos_x_ _startpos__1_ pats x xs = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_417 e = (e : Parsing_syntax.expr) -let _menhir_action_288 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_418 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_hole { loc_ = i _sloc; kind = Incomplete } : Parsing_syntax.expr) -let _menhir_action_289 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_419 _endpos_var_name_ _startpos_var_name_ var_name = + let _endpos = _endpos_var_name_ in + let _symbolstartpos = _startpos_var_name_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Pexpr_ident ~loc_:(i _sloc) { var_name; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_290 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_420 _endpos_c_ _startpos_c_ c = + let _endpos = _endpos_c_ in + let _symbolstartpos = _startpos_c_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_constr { loc_ = i _sloc; constr = c } + : Parsing_syntax.expr) -let _menhir_action_291 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_421 _endpos__5_ _endpos_func_ _startpos_func_ args func = + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_func_ in + let _loc_func_ = (_startpos_func_, _endpos_func_) in + let _sloc = (_symbolstartpos, _endpos) in + (let func : Parsing_syntax.expr = + let loc_ = i _loc_func_ in + Pexpr_ident { id = { var_name = Lident func; loc_ }; loc_ } + in + Pexpr_apply { func; args; loc_ = i _sloc; attr = Question } + : Parsing_syntax.expr) -let _menhir_action_292 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_422 _endpos__5_ _startpos_func_ args func = + let attr = Parsing_syntax.No_attr in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_func_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) -let _menhir_action_293 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_423 _endpos__5_ _startpos_func_ args func = + let attr = Parsing_syntax.Exclamation in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_func_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) -let _menhir_action_294 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_424 _endpos__5_ _startpos_func_ args func = + let attr = Parsing_syntax.Double_exclamation in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_func_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) -let _menhir_action_295 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_425 _endpos__5_ _startpos_func_ args func = + let attr = Parsing_syntax.Question in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos_func_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) -let _menhir_action_296 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_426 _endpos__4_ _startpos_array_ array index = + let _endpos = _endpos__4_ in + let _symbolstartpos = _startpos_array_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_array_get { array; index; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_297 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_427 _endpos__6_ _startpos__2_ _startpos_array_ array + end_index start_index = + let _endpos = _endpos__6_ in + let _symbolstartpos = _startpos_array_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_array_get_slice + { + array; + start_index; + end_index; + loc_ = i _sloc; + index_loc_ = i (_startpos__2_, _endpos__6_); + } + : Parsing_syntax.expr) -let _menhir_action_298 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_428 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.No_attr in + let _endpos = _endpos__6_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = false; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_299 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_429 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Exclamation in + let _endpos = _endpos__6_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = false; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_300 _endpos_e_ _startpos_obj_ e ind obj pats xs = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_430 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Double_exclamation in + let _endpos = _endpos__6_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = false; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_301 _1 pats xs = - let x = - let body = _1 in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_431 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Question in + let _endpos = _endpos__6_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = false; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_302 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_432 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.No_attr in + let _endpos = _endpos__7_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = true; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_303 _endpos_x_ _startpos__1_ pats x = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_433 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Exclamation in + let _endpos = _endpos__7_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = true; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_304 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_434 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Double_exclamation in + let _endpos = _endpos__7_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = true; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_305 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_435 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ + args meth self = + let attr = Parsing_syntax.Question in + let _endpos = _endpos__7_ in + let _symbolstartpos = _startpos_self_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_dot_apply + { self; method_name; args; return_self = true; attr; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_306 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_436 _endpos_name_ _startpos_name_ _startpos_record_ name + record = + let accessor = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + if name = "_" then Parsing_syntax.Newtype + else Parsing_syntax.Label { label_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos_accessor_ = _endpos_name_ in + let _endpos = _endpos_accessor_ in + let _symbolstartpos = _startpos_record_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_field { record; accessor; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_307 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_437 _endpos_index_ _startpos_index_ _startpos_record_ index + record = + let accessor = + let _endpos = _endpos_index_ in + let _startpos = _startpos_index_ in + let _loc = (_startpos, _endpos) in + Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos_accessor_ = _endpos_index_ in + let _endpos = _endpos_accessor_ in + let _symbolstartpos = _startpos_record_ in + let _sloc = (_symbolstartpos, _endpos) in + (Pexpr_field { record; accessor; loc_ = i _sloc } : Parsing_syntax.expr) -let _menhir_action_308 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_438 _endpos_meth_ _startpos_meth_ _startpos_type_name_ meth + type_name = + let _endpos = _endpos_meth_ in + let _symbolstartpos = _startpos_type_name_ in + let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in + let _sloc = (_symbolstartpos, _endpos) in + (let method_name : Parsing_syntax.label = + { label_name = meth; loc_ = i _loc_meth_ } + in + Pexpr_method { type_name; method_name; loc_ = i _sloc } + : Parsing_syntax.expr) -let _menhir_action_309 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_439 _endpos__3_ _startpos__1_ bs = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (match bs with + | [] -> Pexpr_unit { loc_ = i _sloc; faked = false } + | expr :: [] -> Pexpr_group { expr; group = Group_paren; loc_ = i _sloc } + | _ -> make_Pexpr_tuple ~loc_:(i _sloc) bs + : Parsing_syntax.expr) -let _menhir_action_310 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_440 _endpos__4_ _startpos__1_ expr t = + let ty = t in + let _endpos = _endpos__4_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Pexpr_constraint { loc_ = i _sloc; expr; ty } + : Parsing_syntax.expr) -let _menhir_action_311 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_441 _endpos__3_ _startpos__1_ es = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Pexpr_array ~loc_:(i _sloc) es : Parsing_syntax.expr) -let _menhir_action_312 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_442 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_bool true) + : Parsing_syntax.pattern) -let _menhir_action_313 _endpos_e_ _endpos_name_ _startpos_name_ e name pats = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_443 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_bool false) + : Parsing_syntax.pattern) -let _menhir_action_314 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_444 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_char _1) : Parsing_syntax.pattern) -let _menhir_action_315 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_445 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Parsing_util.make_int _1) + : Parsing_syntax.pattern) -let _menhir_action_316 _endpos_e_ _startpos_obj_ e ind obj pats = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_446 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_byte _1) : Parsing_syntax.pattern) -let _menhir_action_317 _1 pats = - let x = - let body = _1 in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_447 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_double _1) + : Parsing_syntax.pattern) -let _menhir_action_318 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_448 _2 _endpos__2_ _startpos__1_ = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Parsing_util.make_int ("-" ^ _2)) + : Parsing_syntax.pattern) -let _menhir_action_319 _endpos_x_ _startpos__1_ pats x xs = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_449 _2 _endpos__2_ _startpos__1_ = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_double ("-" ^ _2)) + : Parsing_syntax.pattern) -let _menhir_action_320 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_321 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_450 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_string _1) + : Parsing_syntax.pattern) -let _menhir_action_322 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_451 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_constant ~loc_:(i _sloc) (Const_bytes _1) : Parsing_syntax.pattern) -let _menhir_action_323 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_452 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Ppat_any { loc_ = i _sloc } : Parsing_syntax.pattern) -let _menhir_action_324 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pats, body) +let _menhir_action_453 _endpos_name_ _startpos_name_ name = + let b = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + (Ppat_var b : Parsing_syntax.pattern) -let _menhir_action_325 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_454 _endpos_ps_ _startpos_constr_ constr ps = + let _endpos = _endpos_ps_ in + let _symbolstartpos = _startpos_constr_ in + let _sloc = (_symbolstartpos, _endpos) in + (let args, is_open = + match ps with + | None -> (None, false) + | Some (args, is_open) -> (Some args, is_open) + in + make_Ppat_constr ~loc_:(i _sloc) (constr, args, is_open) + : Parsing_syntax.pattern) -let _menhir_action_326 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_455 _2 = (_2 : Parsing_syntax.pattern) -let _menhir_action_327 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_456 _endpos__5_ _startpos__1_ p ps = + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ppat_tuple ~loc_:(i _sloc) (p :: ps) : Parsing_syntax.pattern) -let _menhir_action_328 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_457 _endpos__4_ _startpos__1_ pat t = + let ty = t in + let _endpos = _endpos__4_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_constraint { loc_ = i _sloc; pat; ty } + : Parsing_syntax.pattern) -let _menhir_action_329 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_458 _endpos__3_ _startpos__1_ pats = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Ppat_array { loc_ = i _sloc; pats } : Parsing_syntax.pattern) -let _menhir_action_330 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_459 _endpos__2_ _startpos__1_ = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_record { fields = []; is_closed = true; loc_ = i _sloc } + : Parsing_syntax.pattern) -let _menhir_action_331 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_460 _endpos__4_ _startpos__1_ = + let _endpos = _endpos__4_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ppat_record { fields = []; is_closed = false; loc_ = i _sloc } + : Parsing_syntax.pattern) -let _menhir_action_332 _endpos_e_ _startpos_obj_ e ind obj pats xs = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_461 _endpos__3_ _startpos__1_ p = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (let fps, is_closed = p in + Parsing_syntax.Ppat_record { fields = fps; is_closed; loc_ = i _sloc } + : Parsing_syntax.pattern) -let _menhir_action_333 _1 pats xs = - let x = - let body = _1 in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_462 _endpos__3_ _startpos__1_ elems = + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (let elems, is_closed = elems in + Parsing_syntax.Ppat_map { elems; is_closed; loc_ = i _sloc } + : Parsing_syntax.pattern) -let _menhir_action_334 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_463 body guard pat = + (({ pattern = pat; guard; body } : Parsing_syntax.case) : Parsing_syntax.case) -let _menhir_action_335 _endpos_x_ _startpos__1_ pats x = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_464 cases = (cases : Parsing_syntax.case list) -let _menhir_action_336 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_465 expr = + (Parsing_syntax.Elem_regular expr : Parsing_syntax.spreadable_elem) -let _menhir_action_337 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_466 _endpos_expr_ _startpos__1_ expr = + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Elem_spread { expr; loc_ = i _sloc } + : Parsing_syntax.spreadable_elem) -let _menhir_action_338 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_467 _endpos_expr_ _startpos__1_ expr pat = + let ty_opt = + let _1 = None in + _1 in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (let pat = + match ty_opt with + | None -> pat + | Some ty -> + Parsing_syntax.Ppat_constraint + { + pat; + ty; + loc_ = + Rloc.merge + (Parsing_syntax.loc_of_pattern pat) + (Parsing_syntax.loc_of_type_expression ty); + } + in + Stmt_let { pat; expr; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_339 _endpos_expr_ _startpos__1_ expr pats = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } +let _menhir_action_468 _endpos_expr_ _startpos__1_ expr pat t = + let ty_opt = + let _1 = + let x = t in + Some x in - (pats, body) + _1 in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (let pat = + match ty_opt with + | None -> pat + | Some ty -> + Parsing_syntax.Ppat_constraint + { + pat; + ty; + loc_ = + Rloc.merge + (Parsing_syntax.loc_of_pattern pat) + (Parsing_syntax.loc_of_type_expression ty); + } + in + Stmt_let { pat; expr; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_340 _endpos__1_ _startpos__1_ pats = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pats, body) +let _menhir_action_469 _endpos_expr_ _endpos_name_ _startpos__1_ _startpos_name_ + expr name = + let ty = + let _1 = None in + _1 in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_341 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Stmt_letmut { binder; ty_opt = ty; expr; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_342 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 +let _menhir_action_470 _endpos_expr_ _endpos_name_ _startpos__1_ _startpos_name_ + expr name t = + let ty = + let _1 = + let x = t in + Some x in - (pats, body) + _1 in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_343 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Stmt_letmut { binder; ty_opt = ty; expr; loc = i _sloc } + : Parsing_compact.semi_expr_prop) -let _menhir_action_344 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_471 _endpos__1_ _endpos_block_ _endpos_name_ _endpos_params_ + _startpos__1_ _startpos__2_ _startpos_name_ _startpos_params_ block + has_error name params ty_opt = + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_345 _endpos_e_ _endpos_name_ _startpos_name_ e name pats = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_block_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_params_ = (_startpos_params_, _endpos_params_) in + let _sloc = (_symbolstartpos, _endpos) in + (let locb = i _sloc in + let func : Parsing_syntax.func = + Lambda + { + parameters = params; + params_loc_ = i _loc_params_; + body = block; + return_type = ty_opt; + kind_ = Lambda; + has_error; + is_async; + } + in + Parsing_compact.Stmt_func { binder; func; loc = locb } + : Parsing_compact.semi_expr_prop) -let _menhir_action_346 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_472 _endpos__0_ _endpos_block_ _endpos_name_ _endpos_params_ + _startpos__2_ _startpos_name_ _startpos_params_ block has_error name params + ty_opt = + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_347 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_block_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_params_ = (_startpos_params_, _endpos_params_) in + let _sloc = (_symbolstartpos, _endpos) in + (let locb = i _sloc in + let func : Parsing_syntax.func = + Lambda + { + parameters = params; + params_loc_ = i _loc_params_; + body = block; + return_type = ty_opt; + kind_ = Lambda; + has_error; + is_async; + } + in + Parsing_compact.Stmt_func { binder; func; loc = locb } + : Parsing_compact.semi_expr_prop) -let _menhir_action_348 _endpos_e_ _startpos_obj_ e ind obj pats = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_473 _endpos__1_ _endpos__4_ _endpos_binder_ _startpos__1_ + _startpos_binder_ binder cases = + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos__4_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos_binder_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder, has_error = binder in + Parsing_compact.Stmt_func + { + binder; + func = + Match + { + cases; + has_error; + is_async; + loc_ = i _sloc; + fn_loc_ = i _loc_binder_; + }; + loc = i _sloc; + } + : Parsing_compact.semi_expr_prop) -let _menhir_action_349 _1 pats = - let x = - let body = _1 in - (pats, body) +let _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ _startpos_binder_ + binder cases = + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__4_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos_binder_ in - ([ x ] : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder, has_error = binder in + Parsing_compact.Stmt_func + { + binder; + func = + Match + { + cases; + has_error; + is_async; + loc_ = i _sloc; + fn_loc_ = i _loc_binder_; + }; + loc = i _sloc; + } + : Parsing_compact.semi_expr_prop) -let _menhir_action_350 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_475 _1 = (_1 : Parsing_compact.semi_expr_prop) -let _menhir_action_351 _endpos_x_ _startpos__1_ pats x xs = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_476 _1 = + (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) -let _menhir_action_352 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_477 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_353 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_478 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ + params tycon = + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_354 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pats, body) +let _menhir_action_479 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_355 _endpos_expr_ _startpos__1_ expr pats xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_480 _1 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_356 _endpos__1_ _startpos__1_ pats xs = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } +let _menhir_action_481 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (pats, body) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_357 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_482 _1 _endpos_attr_ _endpos_tycon_ _startpos__1_inlined1_ + _startpos_tycon_ attr params tycon = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_358 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_483 _1 = (_1 : Parsing_syntax.impls) -let _menhir_action_359 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) +let _menhir_action_484 _endpos_deriving__ _startpos_type_header_ deriving_ + type_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_type_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_, params = type_header in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_abstract; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_360 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pats xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_485 _endpos__0_ _endpos_deriving__ _endpos_tycon_ + _startpos__3_ _startpos_tycon_ deriving_ params tycon = + let type_vis = Parsing_syntax.Vis_default in + let _endpos_type_vis_, _startpos_type_vis_ = (_endpos__0_, _endpos__0_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_361 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_486 _endpos__0_ _endpos__1_ _endpos_deriving__ _endpos_tycon_ + _startpos__1_ _startpos__3_ _startpos_tycon_ deriving_ params tycon = + let type_vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_362 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) + let _endpos_type_vis_, _startpos_type_vis_ = (_endpos__1_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_363 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) - in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_364 _endpos_e_ _startpos_obj_ e ind obj pats xs = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pats, body) +let _menhir_action_487 _endpos__0_ _endpos_attr_ _endpos_deriving__ + _endpos_tycon_ _startpos__1_ _startpos__3_ _startpos_tycon_ attr deriving_ + params tycon = + let type_vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_365 _1 pats xs = - let x = - let body = _1 in - (pats, body) + let _endpos_type_vis_, _startpos_type_vis_ = (_endpos_attr_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_366 _endpos__1_ _startpos__1_ pat = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pat, body) +let _menhir_action_488 _1 _endpos__1_ _endpos_deriving__ _endpos_tycon_ + _startpos__1_ _startpos__3_ _startpos_tycon_ deriving_ params tycon = + let type_vis = Parsing_syntax.Vis_default in + let _endpos_type_vis_, _startpos_type_vis_ = (_endpos__1_, _endpos__1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_367 _endpos_x_ _startpos__1_ pat x = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } +let _menhir_action_489 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_deriving__ + _endpos_tycon_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_tycon_ deriving_ params tycon = + let type_vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (pat, body) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_368 _endpos__1_ _startpos__1_ pat = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pat, body) + let _endpos_type_vis_, _startpos_type_vis_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_369 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pat = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pat, body) + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_370 _endpos_expr_ _startpos__1_ expr pat = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pat, body) +let _menhir_action_490 _1 _endpos__1_ _endpos_attr_ _endpos_deriving__ + _endpos_tycon_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_tycon_ attr deriving_ params tycon = + let type_vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_371 _endpos_expr_ _startpos__1_ expr pat = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pat, body) + let _endpos_type_vis_, _startpos_type_vis_ = + (_endpos_attr_, _startpos__1_inlined1_) in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_372 _endpos__1_ _startpos__1_ pat = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pat, body) + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_deriving__ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_type_vis_ != _endpos_type_vis_ then _startpos_type_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptop_typedef + { + tycon; + tycon_loc_ = i _loc_tycon_; + params; + components = Ptd_extern; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_373 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pat = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_491 _endpos_deriving__ _startpos_type_header_ deriving_ ty + type_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_type_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_, params = type_header in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_newtype ty; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_374 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pat record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_492 _endpos_deriving__ _startpos_type_header_ deriving_ ty + type_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_type_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_ = type_header in + let exception_decl : Parsing_syntax.exception_decl = + match ty with None -> No_payload | Some ty -> Single_payload ty + in + Ptop_typedef + { + tycon; + tycon_loc_; + params = []; + components = Ptd_error exception_decl; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_375 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pat record = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_493 _endpos_deriving__ _startpos_type_header_ cs deriving_ + type_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_type_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_ = type_header in + let exception_decl : Parsing_syntax.exception_decl = Enum_payload cs in + Ptop_typedef + { + tycon; + tycon_loc_; + params = []; + components = Ptd_error exception_decl; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_376 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pat = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_494 _endpos_deriving__ _startpos_type_header_ deriving_ ty + type_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_type_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_, params = type_header in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_alias ty; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_377 _endpos_e_ _endpos_name_ _startpos_name_ e name pat = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_495 _endpos_deriving__ _startpos_struct_header_ deriving_ fs + struct_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_struct_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_, params = struct_header in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_record fs; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_378 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pat record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_496 _endpos_deriving__ _startpos_enum_header_ cs deriving_ + enum_header = + let _endpos = _endpos_deriving__ in + let _symbolstartpos = _startpos_enum_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, type_vis, tycon, tycon_loc_, params = enum_header in + Ptop_typedef + { + tycon; + tycon_loc_; + params; + components = Ptd_variant cs; + type_vis; + doc_ = Docstring.empty; + deriving_; + loc_ = aloc _sloc; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_379 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pat record = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_497 _endpos_expr_ _startpos_val_header_ expr val_header = + let _endpos = _endpos_expr_ in + let _symbolstartpos = _startpos_val_header_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let attrs, is_constant, vis, binder, ty = val_header in + Ptop_letdef + { + binder; + ty; + expr; + vis; + is_constant; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_380 _endpos_e_ _startpos_obj_ e ind obj pat = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_498 _endpos_fname_ _startpos_t_ fname mname t = + let _endpos = _endpos_fname_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = t; + decl_body = + Decl_stubs (Import { module_name = mname; func_name = fname }); + } + : Parsing_syntax.impl) -let _menhir_action_381 _1 pat = - let x = - let body = _1 in - (pat, body) - in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_499 _endpos_s_ _startpos_t_ s t = + let _endpos = _endpos_s_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = t; + decl_body = + Decl_stubs (Embedded { language = None; code = Code_string s }); + } + : Parsing_syntax.impl) -let _menhir_action_382 _endpos__1_ _startpos__1_ pat xs = - let x = - let body = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pat, body) - in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_500 _endpos_xs_ _startpos_t_ t xs = + let _endpos = _endpos_xs_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = t; + decl_body = + Decl_stubs + (Embedded { language = None; code = Code_multiline_string xs }); + } + : Parsing_syntax.impl) -let _menhir_action_383 _endpos_x_ _startpos__1_ pat x xs = - let x = - let body = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (pat, body) - in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_501 _endpos_s_ _startpos_t_ s t = + let _endpos = _endpos_s_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let language, decl = t in + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = decl; + decl_body = + Decl_stubs + (Embedded { language = Some language; code = Code_string s }); + } + : Parsing_syntax.impl) -let _menhir_action_384 _endpos__1_ _startpos__1_ pat xs = - let x = - let body = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pat, body) - in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_502 _endpos_xs_ _startpos_t_ t xs = + let _endpos = _endpos_xs_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let language, decl = t in + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = decl; + decl_body = + Decl_stubs + (Embedded + { language = Some language; code = Code_multiline_string xs }); + } + : Parsing_syntax.impl) -let _menhir_action_385 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pat xs = - let x = - let body = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (pat, body) - in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) +let _menhir_action_503 _endpos_body_ _startpos_t_ body t = + let _endpos = _endpos_body_ in + let _symbolstartpos = _startpos_t_ in + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let local_types, body = body in + Parsing_syntax.Ptop_funcdef + { + loc_ = aloc _sloc; + fun_decl = t; + decl_body = Decl_body { expr = body; local_types }; + } + : Parsing_syntax.impl) -let _menhir_action_386 _endpos_expr_ _startpos__1_ expr pat xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (pat, body) +let _menhir_action_504 _endpos__0_ _endpos__8_ _endpos_name_ _startpos__3_ + _startpos_name_ methods name supers = + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_387 _endpos_expr_ _startpos__1_ expr pat xs = - let x = - let body = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (pat, body) +let _menhir_action_505 _endpos__0_ _endpos__1_ _endpos__8_ _endpos_name_ + _startpos__1_ _startpos__3_ _startpos_name_ methods name supers = + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_388 _endpos__1_ _startpos__1_ pat xs = - let x = - let body = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (pat, body) + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_389 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pat xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) +let _menhir_action_506 _endpos__0_ _endpos__8_ _endpos_attr_ _endpos_name_ + _startpos__1_ _startpos__3_ _startpos_name_ attr methods name supers = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_390 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pat record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_391 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pat record xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (pat, body) +let _menhir_action_507 _1 _endpos__1_ _endpos__8_ _endpos_name_ _startpos__1_ + _startpos__3_ _startpos_name_ methods name supers = + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _endpos__1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_392 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj pat xs = - let x = - let body = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 +let _menhir_action_508 _1 _endpos__1_ _endpos__1_inlined1_ _endpos__8_ + _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ methods name supers = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (pat, body) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_393 _endpos_e_ _endpos_name_ _startpos_name_ e name pat xs = - let x = - let body = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) + let _endpos_vis_, _startpos_vis_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_394 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pat record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_395 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pat record xs = - let x = - let body = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) +let _menhir_action_509 _1 _endpos__1_ _endpos__8_ _endpos_attr_ _endpos_name_ + _startpos__1_ _startpos__1_inlined1_ _startpos__3_ _startpos_name_ attr + methods name supers = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_396 _endpos_e_ _startpos_obj_ e ind obj pat xs = - let x = - let body = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (pat, body) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_inlined1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos__8_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let trait_name : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + let supers = match supers with None -> [] | Some supers -> supers in + Parsing_syntax.Ptop_trait + { + trait_name; + trait_supers = supers; + trait_methods = methods; + trait_vis = vis; + trait_loc_ = aloc _sloc; + trait_doc_ = Docstring.empty; + trait_attrs = attrs; + } + : Parsing_syntax.impl) -let _menhir_action_397 _1 pat xs = - let x = - let body = _1 in - (pat, body) +let _menhir_action_510 _endpos__0_ _endpos_name_ _endpos_target_ _startpos__3_ + _startpos_name_ name target = + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_398 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (_1, _3) +let _menhir_action_511 _endpos__0_ _endpos__1_ _endpos_name_ _endpos_target_ + _startpos__1_ _startpos__3_ _startpos_name_ name target = + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_399 _1 _endpos_x_ _startpos__1_inlined1_ x = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_400 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (_1, _3) +let _menhir_action_512 _endpos__0_ _endpos_attr_ _endpos_name_ _endpos_target_ + _startpos__1_ _startpos__3_ _startpos_name_ attr name target = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_401 _1 _1_inlined2 _endpos__1_inlined2_ - _startpos__1_inlined1_ = - let x = - let _3 = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_402 _1 _endpos_expr_ _startpos__1_inlined1_ expr = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (_1, _3) +let _menhir_action_513 _1 _endpos__1_ _endpos_name_ _endpos_target_ + _startpos__1_ _startpos__3_ _startpos_name_ name target = + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _endpos__1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_403 _1 _endpos_expr_ _startpos__1_inlined1_ expr = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } +let _menhir_action_514 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ name target = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (_1, _3) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_404 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_405 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ e name = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_406 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ _startpos_record_ e - name record = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_515 _1 _endpos__1_ _endpos_attr_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ attr name target = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_407 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_index_ _startpos__1_inlined1_ _startpos_index_ _startpos_record_ e - index record = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_inlined1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_target_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _loc_name_ = (_startpos_name_, _endpos_name_) in + let _sloc = (_symbolstartpos, _endpos) in + (let binder : Parsing_syntax.binder = + { binder_name = name; loc_ = i _loc_name_ } + in + enter_next_block (); + Parsing_syntax.Ptop_trait_alias + { binder; target; vis; loc_ = aloc _sloc; attrs; doc_ = Docstring.empty } + : Parsing_syntax.impl) -let _menhir_action_408 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _startpos__1_inlined1_ _startpos_obj_ e ind obj = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_516 _endpos__0_ _endpos_body_ _startpos__2_ body name params + = + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let local_types, body = body in + Parsing_syntax.Ptop_test + { + expr = body; + name; + params; + local_types; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_409 _1 _endpos_e_ _endpos_name_ _startpos_name_ e name = - let x = - let _3 = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_517 _1 _endpos__1_ _endpos_body_ _startpos__1_ _startpos__2_ + body name params = + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else _startpos__2_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (enter_next_block (); + let local_types, body = body in + Parsing_syntax.Ptop_test + { + expr = body; + name; + params; + local_types; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_410 _1 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record = - let x = - let _3 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_518 _endpos__0_ _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__3_ _startpos_name_ body has_error name params quantifiers ret_ty + self_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_411 _1 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record = - let x = - let _3 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_412 _1 _endpos_e_ _startpos_obj_ e ind obj = - let x = - let _3 = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_519 _endpos__0_ _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body has_error + name params quantifiers ret_ty self_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_413 _1 _1_inlined1 = - let x = - let _3 = - let _1 = _1_inlined1 in - _1 - in - (_1, _3) + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - ([ x ] : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_414 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_415 _1 _endpos_x_ _startpos__1_inlined1_ x xs = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (_1, _3) +let _menhir_action_520 _endpos__0_ _endpos_attr_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ attr body + has_error name params quantifiers ret_ty self_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_416 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (_1, _3) + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_417 _1 _1_inlined2 _endpos__1_inlined2_ - _startpos__1_inlined1_ xs = - let x = - let _3 = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_418 _1 _endpos_expr_ _startpos__1_inlined1_ expr xs = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (_1, _3) +let _menhir_action_521 _1 _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body has_error + name params quantifiers ret_ty self_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_419 _1 _endpos_expr_ _startpos__1_inlined1_ expr xs = - let x = - let _3 = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (_1, _3) + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _endpos__1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_420 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (_1, _3) +let _menhir_action_522 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ body has_error name params quantifiers ret_ty + self_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_421 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ e name xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (_1, _3) + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_422 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ _startpos_record_ e - name record xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_423 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_index_ _startpos__1_inlined1_ _startpos_index_ _startpos_record_ e - index record xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_424 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _startpos__1_inlined1_ _startpos_obj_ e ind obj xs = - let x = - let _3 = - let _endpos__1_, _startpos__1_, _1 = - (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) - in - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_523 _1 _endpos__1_ _endpos_attr_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ attr body has_error name params quantifiers ret_ty self_ty + trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_425 _1 _endpos_e_ _endpos_name_ _startpos_name_ e name xs = - let x = - let _3 = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_426 _1 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record xs = - let x = - let _3 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_inlined1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_427 _1 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record xs = - let x = - let _3 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) +let _menhir_action_524 _endpos__0_ _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__3_ _startpos_name_ body has_error name params quantifiers ret_ty + trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_428 _1 _endpos_e_ _startpos_obj_ e ind obj xs = - let x = - let _3 = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (_1, _3) + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_429 _1 _1_inlined1 xs = - let x = - let _3 = - let _1 = _1_inlined1 in - _1 - in - (_1, _3) - in - (x :: xs : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_430 x : Parsing_syntax.constr_decl list = [ x ] -let _menhir_action_431 x xs : Parsing_syntax.constr_decl list = x :: xs -let _menhir_action_432 x : Parsing_syntax.local_type_decl list = [ x ] -let _menhir_action_433 x xs : Parsing_syntax.local_type_decl list = x :: xs -let _menhir_action_434 x : Parsing_syntax.field_decl list = [ x ] -let _menhir_action_435 x xs : Parsing_syntax.field_decl list = x :: xs -let _menhir_action_436 x : Parsing_compact.semi_expr_prop list = [ x ] -let _menhir_action_437 x xs : Parsing_compact.semi_expr_prop list = x :: xs -let _menhir_action_438 x : Parsing_syntax.impl list = [ x ] -let _menhir_action_439 x xs : Parsing_syntax.impl list = x :: xs -let _menhir_action_440 x : Parsing_syntax.trait_method_decl list = [ x ] -let _menhir_action_441 x xs : Parsing_syntax.trait_method_decl list = x :: xs - -let _menhir_action_442 xs = - let _1 = - let _2 = None in - xs +let _menhir_action_525 _endpos__0_ _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body has_error + name params quantifiers ret_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_443 x xs = - let _1 = - let _2 = Some x in - xs + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_444 xs = - let _1 = - let _2 = None in - xs + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_445 x xs = - let _1 = - let _2 = Some x in - xs +let _menhir_action_526 _endpos__0_ _endpos_attr_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ attr body + has_error name params quantifiers ret_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_446 xs = - let _1 = - let _2 = None in - xs + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) - -let _menhir_action_447 x xs = - let _1 = - let _2 = Some x in - xs + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in + let attrs = [] in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (List.rev _1 : (Parsing_syntax.pattern list * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_448 xs = - let _1 = - let _2 = None in - xs +let _menhir_action_527 _1 _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body has_error + name params quantifiers ret_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_449 x xs = - let _1 = - let _2 = Some x in - xs + let vis = Parsing_syntax.Vis_default in + let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _endpos__1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (List.rev _1 : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_450 xs = - let _1 = - let _2 = None in - xs +let _menhir_action_528 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ body has_error name params quantifiers ret_ty + trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_451 x xs = - let _1 = - let _2 = Some x in - xs + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (List.rev _1 : (Parsing_syntax.pattern * Parsing_syntax.expr) list) - -let _menhir_action_452 xs = - let _1 = - let _2 = None in - xs + let _endpos_vis_, _startpos_vis_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - (List.rev _1 : Parsing_syntax.constr_decl list) - -let _menhir_action_453 x xs = - let _1 = - let _2 = Some x in - xs + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (List.rev _1 : Parsing_syntax.constr_decl list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_454 xs = - let _1 = - let _2 = None in - xs +let _menhir_action_529 _1 _endpos__1_ _endpos_attr_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ attr body has_error name params quantifiers ret_ty trait = + let method_name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : Parsing_syntax.local_type_decl list) - -let _menhir_action_455 x xs = - let _1 = - let _2 = Some x in - xs + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (List.rev _1 : Parsing_syntax.local_type_decl list) - -let _menhir_action_456 xs = - let _1 = - let _2 = None in - xs + let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_inlined1_) in + let attrs = _1 in + let _endpos_attrs_, _startpos_attrs_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_body_ in + let _symbolstartpos = + if _startpos_attrs_ != _endpos_attrs_ then _startpos_attrs_ + else if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ + else _startpos__3_ in - (List.rev _1 : Parsing_syntax.field_decl list) + let _sloc = (_symbolstartpos, _endpos) in + (let header_loc_ = i (_startpos__3_, _endpos_ret_ty_) in + enter_next_block (); + Parsing_syntax.Ptop_impl + { + self_ty = None; + trait; + method_name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_ = aloc _sloc; + doc_ = Docstring.empty; + attrs; + } + : Parsing_syntax.impl) -let _menhir_action_457 x xs = - let _1 = - let _2 = Some x in - xs +let _menhir_action_530 _endpos_name_ _endpos_return_type_ _startpos_name_ + has_error name params quantifiers return_type = + let name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } in - (List.rev _1 : Parsing_syntax.field_decl list) + let _endpos = _endpos_return_type_ in + let _symbolstartpos = _startpos_name_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Trait_method + { + name; + has_error = (match has_error with Some _ -> true | _ -> false); + quantifiers; + params; + return_type; + loc_ = i _sloc; + } + : Parsing_syntax.trait_method_decl) -let _menhir_action_458 xs = - let _1 = - let _2 = None in - xs - in - (List.rev _1 : Parsing_syntax.impls) +let _menhir_action_531 typ = + ({ Parsing_syntax.tmparam_typ = typ; tmparam_label = None } + : Parsing_syntax.trait_method_param) -let _menhir_action_459 x xs = - let _1 = - let _2 = Some x in - xs - in - (List.rev _1 : Parsing_syntax.impls) +let _menhir_action_532 _endpos_label_name_ _startpos_label_name_ label_name typ + = + let _loc_label_name_ = (_startpos_label_name_, _endpos_label_name_) in + (let label = + { + Parsing_syntax.label_name; + loc_ = Rloc.trim_last_char (i _loc_label_name_); + } + in + { Parsing_syntax.tmparam_typ = typ; tmparam_label = Some label } + : Parsing_syntax.trait_method_param) -let _menhir_action_460 xs = - let _1 = - let _2 = None in - xs - in - (List.rev _1 : Parsing_syntax.trait_method_decl list) +let _menhir_action_533 _endpos__1_ _endpos__5_ _startpos__1_ body catch + catch_keyword = + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _loc__1_ = (_startpos__1_, _endpos__1_) in + let _sloc = (_symbolstartpos, _endpos) in + (let catch_all, catch_loc_ = catch_keyword in + Parsing_syntax.Pexpr_try + { + loc_ = i _sloc; + body; + catch; + catch_all; + try_else = None; + else_loc_ = Rloc.no_location; + try_loc_ = i _loc__1_; + catch_loc_; + } + : Parsing_syntax.expr) -let _menhir_action_461 x xs = - let _1 = - let _2 = Some x in - xs +let _menhir_action_534 _endpos__1_ _endpos__2_ _endpos__8_ _startpos__1_ + _startpos__1_inlined1_ body catch catch_keyword try_else = + let else_loc_ = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + i _sloc in - (List.rev _1 : Parsing_syntax.trait_method_decl list) + let _endpos = _endpos__8_ in + let _symbolstartpos = _startpos__1_ in + let _loc__1_ = (_startpos__1_, _endpos__1_) in + let _sloc = (_symbolstartpos, _endpos) in + (let catch_all, catch_loc_ = catch_keyword in + Parsing_syntax.Pexpr_try + { + loc_ = i _sloc; + body; + catch; + catch_all; + try_else = Some try_else; + else_loc_; + try_loc_ = i _loc__1_; + catch_loc_; + } + : Parsing_syntax.expr) -let _menhir_action_462 _1 : Parsing_syntax.map_pat_elem list = _1 -let _menhir_action_463 () : unit option = None -let _menhir_action_464 x : unit option = Some x -let _menhir_action_465 () : unit option = None -let _menhir_action_466 x : unit option = Some x +let _menhir_action_535 _endpos_name_ _startpos_name_ name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + ({ Parsing_syntax.tvar_name = name; tvar_constraints = []; loc_ = i _loc } + : Parsing_syntax.tvar_binder) -let _menhir_action_467 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_536 _endpos_name_ _startpos_name_ constraints name = + let _loc_name_ = (_startpos_name_, _endpos_name_) in + ({ + Parsing_syntax.tvar_name = name; + tvar_constraints = constraints; + loc_ = i _loc_name_; + } + : Parsing_syntax.tvar_binder) -let _menhir_action_468 t = - let x = t in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_537 _1 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + ({ Parsing_syntax.tvc_trait = _1; loc_ = i _sloc } + : Parsing_syntax.tvar_constraint) -let _menhir_action_469 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_538 _endpos__2_ _startpos_id_ id = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos_id_ in + let _sloc = (_symbolstartpos, _endpos) in + ({ Parsing_syntax.tvc_trait = Lident (id ^ "?"); loc_ = i _sloc } + : Parsing_syntax.tvar_constraint) -let _menhir_action_470 t = - let x = t in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_539 _endpos__2_ _startpos__2_ _startpos_ty_ ty = + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos_ty_ in + let _loc__2_ = (_startpos__2_, _endpos__2_) in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ptype_option ~loc_:(i _sloc) ~constr_loc:(i _loc__2_) ty + : Parsing_syntax.typ) -let _menhir_action_471 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_540 _endpos__5_ _startpos__1_ t ts = + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (make_Ptype_tuple ~loc_:(i _sloc) (t :: ts) : Parsing_syntax.typ) -let _menhir_action_472 t = - let x = t in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_541 _endpos__1_ _endpos_rty_ _startpos__1_ _startpos__2_ rty + t = + let ts = None in + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + let ts = match ts with None -> [] | Some ts -> ts in + Ptype_arrow { loc_ = i _sloc; ty_arg = t :: ts; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_473 () : (Parsing_syntax.constr_pat_arg list * bool) option = - None +let _menhir_action_542 _endpos__1_ _endpos_rty_ _startpos__1_ _startpos__2_ rty + t x = + let ts = Some x in + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + let ts = match ts with None -> [] | Some ts -> ts in + Ptype_arrow { loc_ = i _sloc; ty_arg = t :: ts; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_474 t = - let x = t in - (Some x : (Parsing_syntax.constr_pat_arg list * bool) option) +let _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty t = + let ts = None in + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + let ts = match ts with None -> [] | Some ts -> ts in + Ptype_arrow { loc_ = i _sloc; ty_arg = t :: ts; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_475 () : Parsing_syntax.binder option = None +let _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ rty t x = + let ts = Some x in + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + let ts = match ts with None -> [] | Some ts -> ts in + Ptype_arrow { loc_ = i _sloc; ty_arg = t :: ts; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_476 _endpos_name_ _startpos_name_ name = - let x = - let b = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - b +let _menhir_action_545 _endpos__1_ _endpos_rty_ _startpos__1_ _startpos__2_ rty + = + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ in - (Some x : Parsing_syntax.binder option) + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + Ptype_arrow { loc_ = i _sloc; ty_arg = []; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_477 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty = + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + Ptype_arrow { loc_ = i _sloc; ty_arg = []; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_478 t2 = - let x = t2 in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_547 t = (t : Parsing_syntax.typ) -let _menhir_action_479 () : Parsing_syntax.tvar_constraint list option = None +let _menhir_action_548 _endpos__1_ _endpos_rty_ _startpos__1_ _startpos__2_ rty + t = + let is_async = true in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__1_, _startpos__1_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + Ptype_arrow { loc_ = i _sloc; ty_arg = [ t ]; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_480 _2 = - let x = _2 in - (Some x : Parsing_syntax.tvar_constraint list option) +let _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty t = + let is_async = false in + let _endpos_is_async_, _startpos_is_async_ = (_endpos__0_, _endpos__0_) in + let _endpos = _endpos_rty_ in + let _symbolstartpos = + if _startpos_is_async_ != _endpos_is_async_ then _startpos_is_async_ + else _startpos__2_ + in + let _sloc = (_symbolstartpos, _endpos) in + (let ty_res, ty_err = rty in + Ptype_arrow { loc_ = i _sloc; ty_arg = [ t ]; ty_res; ty_err; is_async } + : Parsing_syntax.typ) -let _menhir_action_481 () : Parsing_syntax.constr_param list option = None +let _menhir_action_550 _endpos_id_ _endpos_params_ _startpos_id_ id params = + let _endpos = _endpos_params_ in + let _symbolstartpos = _startpos_id_ in + let _loc_id_ = (_startpos_id_, _endpos_id_) in + let _sloc = (_symbolstartpos, _endpos) in + (Ptype_name + { + loc_ = i _sloc; + constr_id = { lid = id; loc_ = i _loc_id_ }; + tys = params; + } + : Parsing_syntax.typ) -let _menhir_action_482 ts = - let x = ts in - (Some x : Parsing_syntax.constr_param list option) +let _menhir_action_551 _endpos_lid_ _startpos_lid_ lid = + let _loc_lid_ = (_startpos_lid_, _endpos_lid_) in + (Ptype_object { lid; loc_ = i _loc_lid_ } : Parsing_syntax.typ) -let _menhir_action_483 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_552 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + (Parsing_syntax.Ptype_any { loc_ = i _sloc } : Parsing_syntax.typ) -let _menhir_action_484 t = - let x = t in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_553 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_485 () : - (Parsing_syntax.typ * Parsing_syntax.error_typ) option = - None +let _menhir_action_554 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ + params tycon = + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_486 t = - let x = t in - (Some x : (Parsing_syntax.typ * Parsing_syntax.error_typ) option) +let _menhir_action_555 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_487 () : Parsing_syntax.type_decl_binder list option = None +let _menhir_action_556 _1 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_488 x = - let x = x in - (Some x : Parsing_syntax.type_decl_binder list option) +let _menhir_action_557 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) + +let _menhir_action_558 _1 _endpos_attr_ _endpos_tycon_ _startpos__1_inlined1_ + _startpos_tycon_ attr params tycon = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_489 () : Parsing_syntax.typ list option = None +let _menhir_action_559 _endpos_name_ _startpos_name_ name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + ({ Parsing_syntax.tvar_name = Some name; loc_ = i _loc } + : Parsing_syntax.type_decl_binder) -let _menhir_action_490 x = - let x = x in - (Some x : Parsing_syntax.typ list option) +let _menhir_action_560 _endpos__1_ _startpos__1_ = + let _endpos = _endpos__1_ in + let _startpos = _startpos__1_ in + let _loc = (_startpos, _endpos) in + ({ Parsing_syntax.tvar_name = None; loc_ = i _loc } + : Parsing_syntax.type_decl_binder) -let _menhir_action_491 () : Parsing_syntax.expr option = None -let _menhir_action_492 x : Parsing_syntax.expr option = Some x -let _menhir_action_493 () : Parsing_syntax.expr option = None -let _menhir_action_494 x : Parsing_syntax.expr option = Some x -let _menhir_action_495 () : Parsing_syntax.test_name = None +let _menhir_action_561 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_496 _1 _endpos__1_ _startpos__1_ = - let x = +let _menhir_action_562 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ + params tycon = + let vis = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - { Rloc.v = _1; loc_ = i _sloc } + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (Some x : Parsing_syntax.test_name) + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) + +let _menhir_action_563 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon = + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_497 () : Parsing_syntax.parameters option = None +let _menhir_action_564 _1 _endpos_tycon_ _startpos_tycon_ params tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_498 () = - let x = - let _1 = - let x = [] in - x +let _menhir_action_565 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - _1 + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (Some x : Parsing_syntax.parameters option) + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_499 _1_inlined1 = - let x = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 +let _menhir_action_566 _1 _endpos_attr_ _endpos_tycon_ _startpos__1_inlined1_ + _startpos_tycon_ attr params tycon = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (Some x : Parsing_syntax.parameters option) + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_, params) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t + * Parsing_syntax.type_decl_binder list) -let _menhir_action_500 () : Parsing_syntax.typ option = None -let _menhir_action_501 x : Parsing_syntax.typ option = Some x -let _menhir_action_502 () : Parsing_syntax.tvar_binder list option = None -let _menhir_action_503 x : Parsing_syntax.tvar_binder list option = Some x +let _menhir_action_567 _endpos_tycon_ _startpos_tycon_ tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) -let _menhir_action_504 _endpos__3_ _startpos__1_inlined1_ = - let else_ = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in +let _menhir_action_568 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ + tycon = + let vis = + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (Some else_ : Parsing_syntax.expr option) + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) -let _menhir_action_505 _endpos__3_ _startpos__1_inlined1_ xs = - let else_ = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in +let _menhir_action_569 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr tycon = + let vis = + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - (Some else_ : Parsing_syntax.expr option) + let attrs = [] in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) -let _menhir_action_506 _endpos__3_ _startpos__1_inlined1_ x xs = - let else_ = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 +let _menhir_action_570 _1 _endpos_tycon_ _startpos_tycon_ tycon = + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) + +let _menhir_action_571 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ tycon = + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - let _endpos = _endpos__3_ in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (Some else_ : Parsing_syntax.expr option) - -let _menhir_action_507 () : Parsing_syntax.expr option = None + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) -let _menhir_action_508 params : Parsing_syntax.typ list = - match params with None -> [] | Some params -> params +let _menhir_action_572 _1 _endpos_attr_ _endpos_tycon_ _startpos__1_inlined1_ + _startpos_tycon_ attr tycon = + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in + let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in + ((attrs, vis, tycon, i _loc_tycon_) + : Parsing_syntax.attribute list + * Parsing_syntax.visibility + * string + * Rloc.t) + +let _menhir_action_573 _endpos_name_ _startpos_name_ name = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + ({ Parsing_syntax.name; is_object = false; loc_ = i _loc } + : Parsing_syntax.type_name) + +let _menhir_action_574 _endpos_name_ _startpos__1_ name = + let _endpos = _endpos_name_ in + let _startpos = _startpos__1_ in + let _loc = (_startpos, _endpos) in + ({ Parsing_syntax.name; is_object = true; loc_ = i _loc } + : Parsing_syntax.type_name) + +let _menhir_action_575 x = + let _1 = x in + (_1 : Parsing_syntax.tvar_binder list) -let _menhir_action_509 params : Parsing_syntax.tvar_binder list = - match params with None -> [] | Some params -> params - -let _menhir_action_510 params : Parsing_syntax.type_decl_binder list = - match params with None -> [] | Some params -> params - -let _menhir_action_511 _endpos_pat2_ _startpos_pat1_ pat1 pat2 = - let _endpos = _endpos_pat2_ in - let _symbolstartpos = _startpos_pat1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_or { loc_ = i _sloc; pat1; pat2 } - : Parsing_syntax.pattern) - -let _menhir_action_512 _1 : Parsing_syntax.pattern = _1 - -let _menhir_action_513 _endpos_name_ _startpos_name_ name = - let param_annot = +let _menhir_action_576 _endpos_name_ _startpos_name_ name = + let t = let _1 = None in _1 in - let param_binder = + let binder = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in let _loc = (_startpos, _endpos) in { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ({ Parsing_syntax.param_binder; param_annot; param_kind = Positional } - : Parsing_syntax.parameter) - -let _menhir_action_514 _endpos_name_ _startpos_name_ name t = - let param_annot = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_577 _endpos_name_ _startpos_name_ name t = + let t = let _1 = let x = t in Some x in _1 in - let param_binder = + let binder = let _endpos = _endpos_name_ in let _startpos = _startpos_name_ in let _loc = (_startpos, _endpos) in { Parsing_syntax.binder_name = name; loc_ = i _loc } in - ({ Parsing_syntax.param_binder; param_annot; param_kind = Positional } - : Parsing_syntax.parameter) - -let _menhir_action_515 label = - let param_annot = + let vis = Parsing_syntax.Vis_default in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_578 _endpos__1_ _endpos_name_ _startpos__1_ _startpos_name_ + name = + let t = let _1 = None in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_516 label t = - let param_annot = +let _menhir_action_579 _endpos__1_ _endpos_name_ _startpos__1_ _startpos_name_ + name t = + let t = let _1 = let x = t in Some x in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_517 default label = - let param_annot = +let _menhir_action_580 _endpos_attr_ _endpos_name_ _startpos__1_ _startpos_name_ + attr name = + let t = let _1 = None in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { - Parsing_syntax.param_binder; - param_annot; - param_kind = Optional { default }; - } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_518 default label t = - let param_annot = +let _menhir_action_581 _endpos_attr_ _endpos_name_ _startpos__1_ _startpos_name_ + attr name t = + let t = let _1 = let x = t in Some x in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { - Parsing_syntax.param_binder; - param_annot; - param_kind = Optional { default }; - } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = [] in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_519 label = - let param_annot = +let _menhir_action_582 _1 _endpos_name_ _startpos_name_ name = + let t = let _1 = None in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - : Parsing_syntax.parameter) - -let _menhir_action_520 label t = - let param_annot = + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_583 _1 _endpos_name_ _startpos_name_ name t = + let t = let _1 = let x = t in Some x in _1 in - (let param_binder : Parsing_syntax.binder = - { - binder_name = label.Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char label.loc_; - } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - : Parsing_syntax.parameter) - -let _menhir_action_521 _endpos_binder_name_ _startpos_binder_name_ binder_name = - let param_annot = + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_584 _1 _endpos__1_inlined1_ _endpos_name_ + _startpos__1_inlined1_ _startpos_name_ name = + let t = let _1 = None in _1 in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_522 _endpos_binder_name_ _startpos_binder_name_ binder_name t - = - let param_annot = +let _menhir_action_585 _1 _endpos__1_inlined1_ _endpos_name_ + _startpos__1_inlined1_ _startpos_name_ name t = + let t = let _1 = let x = t in Some x in _1 in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } + in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_523 _endpos_binder_name_ _startpos_binder_name_ binder_name - default = - let param_annot = +let _menhir_action_586 _1 _endpos_attr_ _endpos_name_ _startpos__1_inlined1_ + _startpos_name_ attr name = + let t = let _1 = None in _1 in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } - in - { - Parsing_syntax.param_binder; - param_annot; - param_kind = Optional { default }; - } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_524 _endpos_binder_name_ _startpos_binder_name_ binder_name - default t = - let param_annot = +let _menhir_action_587 _1 _endpos_attr_ _endpos_name_ _startpos__1_inlined1_ + _startpos_name_ attr name t = + let t = let _1 = let x = t in Some x in _1 in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i _loc_binder_name_) } - in - { - Parsing_syntax.param_binder; - param_annot; - param_kind = Optional { default }; - } - : Parsing_syntax.parameter) + let binder = + let _endpos = _endpos_name_ in + let _startpos = _startpos_name_ in + let _loc = (_startpos, _endpos) in + { Parsing_syntax.binder_name = name; loc_ = i _loc } + in + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } + in + let attrs = _1 in + ((attrs, false, vis, binder, t) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_525 _endpos_binder_name_ _startpos_binder_name_ binder_name = - let param_annot = +let _menhir_action_588 _endpos_binder_name_ _startpos_binder_name_ binder_name = + let t = let _1 = None in _1 in + let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = i _loc_binder_name_ } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - : Parsing_syntax.parameter) + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) -let _menhir_action_526 _endpos_binder_name_ _startpos_binder_name_ binder_name t +let _menhir_action_589 _endpos_binder_name_ _startpos_binder_name_ binder_name t = - let param_annot = + let t = let _1 = let x = t in Some x in _1 in + let vis = Parsing_syntax.Vis_default in + let attrs = [] in let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = i _loc_binder_name_ } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - : Parsing_syntax.parameter) - -let _menhir_action_527 _endpos_name_ _startpos_name_ _startpos_p_ name p = - let b = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos_b_ = _endpos_name_ in - let _endpos = _endpos_b_ in - let _symbolstartpos = _startpos_p_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_alias ~loc_:(i _sloc) (p, b) : Parsing_syntax.pattern) - -let _menhir_action_528 _1 : Parsing_syntax.pattern = _1 - -let _menhir_action_529 _endpos_rhs_ _startpos_lhs_ lhs rhs = - let _endpos = _endpos_rhs_ in - let _symbolstartpos = _startpos_lhs_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_pipe { lhs; rhs; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_530 _1 : Parsing_syntax.expr = _1 - -let _menhir_action_531 _endpos_name_ _startpos_expr_ _startpos_name_ expr name = - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let _endpos_trait_ = _endpos_name_ in - let _endpos = _endpos_trait_ in - let _symbolstartpos = _startpos_expr_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_as { expr; trait; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_532 _1 : Parsing_syntax.expr = _1 - -let _menhir_action_533 _endpos_e_ _startpos__1_ e = - let op = - let _1 = "+" in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_590 _endpos__1_ _endpos_binder_name_ _startpos__1_ + _startpos_binder_name_ binder_name = + let t = + let _1 = None in _1 in - let _startpos_op_ = _startpos__1_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_op_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_uplus ~loc_:(i _sloc) op e : Parsing_syntax.expr) - -let _menhir_action_534 _endpos_e_ _startpos__1_ e = - let op = - let _1 = "-" in - _1 + let vis = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - let _startpos_op_ = _startpos__1_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_op_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_uminus ~loc_:(i _sloc) op e : Parsing_syntax.expr) - -let _menhir_action_535 _1 : Parsing_syntax.expr = _1 -let _menhir_action_536 () : string option = None -let _menhir_action_537 () : string option = Some "readonly" -let _menhir_action_538 attr : string option = Some attr -let _menhir_action_539 i : Parsing_syntax.longident = Lident i -let _menhir_action_540 id ps : Parsing_syntax.longident = Ldot { pkg = ps; id } -let _menhir_action_541 i : Parsing_syntax.longident = Lident i -let _menhir_action_542 id ps : Parsing_syntax.longident = Ldot { pkg = ps; id } -let _menhir_action_543 i : Parsing_syntax.longident = Lident i -let _menhir_action_544 id ps : Parsing_syntax.longident = Ldot { pkg = ps; id } -let _menhir_action_545 id ps : Parsing_syntax.longident = Ldot { pkg = ps; id } - -let _menhir_action_546 _endpos_rhs_ _startpos_lhs_ lhs rhs = - let _endpos = _endpos_rhs_ in - let _symbolstartpos = _startpos_lhs_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_range { lhs; rhs; inclusive = false; loc_ = i _sloc } - : Parsing_syntax.pattern) - -let _menhir_action_547 _endpos_rhs_ _startpos_lhs_ lhs rhs = - let _endpos = _endpos_rhs_ in - let _symbolstartpos = _startpos_lhs_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_range { lhs; rhs; inclusive = true; loc_ = i _sloc } - : Parsing_syntax.pattern) - -let _menhir_action_548 _1 : Parsing_syntax.pattern = _1 - -let _menhir_action_549 _endpos__0_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ - _startpos_mutflag_ _startpos_name_ mutflag name ty = - let field_vis = Parsing_syntax.Vis_default in - let _endpos_field_vis_, _startpos_field_vis_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_ty_ in - let _symbolstartpos = - if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ - else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ - else _startpos_name_ + let attrs = [] in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_591 _endpos__1_ _endpos_binder_name_ _startpos__1_ + _startpos_binder_name_ binder_name t = + let t = + let _1 = + let x = t in + Some x + in + _1 in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - ({ - Parsing_syntax.field_name = - { Parsing_syntax.label = name; loc_ = i _loc_name_ }; - field_ty = ty; - field_mut = mutflag <> None; - field_vis; - field_loc_ = i _sloc; - } - : Parsing_syntax.field_decl) - -let _menhir_action_550 _endpos__1_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ - _startpos__1_ _startpos_mutflag_ _startpos_name_ mutflag name ty = - let field_vis = + let vis = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in Parsing_syntax.Vis_priv { loc_ = i _sloc } in - let _endpos_field_vis_, _startpos_field_vis_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos_ty_ in - let _symbolstartpos = - if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ - else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ - else _startpos_name_ + let attrs = [] in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_592 _endpos_attr_ _endpos_binder_name_ _startpos__1_ + _startpos_binder_name_ attr binder_name = + let t = + let _1 = None in + _1 in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - ({ - Parsing_syntax.field_name = - { Parsing_syntax.label = name; loc_ = i _loc_name_ }; - field_ty = ty; - field_mut = mutflag <> None; - field_vis; - field_loc_ = i _sloc; - } - : Parsing_syntax.field_decl) - -let _menhir_action_551 _endpos_attr_ _endpos_mutflag_ _endpos_name_ _endpos_ty_ - _startpos__1_ _startpos_mutflag_ _startpos_name_ attr mutflag name ty = - let field_vis = + let vis = let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _endpos_field_vis_, _startpos_field_vis_ = - (_endpos_attr_, _startpos__1_) + let attrs = [] in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_593 _endpos_attr_ _endpos_binder_name_ _startpos__1_ + _startpos_binder_name_ attr binder_name t = + let t = + let _1 = + let x = t in + Some x + in + _1 in - let _endpos = _endpos_ty_ in - let _symbolstartpos = - if _startpos_field_vis_ != _endpos_field_vis_ then _startpos_field_vis_ - else if _startpos_mutflag_ != _endpos_mutflag_ then _startpos_mutflag_ - else _startpos_name_ + let vis = + let _endpos = _endpos_attr_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - ({ - Parsing_syntax.field_name = - { Parsing_syntax.label = name; loc_ = i _loc_name_ }; - field_ty = ty; - field_mut = mutflag <> None; - field_vis; - field_loc_ = i _sloc; - } - : Parsing_syntax.field_decl) - -let _menhir_action_552 _endpos_name_ _startpos_name_ name = - let x = ([], false) in - let l = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } + let attrs = [] in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_594 _1 _endpos_binder_name_ _startpos_binder_name_ + binder_name = + let t = + let _1 = None in + _1 + in + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_595 _1 _endpos_binder_name_ _startpos_binder_name_ + binder_name t = + let t = + let _1 = + let x = t in + Some x in - let _endpos_l_, _startpos_l_ = (_endpos_name_, _startpos_name_) in - let _endpos = _endpos_l_ in - let _symbolstartpos = _startpos_l_ in - let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l (label_to_expr ~loc_:(i _sloc) l) true + _1 in - (let fs, trailing = x in - let trailing = - if fs = [] || trailing then Parsing_syntax.Trailing_comma - else Parsing_syntax.Trailing_none - in - (l :: fs, trailing) - : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) - -let _menhir_action_553 _1 _endpos_name_ _startpos_name_ name = - let x = _1 in - let l = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } + let vis = Parsing_syntax.Vis_default in + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_596 _1 _endpos__1_inlined1_ _endpos_binder_name_ + _startpos__1_inlined1_ _startpos_binder_name_ binder_name = + let t = + let _1 = None in + _1 + in + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - let _endpos_l_, _startpos_l_ = (_endpos_name_, _startpos_name_) in - let _endpos = _endpos_l_ in - let _symbolstartpos = _startpos_l_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l (label_to_expr ~loc_:(i _sloc) l) true + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (let fs, trailing = x in - let trailing = - if fs = [] || trailing then Parsing_syntax.Trailing_comma - else Parsing_syntax.Trailing_none - in - (l :: fs, trailing) - : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) - -let _menhir_action_554 _endpos_e_ _endpos_name_ _startpos_name_ comma e name = - let l = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_597 _1 _endpos__1_inlined1_ _endpos_binder_name_ + _startpos__1_inlined1_ _startpos_binder_name_ binder_name t = + let t = + let _1 = + let x = t in + Some x in - let _startpos_l_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_l_ in - let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l e false + _1 in - (( [ l ], - if Option.is_some comma then Parsing_syntax.Trailing_comma - else Parsing_syntax.Trailing_none ) - : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) - -let _menhir_action_555 _endpos_e_ _endpos_name_ _startpos_name_ e name x = - let l = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } + let vis = + let _endpos__1_, _startpos__1_ = + (_endpos__1_inlined1_, _startpos__1_inlined1_) in - let _startpos_l_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_l_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l e false + Parsing_syntax.Vis_priv { loc_ = i _sloc } in - (match x with - | fs, true -> (l :: fs, Parsing_syntax.Trailing_comma) - | fs, false -> (l :: fs, Parsing_syntax.Trailing_none) - : Parsing_syntax.field_def list * Parsing_syntax.trailing_mark) - -let _menhir_action_556 _endpos_e_ _endpos_name_ _startpos_name_ e name = - let _1 = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } - in - let _startpos_l_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_l_ in - let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l e false - in - (_1 : Parsing_syntax.field_def) - -let _menhir_action_557 _endpos_name_ _startpos_name_ name = - let _1 = - let l = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.label_name = name; loc_ = i _loc } - in - let _endpos_l_, _startpos_l_ = (_endpos_name_, _startpos_name_) in - let _endpos = _endpos_l_ in - let _symbolstartpos = _startpos_l_ in - let _sloc = (_symbolstartpos, _endpos) in - make_field_def ~loc_:(i _sloc) l (label_to_expr ~loc_:(i _sloc) l) true + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_598 _1 _endpos_attr_ _endpos_binder_name_ + _startpos__1_inlined1_ _startpos_binder_name_ attr binder_name = + let t = + let _1 = None in + _1 in - (_1 : Parsing_syntax.field_def) - -let _menhir_action_558 t : Parsing_syntax.typ * Parsing_syntax.error_typ = - (t, No_error_typ) - -let _menhir_action_559 _endpos__2_ _startpos__2_ t1 = - let _loc__2_ = (_startpos__2_, _endpos__2_) in - ((t1, Default_error_typ { loc_ = i _loc__2_ }) - : Parsing_syntax.typ * Parsing_syntax.error_typ) - -let _menhir_action_560 t1 t2 : Parsing_syntax.typ * Parsing_syntax.error_typ = - (t1, Error_typ { ty = t2 }) - -let _menhir_action_561 _1 _endpos__1_ _startpos__1_ = - let x = - let _endpos = _endpos__1_ in + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.tvc_trait = _1; loc_ = i _sloc } + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - ([ x ] : Parsing_syntax.tvar_constraint list) - -let _menhir_action_562 _endpos__2_ _startpos_id_ id = - let x = - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos_id_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.tvc_trait = Lident (id ^ "?"); loc_ = i _sloc } + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_599 _1 _endpos_attr_ _endpos_binder_name_ + _startpos__1_inlined1_ _startpos_binder_name_ attr binder_name t = + let t = + let _1 = + let x = t in + Some x + in + _1 in - ([ x ] : Parsing_syntax.tvar_constraint list) - -let _menhir_action_563 _1 _endpos__1_ _startpos__1_ xs = - let x = - let _endpos = _endpos__1_ in + let vis = + let _startpos__1_ = _startpos__1_inlined1_ in + let _endpos = _endpos_attr_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.tvc_trait = _1; loc_ = i _sloc } - in - (x :: xs : Parsing_syntax.tvar_constraint list) - -let _menhir_action_564 _endpos__2_inlined1_ _startpos_id_ id xs = - let x = - let _endpos__2_ = _endpos__2_inlined1_ in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos_id_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.tvc_trait = Lident (id ^ "?"); loc_ = i _sloc } - in - (x :: xs : Parsing_syntax.tvar_constraint list) - -let _menhir_action_565 _endpos__3_ _startpos__1_ x = - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let fs, trailing = x in - make_Pexpr_record ~loc_:(i _sloc) ~trailing None fs - : Parsing_syntax.expr) - -let _menhir_action_566 _endpos__5_ _endpos_name_ _startpos_name_ name = - let x = ([], false) in - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let _startpos_type_name_ = _startpos_name_ in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_type_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (let fs, trailing = x in - let trailing = - if trailing then Parsing_syntax.Trailing_comma - else Parsing_syntax.Trailing_none - in - make_Pexpr_record ~loc_:(i _sloc) ~trailing (Some type_name) fs - : Parsing_syntax.expr) - -let _menhir_action_567 _1 _endpos__5_ _endpos_name_ _startpos_name_ name = - let x = _1 in - let type_name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } + Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } in - let _startpos_type_name_ = _startpos_name_ in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_type_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (let fs, trailing = x in - let trailing = - if trailing then Parsing_syntax.Trailing_comma - else Parsing_syntax.Trailing_none - in - make_Pexpr_record ~loc_:(i _sloc) ~trailing (Some type_name) fs - : Parsing_syntax.expr) - -let _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe = - let type_name = None in - let _endpos_type_name_, _startpos_type_name_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos__5_ in + let attrs = _1 in + let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in + (( attrs, + true, + vis, + { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, + t ) + : Parsing_syntax.attribute list + * bool + * Parsing_syntax.visibility + * Parsing_syntax.binder + * Parsing_syntax.typ option) + +let _menhir_action_600 _endpos_label_ _endpos_while_else_ _startpos__2_ + _startpos_label_ body cond label while_else = + let _endpos = _endpos_while_else_ in let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ + if _startpos_label_ != _endpos_label_ then _startpos_label_ else _startpos__2_ in let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = []; loc_ = i _sloc } + (Parsing_syntax.Pexpr_while + { loc_ = i _sloc; loop_cond = cond; loop_body = body; while_else; label } : Parsing_syntax.expr) -let _menhir_action_569 _endpos__2_inlined1_ _endpos__5_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe = - let type_name = - let x = - let x = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - x - in - Some x - in - let _endpos_type_name_, _startpos_type_name_ = - (_endpos__2_inlined1_, _startpos_name_) - in - let _endpos = _endpos__5_ in - let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ - else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = []; loc_ = i _sloc } - : Parsing_syntax.expr) +let _menhir_print_token : token -> string = + fun _tok -> + match _tok with + | Lex_menhir_token.AMPER -> "AMPER" + | Lex_menhir_token.AMPERAMPER -> "AMPERAMPER" + | Lex_menhir_token.AS -> "AS" + | Lex_menhir_token.ASYNC -> "ASYNC" + | Lex_menhir_token.ATTRIBUTE _ -> "ATTRIBUTE" + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ -> "AUGMENTED_ASSIGNMENT" + | Lex_menhir_token.BAR -> "BAR" + | Lex_menhir_token.BARBAR -> "BARBAR" + | Lex_menhir_token.BREAK -> "BREAK" + | Lex_menhir_token.BYTE _ -> "BYTE" + | Lex_menhir_token.BYTES _ -> "BYTES" + | Lex_menhir_token.CARET -> "CARET" + | Lex_menhir_token.CATCH -> "CATCH" + | Lex_menhir_token.CHAR _ -> "CHAR" + | Lex_menhir_token.COLON -> "COLON" + | Lex_menhir_token.COLONCOLON -> "COLONCOLON" + | Lex_menhir_token.COMMA -> "COMMA" + | Lex_menhir_token.COMMENT _ -> "COMMENT" + | Lex_menhir_token.CONST -> "CONST" + | Lex_menhir_token.CONTINUE -> "CONTINUE" + | Lex_menhir_token.DERIVE -> "DERIVE" + | Lex_menhir_token.DOTDOT -> "DOTDOT" + | Lex_menhir_token.DOT_INT _ -> "DOT_INT" + | Lex_menhir_token.DOT_LIDENT _ -> "DOT_LIDENT" + | Lex_menhir_token.DOT_UIDENT _ -> "DOT_UIDENT" + | Lex_menhir_token.ELLIPSIS -> "ELLIPSIS" + | Lex_menhir_token.ELSE -> "ELSE" + | Lex_menhir_token.ENUM -> "ENUM" + | Lex_menhir_token.EOF -> "EOF" + | Lex_menhir_token.EQUAL -> "EQUAL" + | Lex_menhir_token.EXCLAMATION -> "EXCLAMATION" + | Lex_menhir_token.EXTERN -> "EXTERN" + | Lex_menhir_token.FALSE -> "FALSE" + | Lex_menhir_token.FAT_ARROW -> "FAT_ARROW" + | Lex_menhir_token.FLOAT _ -> "FLOAT" + | Lex_menhir_token.FN -> "FN" + | Lex_menhir_token.FOR -> "FOR" + | Lex_menhir_token.GUARD -> "GUARD" + | Lex_menhir_token.IF -> "IF" + | Lex_menhir_token.IMPL -> "IMPL" + | Lex_menhir_token.IMPORT -> "IMPORT" + | Lex_menhir_token.IN -> "IN" + | Lex_menhir_token.INFIX1 _ -> "INFIX1" + | Lex_menhir_token.INFIX2 _ -> "INFIX2" + | Lex_menhir_token.INFIX3 _ -> "INFIX3" + | Lex_menhir_token.INFIX4 _ -> "INFIX4" + | Lex_menhir_token.INT _ -> "INT" + | Lex_menhir_token.INTERP _ -> "INTERP" + | Lex_menhir_token.IS -> "IS" + | Lex_menhir_token.LBRACE -> "LBRACE" + | Lex_menhir_token.LBRACKET -> "LBRACKET" + | Lex_menhir_token.LET -> "LET" + | Lex_menhir_token.LIDENT _ -> "LIDENT" + | Lex_menhir_token.LOOP -> "LOOP" + | Lex_menhir_token.LPAREN -> "LPAREN" + | Lex_menhir_token.MATCH -> "MATCH" + | Lex_menhir_token.MINUS -> "MINUS" + | Lex_menhir_token.MULTILINE_INTERP _ -> "MULTILINE_INTERP" + | Lex_menhir_token.MULTILINE_STRING _ -> "MULTILINE_STRING" + | Lex_menhir_token.MUTABLE -> "MUTABLE" + | Lex_menhir_token.NEWLINE -> "NEWLINE" + | Lex_menhir_token.PACKAGE_NAME _ -> "PACKAGE_NAME" + | Lex_menhir_token.PIPE -> "PIPE" + | Lex_menhir_token.PLUS -> "PLUS" + | Lex_menhir_token.POST_LABEL _ -> "POST_LABEL" + | Lex_menhir_token.PRIV -> "PRIV" + | Lex_menhir_token.PUB -> "PUB" + | Lex_menhir_token.QUESTION -> "QUESTION" + | Lex_menhir_token.RAISE -> "RAISE" + | Lex_menhir_token.RANGE_EXCLUSIVE -> "RANGE_EXCLUSIVE" + | Lex_menhir_token.RANGE_INCLUSIVE -> "RANGE_INCLUSIVE" + | Lex_menhir_token.RBRACE -> "RBRACE" + | Lex_menhir_token.RBRACKET -> "RBRACKET" + | Lex_menhir_token.READONLY -> "READONLY" + | Lex_menhir_token.RETURN -> "RETURN" + | Lex_menhir_token.RPAREN -> "RPAREN" + | Lex_menhir_token.SEMI _ -> "SEMI" + | Lex_menhir_token.STRING _ -> "STRING" + | Lex_menhir_token.STRUCT -> "STRUCT" + | Lex_menhir_token.TEST -> "TEST" + | Lex_menhir_token.THIN_ARROW -> "THIN_ARROW" + | Lex_menhir_token.THROW -> "THROW" + | Lex_menhir_token.TRAIT -> "TRAIT" + | Lex_menhir_token.TRAITALIAS -> "TRAITALIAS" + | Lex_menhir_token.TRUE -> "TRUE" + | Lex_menhir_token.TRY -> "TRY" + | Lex_menhir_token.TYPE -> "TYPE" + | Lex_menhir_token.TYPEALIAS -> "TYPEALIAS" + | Lex_menhir_token.UIDENT _ -> "UIDENT" + | Lex_menhir_token.UNDERSCORE -> "UNDERSCORE" + | Lex_menhir_token.WHILE -> "WHILE" + | Lex_menhir_token.WITH -> "WITH" -let _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe = - let fs = [] in - let type_name = None in - let _endpos_type_name_, _startpos_type_name_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ - else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } - : Parsing_syntax.expr) +let _menhir_fail : unit -> 'a = + fun () -> + Printf.eprintf + "Internal failure -- please contact the parser generator's developers.\n%!"; + assert false -let _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe = - let fs = _1 in - let type_name = None in - let _endpos_type_name_, _startpos_type_name_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ - else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } - : Parsing_syntax.expr) +include struct + [@@@ocaml.warning "-4-37-39"] -let _menhir_action_572 _endpos__2_inlined1_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe = - let fs = [] in - let type_name = - let x = - let x = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - x - in - Some x - in - let _endpos_type_name_, _startpos_type_name_ = - (_endpos__2_inlined1_, _startpos_name_) - in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ - else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } - : Parsing_syntax.expr) + let rec _menhir_run_0670 : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_expression = + fun _menhir_stack -> + fun _v -> + fun _tok -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EOF -> + let _1 = _v in + let _v = _menhir_action_070 _1 in + MenhirBox_expression _v + | _ -> _eRR () + + let rec _menhir_goto_list_semis_structure_item_ : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_structure = + fun _menhir_stack -> + fun _v -> + fun _tok -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EOF -> + let _1 = _v in + let _v = _menhir_action_483 _1 in + MenhirBox_structure _v + | _ -> _eRR () + + let rec _menhir_run_1349 : type ttv_stack. + ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _tok -> + let (MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_281 xs in + let _1 = _v in + let _v = _menhir_action_274 _1 in + let _1 = _v in + let _v = _menhir_action_159 _1 in + _menhir_goto_list_semis_structure_item_ _menhir_stack _v _tok + + let rec _menhir_run_0001 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_418 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_573 _1 _endpos__2_inlined1_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe = - let fs = _1 in - let type_name = - let x = - let x = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - x - in - Some x - in - let _endpos_type_name_, _startpos_type_name_ = - (_endpos__2_inlined1_, _startpos_name_) - in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_type_name_ != _endpos_type_name_ then _startpos_type_name_ - else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_record_update { type_name; record = oe; fields = fs; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_goto_simple_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0841 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0384 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0124 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0385 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LBRACKET -> ( + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACKET (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0395 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0395 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0395 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0395 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0395 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0395 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0395 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0395 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0395 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0395 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0395 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0395 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0395 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0395 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0395) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COLON -> + let _v_16 = _menhir_action_324 () in + _menhir_run_0396 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _v_16 MenhirState0395 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0402 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v_17 -> ( + let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0411 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0415 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EXCLAMATION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0418 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ + | Lex_menhir_token.EQUAL -> + let ( _endpos_name_, + _startpos_name_, + name, + _startpos_record_, + record ) = + (_endpos_19, _startpos_18, _v_17, _startpos, _v) + in + let _v = + _menhir_action_123 _endpos_name_ _startpos_name_ name + record + in + _menhir_goto_left_value _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos_record_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let ( _endpos_name_, + _startpos_name_, + name, + _startpos_record_, + record ) = + (_endpos_19, _startpos_18, _v_17, _startpos, _v) + in + let _v = + _menhir_action_436 _endpos_name_ _startpos_name_ + _startpos_record_ name record + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_name_ _startpos_record_ _v _menhir_s + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.DOT_INT _v_20 -> ( + let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ + | Lex_menhir_token.EQUAL -> + let ( _startpos_record_, + record, + _endpos_index_, + _startpos_index_, + index ) = + (_startpos, _v, _endpos_22, _startpos_21, _v_20) + in + let _v = + _menhir_action_124 _endpos_index_ _startpos_index_ index + record + in + _menhir_goto_left_value _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos_record_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let ( _startpos_record_, + record, + _endpos_index_, + _startpos_index_, + index ) = + (_startpos, _v, _endpos_22, _startpos_21, _v_20) + in + let _v = + _menhir_action_437 _endpos_index_ _startpos_index_ + _startpos_record_ index record + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_index_ _startpos_record_ _v + _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0427 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_367 _1 in + _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_574 _endpos__3_ _endpos_xs_ _startpos__1_ _startpos_xs_ xs = - let x = - let _1 = - let semi = None in - (xs, Option.is_some semi) - in - let _endpos__1_, _startpos__1_ = (_endpos_xs_, _startpos_xs_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - let ls, trailing = _1 in - (Parsing_compact.compact_rev ls (i _sloc), trailing) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (match x with - | ( (Parsing_syntax.Pexpr_ident { id = { var_name = Lident str; loc_ }; _ } - as expr), - trailing ) -> - let label = { Parsing_syntax.label_name = str; loc_ } in - let field = make_field_def ~loc_:(i _sloc) label expr true in - let trailing = - if trailing then Parsing_syntax.Trailing_semi - else Parsing_syntax.Trailing_none + and _menhir_run_0124 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) in - make_Pexpr_record ~loc_:(i _sloc) ~trailing None [ field ] - | expr, _ -> Pexpr_group { expr; group = Group_brace; loc_ = i _sloc } - : Parsing_syntax.expr) + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0125 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0125 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0458 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0125) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0002 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.IF | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_030 _endpos_name_ _startpos_name_ name in + _menhir_goto_constr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_name_ _startpos_name_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_174 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_constr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1069 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0282 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0128 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0181 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0155 -> + _menhir_run_0158 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0282 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_c_, _startpos_c_, c = (_endpos, _startpos, _v) in + let _v = _menhir_action_420 _endpos_c_ _startpos_c_ c in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_c_ _startpos_c_ _v _menhir_s _tok _menhir_initp -let _menhir_action_575 _endpos__3_ _endpos_x_ _startpos__1_ _startpos_xs_ x xs = - let x = - let _1 = - let semi = Some x in - (xs, Option.is_some semi) - in - let _endpos__1_, _startpos__1_ = (_endpos_x_, _startpos_xs_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - let ls, trailing = _1 in - (Parsing_compact.compact_rev ls (i _sloc), trailing) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (match x with - | ( (Parsing_syntax.Pexpr_ident { id = { var_name = Lident str; loc_ }; _ } - as expr), - trailing ) -> - let label = { Parsing_syntax.label_name = str; loc_ } in - let field = make_field_def ~loc_:(i _sloc) label expr true in - let trailing = - if trailing then Parsing_syntax.Trailing_semi - else Parsing_syntax.Trailing_none - in - make_Pexpr_record ~loc_:(i _sloc) ~trailing None [ field ] - | expr, _ -> Pexpr_group { expr; group = Group_brace; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_576 _endpos__3_ _startpos__1_ = - let elems = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_map { elems; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_577 _1_inlined1 _endpos__3_ _startpos__1_ = - let elems = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_map { elems; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_578 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0158 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_constr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0159 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0160 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0161 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.DOTDOT -> + _menhir_run_0170 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.LBRACE | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_300 () in + _menhir_goto_option___anonymous_15_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_579 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0129 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_452 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_580 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt x xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_simple_pattern : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0181 -> + _menhir_run_0182 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0155 -> + _menhir_run_0156 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0128 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0154 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0182 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_pattern + _menhir_cell0_RANGE_EXCLUSIVE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_pattern + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = _menhir_action_381 _endpos_rhs_ _startpos_lhs_ lhs rhs in + _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp -let _menhir_action_581 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ ty_opt = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_range_pattern : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0128 -> + _menhir_run_0256 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0163 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0256 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_range_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_range_expr + (_menhir_stack, _menhir_s, expr, _startpos_expr_, _)) = + _menhir_stack + in + let _endpos_pat_, pat = (_endpos, _v) in + let _v = _menhir_action_363 _endpos_pat_ _startpos_expr_ expr pat in + _menhir_goto_postfix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_pat_ _startpos_expr_ _v _menhir_s _tok _menhir_initp -let _menhir_action_582 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ ty_opt xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_postfix_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_121 _1 in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_583 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ ty_opt x xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined2_) in - let has_error = true in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_infix_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0016 -> + _menhir_run_0640 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0523 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0504 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0364 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0305 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0301 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0299 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0297 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0295 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0293 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0291 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0289 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0279 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0277 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0640 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_MATCH as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.LBRACE -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0641 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0641 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_MATCH + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__2_, _endpos__3_, e = + (_endpos_4, _endpos_1, _v) + in + let _v = + _menhir_action_180 _endpos__2_ _endpos__3_ _startpos__1_ e + in + _menhir_goto_match_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0641 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.LIDENT _v_6 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0641 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.INT _v_7 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0641 _menhir_initp + | Lex_menhir_token.FLOAT _v_8 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0641 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | Lex_menhir_token.CHAR _v_9 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0641 _menhir_initp + | Lex_menhir_token.BYTES _v_10 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0641 _menhir_initp + | Lex_menhir_token.BYTE _v_11 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0641 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState0640, _startpos_0, _endpos_1) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0641 _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.INFIX4 _v_12 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0640 _menhir_initp + | Lex_menhir_token.INFIX3 _v_13 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0640 _menhir_initp + | Lex_menhir_token.INFIX2 _v_14 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0640 _menhir_initp + | Lex_menhir_token.INFIX1 _v_15 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_15 MenhirState0640 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0640 _menhir_initp + | _ -> _eRR () -let _menhir_action_584 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) - -let _menhir_action_585 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0278 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_PLUS (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0278 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_586 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt x xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0004 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_397 () in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_587 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ ty_opt = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_simple_constant : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0026 -> + _menhir_run_0608 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0616 -> + _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0197 -> + _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0139 -> + _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0608 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_022 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_atomic_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COLON -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_176 _1 in + _menhir_goto_map_syntax_key _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_588 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ ty_opt xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_atomic_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_e_, _startpos_e_, e = (_endpos, _startpos, _v) in + let _v = _menhir_action_417 e in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_e_ _startpos_e_ _v _menhir_s _tok _menhir_initp -let _menhir_action_589 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ ty_opt x xs = - let f = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_f_ = _endpos__3_inlined1_ in - let ps = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_ps_, _startpos_ps_ = (_endpos__3_, _startpos__1_inlined1_) in - let has_error = false in - let _endpos = _endpos_f_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ps_ = (_startpos_ps_, _endpos_ps_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Lambda - { - parameters = ps; - has_error; - params_loc_ = i _loc_ps_; - body = f; - return_type = ty_opt; - kind_ = Lambda; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_map_syntax_key : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0026 -> + _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0616 -> + _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0139 -> + _menhir_run_0212 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0197 -> + _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0617 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_map_syntax_key + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0618 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_590 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ = - let cases = [] in - let _endpos_cases_, _startpos_cases_ = - (_endpos__3_inlined1_, _endpos__3_inlined1_) - in - let has_error = - let has_error = true in - has_error - in - let _endpos_has_error_, _startpos_has_error_ = - (_endpos__3_inlined1_, _startpos__1_) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_has_error_ in - let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Match - { - cases; - has_error; - loc_ = i _loc_cases_; - fn_loc_ = i _loc_has_error_; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0003 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_TRY (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0003 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_591 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ - _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined2_ = - let cases = - let _1 = _1_inlined2 in - _1 - in - let _endpos_cases_, _startpos_cases_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let has_error = - let has_error = true in - has_error - in - let _endpos_has_error_, _startpos_has_error_ = - (_endpos__3_inlined1_, _startpos__1_) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_has_error_ in - let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Match - { - cases; - has_error; - loc_ = i _loc_cases_; - fn_loc_ = i _loc_has_error_; - }; - } - : Parsing_syntax.expr) + and _menhir_run_0005 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_404 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0006 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0007 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_POST_LABEL -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, label, _startpos_label_, _endpos_label_)) + = + _menhir_stack + in + let _endpos__2_ = _endpos in + let _v = _menhir_action_171 _endpos_label_ _startpos_label_ label in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__2_ _startpos_label_ _v _menhir_s _tok _menhir_initp -let _menhir_action_592 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ = - let cases = [] in - let _endpos_cases_, _startpos_cases_ = - (_endpos__3_inlined1_, _endpos__3_inlined1_) - in - let has_error = - let has_error = false in - has_error - in - let _endpos_has_error_, _startpos_has_error_ = - (_endpos__3_inlined1_, _startpos__1_) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_has_error_ in - let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Match - { - cases; - has_error; - loc_ = i _loc_cases_; - fn_loc_ = i _loc_has_error_; - }; - } - : Parsing_syntax.expr) - -let _menhir_action_593 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ - _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined1_ = - let cases = - let _1 = _1_inlined1 in - _1 - in - let _endpos_cases_, _startpos_cases_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let has_error = - let has_error = false in - has_error - in - let _endpos_has_error_, _startpos_has_error_ = - (_endpos__3_inlined1_, _startpos__1_) - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_has_error_ in - let _loc_has_error_ = (_startpos_has_error_, _endpos_has_error_) in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_function - { - loc_ = i _sloc; - func = - Match - { - cases; - has_error; - loc_ = i _loc_cases_; - fn_loc_ = i _loc_has_error_; - }; - } - : Parsing_syntax.expr) + and _menhir_goto_loop_label_colon : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_loop_label_colon + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WHILE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_WHILE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0304 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LOOP -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LOOP (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0310 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos_30 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos_30, _endpos_31) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0326 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0325 _menhir_initp + | Lex_menhir_token.LIDENT _v_32 -> ( + let _startpos_33 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_34 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _menhir_stack = + MenhirCell1_LIDENT + ( _menhir_stack, + MenhirState0325, + _v_32, + _startpos_33, + _endpos_34 ) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0328 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.IN -> + let _v_50 = + let _endpos_name_, _startpos_name_, name = + (_endpos_34, _startpos_33, _v_32) + in + _menhir_action_084 _endpos_name_ _startpos_name_ name + in + _menhir_run_0347 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_50 MenhirState0325 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState0325 in + let _v = _menhir_action_142 () in + _menhir_goto_list_commas_no_trailing___anonymous_10_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s + _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_594 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_bool true in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_run_0008 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_PLUS (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0008 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_595 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_bool false in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_run_0009 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DOT_UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) + in + _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v_1 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.DOTDOT + | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_1, _startpos, _v) + in + let _v = _menhir_action_374 id ps in + _menhir_goto_qual_ident_simple_expr _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_ps_ _v + _menhir_s _tok _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_1, _startpos, _v) + in + let _v = _menhir_action_376 id ps in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0010 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_PACKAGE_NAME -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.IF | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_PACKAGE_NAME + (_menhir_stack, _menhir_s, pkg, _startpos_pkg_)) = + _menhir_stack + in + let _endpos_constr_name_, _startpos_constr_name_, constr_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_031 _endpos_constr_name_ _startpos_constr_name_ + _startpos_pkg_ constr_name pkg + in + _menhir_goto_constr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_constr_name_ _startpos_pkg_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let (MenhirCell1_PACKAGE_NAME + (_menhir_stack, _menhir_s, ps, _startpos_ps_)) = + _menhir_stack + in + let _endpos_id_, id = (_endpos, _v) in + let _v = _menhir_action_377 id ps in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_596 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_byte _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_qual_ident_ty : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0716 -> + _menhir_run_0704 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0698 -> + _menhir_run_0704 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0702 -> + _menhir_run_0704 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1325 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1311 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1299 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1283 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1272 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1258 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1246 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1230 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1214 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1197 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1183 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1171 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1155 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1139 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1112 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1062 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1047 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1035 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1019 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1008 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0994 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0982 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0966 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0950 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0933 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0917 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0899 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0876 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0860 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0765 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0759 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0694 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0257 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0128 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0181 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0155 -> + _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0112 -> + _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1322 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + _menhir_run_0057 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0050 -> + _menhir_run_0051 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0704 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_537 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_tvar_constraint _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_597 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_bytes _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_tvar_constraint : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> ( + let _menhir_stack = + MenhirCell1_tvar_constraint (_menhir_stack, _menhir_s, _v) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_PLUS (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0702 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0699 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACKET -> + let x = _v in + let _v = _menhir_action_395 x in + _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0699 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__2_, _startpos_id_, id = (_endpos_1, _startpos, _v) in + let _v = _menhir_action_538 _endpos__2_ _startpos_id_ id in + _menhir_goto_tvar_constraint _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.LBRACE + | Lex_menhir_token.PLUS | Lex_menhir_token.RBRACKET -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_174 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_luident : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1317 -> + _menhir_run_1318 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1306 -> + _menhir_run_1307 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1264 -> + _menhir_run_1265 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1253 -> + _menhir_run_1254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1222 -> + _menhir_run_1223 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1216 -> + _menhir_run_1217 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1212 -> + _menhir_run_1213 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1207 -> + _menhir_run_1210 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1208 -> + _menhir_run_1209 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState1204 -> + _menhir_run_1205 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1189 -> + _menhir_run_1190 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1178 -> + _menhir_run_1179 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1147 -> + _menhir_run_1148 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1141 -> + _menhir_run_1142 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1137 -> + _menhir_run_1138 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1132 -> + _menhir_run_1135 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1133 -> + _menhir_run_1134 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState1129 -> + _menhir_run_1130 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1124 -> + _menhir_run_1125 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1114 -> + _menhir_run_1115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1110 -> + _menhir_run_1111 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1105 -> + _menhir_run_1108 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1106 -> + _menhir_run_1107 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState1102 -> + _menhir_run_1103 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1053 -> + _menhir_run_1054 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1042 -> + _menhir_run_1043 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1000 -> + _menhir_run_1001 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0989 -> + _menhir_run_0990 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0958 -> + _menhir_run_0959 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0952 -> + _menhir_run_0953 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0948 -> + _menhir_run_0949 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0943 -> + _menhir_run_0946 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0944 -> + _menhir_run_0945 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState0940 -> + _menhir_run_0941 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0925 -> + _menhir_run_0926 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0912 -> + _menhir_run_0913 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0868 -> + _menhir_run_0869 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0862 -> + _menhir_run_0863 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0858 -> + _menhir_run_0859 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0853 -> + _menhir_run_0856 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0854 -> + _menhir_run_0855 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState0850 -> + _menhir_run_0851 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0845 -> + _menhir_run_0846 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0807 -> + _menhir_run_0808 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0773 -> + _menhir_run_0774 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0755 -> + _menhir_run_0756 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0710 -> + _menhir_run_0715 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0713 -> + _menhir_run_0715 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0696 -> + _menhir_run_0697 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0692 -> + _menhir_run_0693 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0687 -> + _menhir_run_0690 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0688 -> + _menhir_run_0689 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _tok _menhir_initp + | MenhirState0675 -> + _menhir_run_0681 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0679 -> + _menhir_run_0681 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0673 -> + _menhir_run_0674 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1325 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1322 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1311 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1299 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1283 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1272 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1258 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1246 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1230 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1214 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1197 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1183 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1171 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1155 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1139 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1112 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1062 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1047 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1035 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1019 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1008 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0994 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0982 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0966 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0950 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0933 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0917 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0899 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0876 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0860 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0759 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0765 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0716 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0698 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0702 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0694 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0257 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0128 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0181 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0155 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0112 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0050 -> + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1318 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ENUM + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1318 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1318 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0675 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0675 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0676 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_598 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_char _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_run_0676 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_560 _endpos__1_ _startpos__1_ in + _menhir_goto_type_decl_binder _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_599 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_util.make_int _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_type_decl_binder : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0679 -> + _menhir_run_0680 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0675 -> + _menhir_run_0677 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0680 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__, + _menhir_box_structure ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _1 = _v in + let _v = _menhir_action_230 _1 xs in + _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_600 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_util.make_float _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ : + type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0678, _endpos) + in + _menhir_run_0676 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0679 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0678, _endpos) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0679 _menhir_initp + | Lex_menhir_token.LIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0678, _endpos) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0679 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0682 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _ = _menhir_action_286 () in + _menhir_run_0682 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0038 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_174 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0045 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0682 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_197 xs in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let _endpos__3_, x = (_endpos, _v) in + let _v = _menhir_action_321 x in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_601 _1 _endpos__1_ _startpos__1_ = - let e = - let _1 = Parsing_syntax.Const_string _1 in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_constant ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ : + type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_params_, params = (_endpos, _v) in + let _v = _menhir_action_344 params in + _menhir_goto_optional_type_parameters_no_constraints _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_params_ _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_optional_type_parameters_no_constraints : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1318 -> + _menhir_run_1319 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1307 -> + _menhir_run_1308 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1265 -> + _menhir_run_1266 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1254 -> + _menhir_run_1255 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1223 -> + _menhir_run_1224 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1210 -> + _menhir_run_1211 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1205 -> + _menhir_run_1206 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1190 -> + _menhir_run_1191 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1179 -> + _menhir_run_1180 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1148 -> + _menhir_run_1149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1135 -> + _menhir_run_1136 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1130 -> + _menhir_run_1131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1125 -> + _menhir_run_1126 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1108 -> + _menhir_run_1109 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1103 -> + _menhir_run_1104 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1054 -> + _menhir_run_1055 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1043 -> + _menhir_run_1044 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1001 -> + _menhir_run_1002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0990 -> + _menhir_run_0991 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0959 -> + _menhir_run_0960 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0946 -> + _menhir_run_0947 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0941 -> + _menhir_run_0942 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0926 -> + _menhir_run_0927 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0913 -> + _menhir_run_0914 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0869 -> + _menhir_run_0870 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0856 -> + _menhir_run_0857 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0851 -> + _menhir_run_0852 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0846 -> + _menhir_run_0847 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0690 -> + _menhir_run_0691 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0674 -> + _menhir_run_0685 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1319 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_049 _1 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_enum_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_enum_header (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_1 -> + _menhir_run_0810 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState1345 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_2 = _menhir_action_150 () in + _menhir_run_1346 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState1345 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0810 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_UIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MUTABLE -> + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0811 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.POST_LABEL _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _v_2 = _menhir_action_288 () in + _menhir_run_0812 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _endpos_1 _v_2 MenhirState0811 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_302 () in + _menhir_goto_option___anonymous_16_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0783 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_x_, _startpos_x_, x = (_endpos, _startpos, ()) in + let _v = _menhir_action_289 x in + _menhir_goto_option_MUTABLE_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_x_ _startpos_x_ _v _menhir_s _tok _menhir_initp -let _menhir_action_602 _1 _endpos__1_ _startpos__1_ = - let e = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_multiline_string { loc_ = i _sloc; elems = _1 } - in - (e : Parsing_syntax.expr) + and _menhir_goto_option_MUTABLE_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0818 -> + _menhir_run_0812 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0811 -> + _menhir_run_0812 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1090 -> + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0801 -> + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0775 -> + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0788 -> + _menhir_run_0789 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0782 -> + _menhir_run_0784 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0812 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0812 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0812 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_1 -> ( + let _v, _menhir_s = (_v_1, MenhirState0812) in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0814 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.PACKAGE_NAME _v_8 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0812 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0812 _menhir_initp + | Lex_menhir_token.LIDENT _v_9 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + MenhirState0812 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0812 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0812 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0037 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_552 _endpos__1_ _startpos__1_ in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_603 _1 _endpos__1_ _startpos__1_ = - let e = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - make_Pexpr_interp ~loc_:(i _sloc) _1 - in - (e : Parsing_syntax.expr) + and _menhir_goto_type_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1322 -> + _menhir_run_1323 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + _menhir_run_1292 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + _menhir_run_1281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + _menhir_run_1239 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + _menhir_run_1228 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + _menhir_run_1153 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + _menhir_run_1085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + _menhir_run_1080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + _menhir_run_1059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + _menhir_run_1028 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + _menhir_run_1006 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + _menhir_run_0975 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + _menhir_run_0964 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + _menhir_run_0931 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + _menhir_run_0890 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + _menhir_run_0874 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + _menhir_run_0815 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + _menhir_run_0797 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + _menhir_run_0757 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + _menhir_run_0726 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + _menhir_run_0653 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + _menhir_run_0570 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + _menhir_run_0497 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + _menhir_run_0094 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + _menhir_run_0082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + _menhir_run_0056 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1323 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell0_CONST (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_595 _1 _endpos_binder_name_ + _startpos_binder_name_ binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_604 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_hole { loc_ = i _sloc; kind = Incomplete } : Parsing_syntax.expr) + and _menhir_run_0054 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_type_ -> _ -> _ -> _ -> ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_type_ (_menhir_stack, _menhir_s, ty, _startpos_ty_, _)) + = + _menhir_stack + in + let _endpos__2_, _startpos__2_ = (_endpos, _startpos) in + let _v = _menhir_action_539 _endpos__2_ _startpos__2_ _startpos_ty_ ty in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ + _startpos_ty_ _v _menhir_s _tok _menhir_initp -let _menhir_action_605 _endpos_var_name_ _startpos_var_name_ var_name = - let _endpos = _endpos_var_name_ in - let _symbolstartpos = _startpos_var_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Pexpr_ident ~loc_:(i _sloc) { var_name; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_goto_val_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_val_header (_menhir_stack, _menhir_s, _v, _startpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState1069 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0012 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_182 _1 in + _menhir_goto_multiline_string _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_multiline_string : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1069 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0266 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0263 -> + _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_606 _endpos_name_ _startpos_name_ name = - let c = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _loc = (_startpos, _endpos) in - { - Parsing_syntax.constr_name = { name; loc_ = i _loc_name_ }; - extra_info = No_extra_info; - loc_ = i _loc; - } - in - let _endpos_c_, _startpos_c_ = (_endpos_name_, _startpos_name_) in - let _endpos = _endpos_c_ in - let _symbolstartpos = _startpos_c_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_constr { loc_ = i _sloc; constr = c } - : Parsing_syntax.expr) + and _menhir_run_0266 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_x_, _startpos_x_, x = (_endpos, _startpos, _v) in + let _v = _menhir_action_254 x in + _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s + _tok _menhir_initp -let _menhir_action_607 _endpos_constr_name_ _startpos_constr_name_ - _startpos_pkg_ constr_name pkg = - let c = - let _endpos = _endpos_constr_name_ in - let _symbolstartpos = _startpos_pkg_ in - let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in - let _sloc = (_symbolstartpos, _endpos) in - { - Parsing_syntax.constr_name = - { name = constr_name; loc_ = i _loc_constr_name_ }; - extra_info = Package pkg; - loc_ = i _sloc; - } - in - let _endpos_c_, _startpos_c_ = (_endpos_constr_name_, _startpos_pkg_) in - let _endpos = _endpos_c_ in - let _symbolstartpos = _startpos_c_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_constr { loc_ = i _sloc; constr = c } - : Parsing_syntax.expr) + and _menhir_goto_non_empty_list_rev_multiline_string_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MULTILINE_STRING _v_0 -> + let _menhir_stack = + MenhirCell1_non_empty_list_rev_multiline_string_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0263 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_1 -> + let _menhir_stack = + MenhirCell1_non_empty_list_rev_multiline_string_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0263 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.DOTDOT + | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos_xs_, _startpos_xs_, xs = (_endpos, _startpos, _v) in + let _v = _menhir_action_188 xs in + let _endpos, _startpos = (_endpos_xs_, _startpos_xs_) in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_023 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_atomic_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_608 _endpos_constr_name_ _endpos_type_name_ - _startpos_constr_name_ _startpos_type_name_ constr_name type_name = - let c = - let _endpos = _endpos_constr_name_ in - let _symbolstartpos = _startpos_type_name_ in - let _loc_type_name_ = (_startpos_type_name_, _endpos_type_name_) in - let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in - let _sloc = (_symbolstartpos, _endpos) in - { - Parsing_syntax.constr_name = - { name = constr_name; loc_ = i _loc_constr_name_ }; - extra_info = Type_name { name = type_name; loc_ = i _loc_type_name_ }; - loc_ = i _sloc; - } - in - let _endpos_c_, _startpos_c_ = (_endpos_constr_name_, _startpos_type_name_) in - let _endpos = _endpos_c_ in - let _symbolstartpos = _startpos_c_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_constr { loc_ = i _sloc; constr = c } - : Parsing_syntax.expr) + and _menhir_run_0013 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_183 _1 in + _menhir_goto_multiline_string _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_609 _endpos__5_ _endpos_func_ _startpos_func_ func = - let args = [] in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _loc_func_ = (_startpos_func_, _endpos_func_) in - let _sloc = (_symbolstartpos, _endpos) in - (let func : Parsing_syntax.expr = - let loc_ = i _loc_func_ in - Pexpr_ident { id = { var_name = Lident func; loc_ }; loc_ } - in - Pexpr_apply { func; args; loc_ = i _sloc; attr = Question } - : Parsing_syntax.expr) + and _menhir_run_0264 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_rev_multiline_string_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_rev_multiline_string_ + (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = + _menhir_stack + in + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_255 x xs in + _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s + _tok _menhir_initp -let _menhir_action_610 _1 _endpos__5_ _endpos_func_ _startpos_func_ func = - let args = _1 in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _loc_func_ = (_startpos_func_, _endpos_func_) in - let _sloc = (_symbolstartpos, _endpos) in - (let func : Parsing_syntax.expr = - let loc_ = i _loc_func_ in - Pexpr_ident { id = { var_name = Lident func; loc_ }; loc_ } - in - Pexpr_apply { func; args; loc_ = i _sloc; attr = Question } - : Parsing_syntax.expr) + and _menhir_run_0014 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0014 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_611 _endpos__5_ _startpos_func_ func = - let args = [] in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) + and _menhir_run_0015 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0015 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_130 () in + _menhir_goto_list_commas_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_612 _1 _endpos__5_ _startpos_func_ func = - let args = _1 in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) - -let _menhir_action_613 _endpos__5_ _startpos_func_ func = - let args = [] in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) - -let _menhir_action_614 _1_inlined1 _endpos__5_ _startpos_func_ func = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) - -let _menhir_action_615 _endpos__5_ _startpos_func_ func = - let args = [] in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) - -let _menhir_action_616 _1_inlined1 _endpos__5_ _startpos_func_ func = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos_func_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_apply { func; args; loc_ = i _sloc; attr } : Parsing_syntax.expr) - -let _menhir_action_617 _endpos__4_ _startpos_array_ array index = - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos_array_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_array_get { array; index; loc_ = i _sloc } : Parsing_syntax.expr) - -let _menhir_action_618 _endpos__6_ _startpos__2_ _startpos_array_ array = - let end_index = None in - let start_index = None in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_array_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_array_get_slice - { - array; - start_index; - end_index; - loc_ = i _sloc; - index_loc_ = i (_startpos__2_, _endpos__6_); - } - : Parsing_syntax.expr) - -let _menhir_action_619 _endpos__6_ _startpos__2_ _startpos_array_ array x = - let end_index = Some x in - let start_index = None in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_array_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_array_get_slice - { - array; - start_index; - end_index; - loc_ = i _sloc; - index_loc_ = i (_startpos__2_, _endpos__6_); - } - : Parsing_syntax.expr) - -let _menhir_action_620 _endpos__6_ _startpos__2_ _startpos_array_ array x = - let end_index = None in - let start_index = Some x in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_array_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_array_get_slice - { - array; - start_index; - end_index; - loc_ = i _sloc; - index_loc_ = i (_startpos__2_, _endpos__6_); - } - : Parsing_syntax.expr) - -let _menhir_action_621 _endpos__6_ _startpos__2_ _startpos_array_ array x - x_inlined1 = - let end_index = - let x = x_inlined1 in - Some x - in - let start_index = Some x in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_array_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_array_get_slice - { - array; - start_index; - end_index; - loc_ = i _sloc; - index_loc_ = i (_startpos__2_, _endpos__6_); - } - : Parsing_syntax.expr) - -let _menhir_action_622 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_623 _1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = _1 in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_624 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_625 _1_inlined1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_626 _endpos__6_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_627 _1_inlined1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__6_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = false; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_628 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_run_0016 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_MATCH (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0016 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_629 _1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = _1 in - let attr = Parsing_syntax.No_attr in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_run_0017 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0018 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_373 i in + _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0018 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT -> _ -> _ -> _ -> ttv_result + = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0019 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0019 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0019 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0019 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0638 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0019 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0020 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_label_, _startpos_label_, label = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_004 _endpos_label_ _startpos_label_ label + in + _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_argument : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0761 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0394 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0389 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0394 : type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_213 x in + _menhir_goto_non_empty_list_commas_rev_argument_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_630 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_goto_non_empty_list_commas_rev_argument_ : + type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_argument_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0387 _menhir_initp + | Lex_menhir_token.TRY -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0387 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0387 _menhir_initp + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0387 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0387 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0387 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.MATCH -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.LIDENT _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0387 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.INTERP _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0387 _menhir_initp + | Lex_menhir_token.INT _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0387 _menhir_initp + | Lex_menhir_token.IF -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.FLOAT _v_9 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0387 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.CHAR _v_10 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0387 _menhir_initp + | Lex_menhir_token.BYTES _v_11 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0387 _menhir_initp + | Lex_menhir_token.BYTE _v_12 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0387 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0387 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0386, _endpos) + in + let _menhir_s = MenhirState0387 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0390 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0390 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0021 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) + in + _menhir_run_0019 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos__2_, _startpos__2_, _endpos_id_, _startpos_id_, id + = + (_endpos_1, _startpos_0, _endpos, _startpos, _v) + in + let _v = + _menhir_action_005 _endpos__2_ _endpos_id_ _startpos__2_ + _startpos_id_ id + in + _menhir_goto_argument _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos__1_, _startpos__1_ = (_endpos_1, _startpos_0) in + let _v = _menhir_action_340 _endpos__1_ _startpos__1_ in + _menhir_goto_optional_question _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _v = _menhir_action_341 () in + _menhir_goto_optional_question _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.COMMA + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE + | Lex_menhir_token.RPAREN -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_373 i in + _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_optional_question : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _menhir_stack = MenhirCell0_optional_question (_menhir_stack, _v) in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0024 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_631 _1_inlined1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Exclamation in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_run_0025 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0025 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.DOTDOT -> + _menhir_run_0626 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _v = _menhir_action_138 () in + _menhir_goto_list_commas_spreadable_elem_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_632 _endpos__7_ _endpos_meth_ _startpos_meth_ _startpos_self_ - meth self = - let args = [] in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_633 _1_inlined1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self = - let args = - let _1 = _1_inlined1 in - _1 - in - let attr = Parsing_syntax.Question in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos_self_ in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_dot_apply - { self; method_name; args; return_self = true; attr; loc_ = i _sloc } - : Parsing_syntax.expr) - -let _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ name - record = - let accessor = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } - in - let _endpos_accessor_ = _endpos_name_ in - let _endpos = _endpos_accessor_ in - let _symbolstartpos = _startpos_record_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_field { record; accessor; loc_ = i _sloc } : Parsing_syntax.expr) + and _menhir_run_0026 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.MINUS -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.STRING _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.INTERP _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.INT _v -> ( + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + let _v = + let _2 = _v in + _menhir_action_177 _2 + in + _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_3 _startpos_0 _v MenhirState0026 _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + let _v = + let _1 = _v in + _menhir_action_402 _1 + in + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_3 _startpos_2 _v MenhirState0590 _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.FLOAT _v -> ( + let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + let _v = + let _2 = _v in + _menhir_action_178 _2 + in + _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_5 _startpos_0 _v MenhirState0026 _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + let _v = + let _1 = _v in + _menhir_action_403 _1 + in + _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_5 _startpos_4 _v MenhirState0590 _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.CHAR _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.BYTES _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.BYTE _v -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0590 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_MINUS + (_menhir_stack, MenhirState0026, _startpos_0, _endpos_1) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0590 _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_7 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, MenhirState0026, _v, _startpos_6, _endpos_7) + in + _menhir_run_0018 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, MenhirState0026, _v, _startpos_6, _endpos_7) + in + let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_8) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_9 -> + _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0595 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_10 = _menhir_action_148 () in + _menhir_run_0596 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, MenhirState0026, _v, _startpos_6, _endpos_7) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0597 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLONCOLON -> + let _v = + let i = _v in + _menhir_action_173 i + in + _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_7 _startpos_6 _v MenhirState0026 _tok _menhir_initp + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL + -> + let _menhir_s, _endpos_i_, _startpos_i_, i = + (MenhirState0026, _endpos_7, _startpos_6, _v) + in + let _v = _menhir_action_371 i in + _menhir_goto_qual_ident _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _menhir_s, _endpos_i_, _startpos_i_, i = + (MenhirState0026, _endpos_7, _startpos_6, _v) + in + let _v = _menhir_action_373 i in + _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LET -> + _menhir_run_0484 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.GUARD -> + _menhir_run_0500 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.DOTDOT -> ( + let _menhir_s = MenhirState0026 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0602 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0026 _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0535 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0026 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v = _menhir_action_132 () in + _menhir_goto_list_commas_map_expr_elem_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0026 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_635 _endpos_index_ _startpos_index_ _startpos_record_ index - record = - let accessor = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } - in - let _endpos_accessor_ = _endpos_index_ in - let _endpos = _endpos_accessor_ in - let _symbolstartpos = _startpos_record_ in - let _sloc = (_symbolstartpos, _endpos) in - (Pexpr_field { record; accessor; loc_ = i _sloc } : Parsing_syntax.expr) + and _menhir_run_0027 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RETURN (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0027 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0027 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0027 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_324 () in + _menhir_run_0589 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_636 _endpos_meth_ _endpos_type_name_ _startpos_meth_ - _startpos_type_name_ meth type_name = - let _endpos = _endpos_meth_ in - let _symbolstartpos = _startpos_type_name_ in - let _loc_type_name_ = (_startpos_type_name_, _endpos_type_name_) in - let _loc_meth_ = (_startpos_meth_, _endpos_meth_) in - let _sloc = (_symbolstartpos, _endpos) in - (let type_name : Parsing_syntax.type_name = - { name = type_name; loc_ = i _loc_type_name_ } - in - let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i _loc_meth_ } - in - Pexpr_method { type_name; method_name; loc_ = i _sloc } - : Parsing_syntax.expr) + and _menhir_run_0028 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_024 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_atomic_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0029 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_402 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0030 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0030 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_637 _endpos__3_ _startpos__1_ = - let bs = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (match bs with - | [] -> Pexpr_unit { loc_ = i _sloc; faked = false } - | expr :: [] -> Pexpr_group { expr; group = Group_paren; loc_ = i _sloc } - | _ -> make_Pexpr_tuple ~loc_:(i _sloc) bs - : Parsing_syntax.expr) - -let _menhir_action_638 _1_inlined1 _endpos__3_ _startpos__1_ = - let bs = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (match bs with - | [] -> Pexpr_unit { loc_ = i _sloc; faked = false } - | expr :: [] -> Pexpr_group { expr; group = Group_paren; loc_ = i _sloc } - | _ -> make_Pexpr_tuple ~loc_:(i _sloc) bs - : Parsing_syntax.expr) - -let _menhir_action_639 _endpos__4_ _startpos__1_ expr t = - let ty = t in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_constraint { loc_ = i _sloc; expr; ty } - : Parsing_syntax.expr) - -let _menhir_action_640 _endpos__3_ _startpos__1_ = - let es = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Pexpr_array ~loc_:(i _sloc) es : Parsing_syntax.expr) + and _menhir_run_0031 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0031 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v = _menhir_action_337 () in + _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0031 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0032 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_336 _endpos__1_ _startpos__1_ in + _menhir_goto_optional_bang _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp -let _menhir_action_641 _1_inlined1 _endpos__3_ _startpos__1_ = - let es = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Pexpr_array ~loc_:(i _sloc) es : Parsing_syntax.expr) + and _menhir_goto_optional_bang : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1326 -> + _menhir_run_1327 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1312 -> + _menhir_run_1313 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1300 -> + _menhir_run_1301 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1294 -> + _menhir_run_1295 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1286 -> + _menhir_run_1287 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1273 -> + _menhir_run_1274 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1259 -> + _menhir_run_1260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1247 -> + _menhir_run_1248 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1241 -> + _menhir_run_1242 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1233 -> + _menhir_run_1234 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1198 -> + _menhir_run_1199 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1184 -> + _menhir_run_1185 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1172 -> + _menhir_run_1173 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1166 -> + _menhir_run_1167 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1158 -> + _menhir_run_1159 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1063 -> + _menhir_run_1064 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1048 -> + _menhir_run_1049 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1036 -> + _menhir_run_1037 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1030 -> + _menhir_run_1031 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1022 -> + _menhir_run_1023 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1009 -> + _menhir_run_1010 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0995 -> + _menhir_run_0996 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0983 -> + _menhir_run_0984 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0977 -> + _menhir_run_0978 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0969 -> + _menhir_run_0970 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0934 -> + _menhir_run_0935 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0918 -> + _menhir_run_0919 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0904 -> + _menhir_run_0905 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0892 -> + _menhir_run_0893 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0879 -> + _menhir_run_0880 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0708 -> + _menhir_run_0709 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0537 -> + _menhir_run_0538 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0527 -> + _menhir_run_0528 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0536 -> + _menhir_run_0104 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0103 -> + _menhir_run_0104 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0526 -> + _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0031 -> + _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1327 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1327 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1327 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0710 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0710 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_642 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_bool true) - : Parsing_syntax.pattern) + and _menhir_goto_option_type_parameters_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let params = _v in + let _v = _menhir_action_343 params in + _menhir_goto_optional_type_parameters _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + + and _menhir_goto_optional_type_parameters : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1327 -> + _menhir_run_1328 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1313 -> + _menhir_run_1314 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1301 -> + _menhir_run_1302 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1282 -> + _menhir_run_1283 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1274 -> + _menhir_run_1275 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1260 -> + _menhir_run_1261 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1248 -> + _menhir_run_1249 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1229 -> + _menhir_run_1230 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1199 -> + _menhir_run_1200 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1185 -> + _menhir_run_1186 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1173 -> + _menhir_run_1174 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1154 -> + _menhir_run_1155 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1064 -> + _menhir_run_1065 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1049 -> + _menhir_run_1050 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1037 -> + _menhir_run_1038 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1018 -> + _menhir_run_1019 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1010 -> + _menhir_run_1011 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0996 -> + _menhir_run_0997 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0984 -> + _menhir_run_0985 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0965 -> + _menhir_run_0966 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0935 -> + _menhir_run_0936 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0919 -> + _menhir_run_0920 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0905 -> + _menhir_run_0906 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0875 -> + _menhir_run_0876 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0709 -> + _menhir_run_0722 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1328 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1328 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1329 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1328 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0034 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0034 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0095 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0567 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_134 () in + _menhir_goto_list_commas_parameter_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_643 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_bool false) - : Parsing_syntax.pattern) + and _menhir_run_0035 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_UNDERSCORE + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0036 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_347 _endpos__1_ _startpos__1_ in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_644 _1 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_char _1) : Parsing_syntax.pattern) + and _menhir_run_0039 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DOT_UIDENT _v_0 -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_0, _startpos, _v) + in + let _v = _menhir_action_377 id ps in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) + in + _menhir_run_0041 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0041 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_PACKAGE_NAME -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_PACKAGE_NAME + (_menhir_stack, _menhir_s, ps, _startpos_ps_)) = + _menhir_stack + in + let _endpos_id_, id = (_endpos, _v) in + let _v = _menhir_action_376 id ps in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_id_ _startpos_ps_ _v _menhir_s _tok _menhir_initp -let _menhir_action_645 _1 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Parsing_util.make_int _1) - : Parsing_syntax.pattern) + and _menhir_run_0042 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0042 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0044 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_646 _1 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_double _1) - : Parsing_syntax.pattern) + and _menhir_run_0046 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_ASYNC (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0047 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0049 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_647 _2 _endpos__2_ _startpos__1_ = - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Parsing_util.make_int ("-" ^ _2)) - : Parsing_syntax.pattern) + and _menhir_run_0050 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_AMPER (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0050 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_648 _2 _endpos__2_ _startpos__1_ = - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_double ("-" ^ _2)) - : Parsing_syntax.pattern) + and _menhir_goto_parameter : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0575 -> + _menhir_run_0576 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0034 -> + _menhir_run_0573 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0576 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_parameter_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_parameter_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_236 x xs in + _menhir_goto_non_empty_list_commas_rev_parameter_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_649 _1 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_constant ~loc_:(i _sloc) (Const_string _1) - : Parsing_syntax.pattern) + and _menhir_goto_non_empty_list_commas_rev_parameter_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_parameter_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0574, _endpos) + in + _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0575 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0574, _endpos) + in + _menhir_run_0095 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0575 _menhir_initp + | Lex_menhir_token.LIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0574, _endpos) + in + _menhir_run_0567 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0575 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0577 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0577 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0095 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0096 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0563 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_binder_name_, _startpos_binder_name_, binder_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_351 _endpos_binder_name_ _startpos_binder_name_ + binder_name + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0097 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_403 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0098 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_398 () in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_650 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Ppat_any { loc_ = i _sloc } : Parsing_syntax.pattern) + and _menhir_run_0099 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_401 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0100 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_400 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0101 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_399 _1 in + _menhir_goto_simple_constant _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0102 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_ASYNC (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_FN (_menhir_stack, MenhirState0102, _startpos_0) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0103 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v = _menhir_action_337 () in + _menhir_run_0104 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0103 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_651 _endpos_name_ _startpos_name_ name = - let b = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - (Ppat_var b : Parsing_syntax.pattern) + and _menhir_run_0104 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0104 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0105 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0105 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos__3_ = _endpos in + let _v = _menhir_action_080 has_error in + _menhir_goto_fn_header_no_binder _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_652 _endpos_name_ _endpos_ps_ _startpos_name_ name ps = - let constr = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _loc = (_startpos, _endpos) in - { - Parsing_syntax.constr_name = { name; loc_ = i _loc_name_ }; - extra_info = No_extra_info; - loc_ = i _loc; - } - in - let _startpos_constr_ = _startpos_name_ in - let _endpos = _endpos_ps_ in - let _symbolstartpos = _startpos_constr_ in - let _sloc = (_symbolstartpos, _endpos) in - (let args, is_open = - match ps with - | None -> (None, false) - | Some (args, is_open) -> (Some args, is_open) - in - make_Ppat_constr ~loc_:(i _sloc) (constr, args, is_open) - : Parsing_syntax.pattern) - -let _menhir_action_653 _endpos_constr_name_ _endpos_ps_ _startpos_constr_name_ - _startpos_pkg_ constr_name pkg ps = - let constr = - let _endpos = _endpos_constr_name_ in - let _symbolstartpos = _startpos_pkg_ in - let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in - let _sloc = (_symbolstartpos, _endpos) in - { - Parsing_syntax.constr_name = - { name = constr_name; loc_ = i _loc_constr_name_ }; - extra_info = Package pkg; - loc_ = i _sloc; - } - in - let _startpos_constr_ = _startpos_pkg_ in - let _endpos = _endpos_ps_ in - let _symbolstartpos = _startpos_constr_ in - let _sloc = (_symbolstartpos, _endpos) in - (let args, is_open = - match ps with - | None -> (None, false) - | Some (args, is_open) -> (Some args, is_open) - in - make_Ppat_constr ~loc_:(i _sloc) (constr, args, is_open) - : Parsing_syntax.pattern) + and _menhir_goto_fn_header_no_binder : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0102 -> + _menhir_run_0542 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0535 -> + _menhir_run_0542 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0267 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0542 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_ASYNC as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fn_header_no_binder + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0542 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0542 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0542 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0542 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0542 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0542 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0542 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0542 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0542 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0542 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_9 = _menhir_action_152 () in + _menhir_run_0543 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + _menhir_initp + | _ -> _eRR () -let _menhir_action_654 _endpos_constr_name_ _endpos_ps_ _endpos_type_name_ - _startpos_constr_name_ _startpos_type_name_ constr_name ps type_name = - let constr = - let _endpos = _endpos_constr_name_ in - let _symbolstartpos = _startpos_type_name_ in - let _loc_type_name_ = (_startpos_type_name_, _endpos_type_name_) in - let _loc_constr_name_ = (_startpos_constr_name_, _endpos_constr_name_) in - let _sloc = (_symbolstartpos, _endpos) in - { - Parsing_syntax.constr_name = - { name = constr_name; loc_ = i _loc_constr_name_ }; - extra_info = Type_name { name = type_name; loc_ = i _loc_type_name_ }; - loc_ = i _sloc; - } - in - let _startpos_constr_ = _startpos_type_name_ in - let _endpos = _endpos_ps_ in - let _symbolstartpos = _startpos_constr_ in - let _sloc = (_symbolstartpos, _endpos) in - (let args, is_open = - match ps with - | None -> (None, false) - | Some (args, is_open) -> (Some args, is_open) - in - make_Ppat_constr ~loc_:(i _sloc) (constr, args, is_open) - : Parsing_syntax.pattern) + and _menhir_run_0130 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_442 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_655 _2 : Parsing_syntax.pattern = _2 + and _menhir_run_0131 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_450 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0132 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DOT_UIDENT _v -> + _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v -> + _menhir_run_0041 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0133 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INT _v -> + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_1, _v) in + let _v = _menhir_action_448 _2 _endpos__2_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.FLOAT _v -> + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_3, _v) in + let _v = _menhir_action_449 _2 _endpos__2_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_656 _endpos__5_ _startpos__1_ p ps = - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ppat_tuple ~loc_:(i _sloc) (p :: ps) : Parsing_syntax.pattern) + and _menhir_run_0136 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0136 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_657 _endpos__4_ _startpos__1_ pat t = - let ty = t in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_constraint { loc_ = i _sloc; pat; ty } - : Parsing_syntax.pattern) + and _menhir_run_0137 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.LBRACE | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_453 _endpos_name_ _startpos_name_ name in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_name_ _startpos_name_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0138 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.DOTDOT -> + _menhir_run_0217 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0138 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0138 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _v = _menhir_action_010 () in + _menhir_run_0238 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_658 _endpos__3_ _startpos__1_ pats = - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Ppat_array { loc_ = i _sloc; pats } : Parsing_syntax.pattern) + and _menhir_run_0139 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0139 _menhir_initp + | Lex_menhir_token.STRING _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_ = (_startpos, _endpos_0) in + let _v = _menhir_action_459 _endpos__2_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0141 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0139 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0144 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.INT _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0139 _menhir_initp + | Lex_menhir_token.DOTDOT -> ( + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, MenhirState0139, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> + _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0184 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_286 () in + _menhir_run_0185 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CHAR _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.BYTES _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | Lex_menhir_token.BYTE _v -> + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0139 _menhir_initp + | _ -> _eRR () -let _menhir_action_659 _endpos__2_ _startpos__1_ = - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_record { fields = []; is_closed = true; loc_ = i _sloc } - : Parsing_syntax.pattern) + and _menhir_run_0141 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INT _v -> + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_1, _v) in + let _v = _menhir_action_177 _2 in + _menhir_goto_map_syntax_key _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.FLOAT _v -> + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_3, _v) in + let _v = _menhir_action_178 _2 in + _menhir_goto_map_syntax_key _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_660 _endpos__3_ _startpos__1_ p = - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let fps, is_closed = p in - Parsing_syntax.Ppat_record { fields = fps; is_closed; loc_ = i _sloc } - : Parsing_syntax.pattern) + and _menhir_run_0144 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0145 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_078 _endpos_name_ _startpos_name_ name in + _menhir_goto_fields_pat_single _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0146 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_445 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0147 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_447 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0148 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_443 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_661 _endpos__3_ _startpos__1_ elems = - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ppat_map { elems; loc_ = i _sloc } : Parsing_syntax.pattern) + and _menhir_run_0149 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_444 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0150 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_451 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0151 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_446 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0112 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_AMPER (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0112 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_662 () = - let cases = [] in - (cases : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + and _menhir_goto_fields_pat_single : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0139 -> + _menhir_run_0216 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0205 -> + _menhir_run_0206 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0216 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_223 x in + _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_663 _1 = - let cases = _1 in - (cases : (Parsing_syntax.pattern * Parsing_syntax.expr) list) + and _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0204, _endpos) + in + _menhir_run_0144 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0205 _menhir_initp + | Lex_menhir_token.DOTDOT -> ( + let xs = _v in + let _v = _menhir_action_247 xs in + let _menhir_stack = + MenhirCell1_non_empty_list_commas_with_tail_fields_pat_single_ + (_menhir_stack, _menhir_s, _v) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> + _menhir_run_0171 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0194 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_286 () in + _menhir_run_0195 _menhir_stack _menhir_lexbuf + _menhir_lexer _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ + (_menhir_stack, _menhir_s, _v) + in + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0207 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ + (_menhir_stack, _menhir_s, _v) + in + let _ = _menhir_action_286 () in + _menhir_run_0207 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_664 _endpos_expr_ _startpos__1_ expr pat = - let ty_opt = - let _1 = None in - _1 - in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let pat = - match ty_opt with - | None -> pat - | Some ty -> - Parsing_syntax.Ppat_constraint - { - pat; - ty; - loc_ = - Rloc.merge - (Parsing_syntax.loc_of_pattern pat) - (Parsing_syntax.loc_of_type_expression ty); - } - in - Stmt_let { pat; expr; loc = i _sloc } - : Parsing_compact.semi_expr_prop) + and _menhir_run_0171 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + let x = () in + let _v = _menhir_action_287 x in + _menhir_goto_option_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp -let _menhir_action_665 _endpos_expr_ _startpos__1_ expr pat t = - let ty_opt = - let _1 = - let x = t in - Some x - in - _1 - in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let pat = - match ty_opt with - | None -> pat - | Some ty -> - Parsing_syntax.Ppat_constraint - { - pat; - ty; - loc_ = - Rloc.merge - (Parsing_syntax.loc_of_pattern pat) - (Parsing_syntax.loc_of_type_expression ty); - } - in - Stmt_let { pat; expr; loc = i _sloc } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_option_COMMA_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0817 -> + _menhir_run_0820 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0764 -> + _menhir_run_0767 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0729 -> + _menhir_run_0732 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0712 -> + _menhir_run_0718 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0678 -> + _menhir_run_0682 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0645 -> + _menhir_run_0647 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0629 -> + _menhir_run_0633 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0615 -> + _menhir_run_0621 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0598 -> + _menhir_run_0601 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0574 -> + _menhir_run_0577 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0479 -> + _menhir_run_0480 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0471 -> + _menhir_run_0474 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0386 -> + _menhir_run_0390 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0330 -> + _menhir_run_0334 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0247 -> + _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0226 -> + _menhir_run_0229 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0204 -> + _menhir_run_0207 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0196 -> + _menhir_run_0203 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0194 -> + _menhir_run_0195 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0191 -> + _menhir_run_0192 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0184 -> + _menhir_run_0185 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0176 -> + _menhir_run_0179 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0170 -> + _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | MenhirState0060 -> + _menhir_run_0063 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0820 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_constructor_param_ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_constructor_param_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_191 xs in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let ts = _v in + let _v = _menhir_action_303 ts in + _menhir_goto_option___anonymous_16_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_666 _endpos_expr_ _endpos_name_ _startpos__1_ _startpos_name_ - expr name = - let ty = - let _1 = None in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Stmt_letmut { binder; ty_opt = ty; expr; loc = i _sloc } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_667 _endpos_expr_ _endpos_name_ _startpos__1_ _startpos_name_ - expr name t = - let ty = - let _1 = - let x = t in - Some x - in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Stmt_letmut { binder; ty_opt = ty; expr; loc = i _sloc } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_option___anonymous_16_ : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell0_option___anonymous_16_ (_menhir_stack, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INT _v_0 -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_tag_, _startpos_tag_, tag = + (_endpos_1, _startpos, _v_0) + in + let _v = _menhir_action_305 _endpos_tag_ _startpos_tag_ tag in + _menhir_goto_option___anonymous_17_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_tag_ _v _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_304 () in + _menhir_goto_option___anonymous_17_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_option___anonymous_17_ : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT + _menhir_cell0_option___anonymous_16_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_option___anonymous_16_ (_menhir_stack, constr_args)) + = + _menhir_stack + in + let (MenhirCell1_UIDENT + (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_)) = + _menhir_stack + in + let _endpos_constr_tag_, constr_tag = (_endpos, _v) in + let _v = + _menhir_action_045 _endpos_constr_tag_ _endpos_id_ _startpos_id_ + constr_args constr_tag id + in + _menhir_goto_enum_constructor _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_668 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ _startpos_name_ - name ty_opt = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_enum_constructor : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1345 -> + _menhir_run_0837 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1072 -> + _menhir_run_0837 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0809 -> + _menhir_run_0837 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0831 -> + _menhir_run_0832 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0837 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_256 x in + _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_669 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ _startpos_name_ - name ty_opt xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ : + type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0830, _v_0, _endpos) + in + _menhir_run_0810 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0831 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_0833 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0833 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0833 : type ttv_stack. + ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_276 xs in + let _1 = _v in + let _v = _menhir_action_270 _1 in + let _1 = _v in + let _v = _menhir_action_151 _1 in + _menhir_goto_list_semis_enum_constructor_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + + and _menhir_goto_list_semis_enum_constructor_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1345 -> + _menhir_run_1346 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState1072 -> + _menhir_run_1073 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState0809 -> + _menhir_run_0834 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1346 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_enum_header + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_semis_enum_constructor_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1347 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1348 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0758 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = MenhirCell1_DERIVE (_menhir_stack, _menhir_s) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0759 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_128 () in + _menhir_goto_list_commas_deriving_directive_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_670 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ _startpos_name_ - name ty_opt x xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_list_commas_deriving_directive_ : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_DERIVE (_menhir_stack, _menhir_s)) = + _menhir_stack + in + let _3, _endpos__4_ = (_v, _endpos) in + let _v = _menhir_action_044 _3 in + _menhir_goto_deriving_directive_list _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_deriving_directive_list : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1347 -> + _menhir_run_1348 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1308 -> + _menhir_run_1309 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1255 -> + _menhir_run_1256 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1180 -> + _menhir_run_1181 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1092 -> + _menhir_run_1093 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1085 -> + _menhir_run_1086 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1079 -> + _menhir_run_1082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1080 -> + _menhir_run_1081 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1077 -> + _menhir_run_1078 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1074 -> + _menhir_run_1075 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1044 -> + _menhir_run_1045 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0991 -> + _menhir_run_0992 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0914 -> + _menhir_run_0915 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0835 -> + _menhir_run_0836 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0805 -> + _menhir_run_0806 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0757 -> + _menhir_run_0772 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1348 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_enum_header + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_semis_enum_constructor_ (_menhir_stack, _, cs)) + = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_enum_header + (_menhir_stack, _menhir_s, enum_header, _startpos_enum_header_)) + = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_496 _endpos_deriving__ _startpos_enum_header_ cs + deriving_ enum_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_671 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ - _startpos_name_ name ty_opt = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_goto_structure_item : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1097 -> + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0672 -> + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1098 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_, + _menhir_box_structure ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_267 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0673 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.TYPE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0687 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.TRAITALIAS -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0692 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.TRAIT -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0696 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.TEST -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0749 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.STRUCT -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0845 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.PUB -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0848 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.PRIV -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_0939 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.LET -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.IMPL -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1018 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1035 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.EXTERN -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1041 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.ENUM -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1053 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.CONST -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1056 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.ATTRIBUTE _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1060 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState1097 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState1096, _v_0, _endpos) + in + _menhir_run_1061 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1097 _menhir_initp + | Lex_menhir_token.EOF -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_1349 _menhir_stack _tok + | _ -> _eRR ()) + | Lex_menhir_token.EOF -> + let _ = _menhir_action_292 () in + _menhir_run_1349 _menhir_stack _tok + | _ -> _eRR () + + and _menhir_run_0673 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_TYPEALIAS (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0673 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_672 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ - _startpos_name_ name ty_opt xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_run_0687 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0687 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0688 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_673 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ - _startpos_name_ name ty_opt x xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined4_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined3 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined2_) - in - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_run_0692 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_TRAITALIAS (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0692 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_674 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ _startpos_name_ - name ty_opt = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) + and _menhir_run_0696 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_TRAIT (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0696 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_675 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ _startpos_name_ - name ty_opt xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_676 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ _startpos_name_ - name ty_opt x xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined2_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_677 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_678 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_679 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt x xs = - let block = - let _endpos__3_, _startpos__1_ = - (_endpos__3_inlined1_, _startpos__1_inlined3_) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos_block_ = _endpos__3_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let _endpos_params_, _startpos_params_ = - (_endpos__3_, _startpos__1_inlined1_) - in - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_block_ in - let _symbolstartpos = _startpos__1_ in - let _loc_params_ = (_startpos_params_, _endpos_params_) in - let _sloc = (_symbolstartpos, _endpos) in - (let locb = i _sloc in - let func : Parsing_syntax.func = - Lambda - { - parameters = params; - params_loc_ = i _loc_params_; - body = block; - return_type = ty_opt; - kind_ = Lambda; - has_error; - } - in - Parsing_compact.Stmt_func { binder; func; loc = locb } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_680 _endpos__3_ _endpos__4_ _endpos_name_ _startpos__1_ - _startpos_name_ name = - let cases = [] in - let _endpos_cases_, _startpos_cases_ = (_endpos__4_, _endpos__4_) in - let binder = - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - (binder, has_error) - in - let _endpos_binder_, _startpos_binder_ = (_endpos__4_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_binder_ in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in - let _sloc = (_symbolstartpos, _endpos) in - (let binder, has_error = binder in - Parsing_compact.Stmt_func - { - binder; - func = - Match - { cases; has_error; loc_ = i _loc_cases_; fn_loc_ = i _loc_binder_ }; - loc = i _sloc; - } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_681 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ _startpos_name_ name = - let cases = - let _1 = _1_inlined2 in - _1 - in - let _endpos_cases_, _startpos_cases_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let binder = - let has_error = true in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - (binder, has_error) - in - let _endpos_binder_, _startpos_binder_ = (_endpos__4_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_binder_ in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in - let _sloc = (_symbolstartpos, _endpos) in - (let binder, has_error = binder in - Parsing_compact.Stmt_func - { - binder; - func = - Match - { cases; has_error; loc_ = i _loc_cases_; fn_loc_ = i _loc_binder_ }; - loc = i _sloc; - } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_682 _endpos__3_ _endpos__4_ _endpos_name_ _startpos__1_ - _startpos_name_ name = - let cases = [] in - let _endpos_cases_, _startpos_cases_ = (_endpos__4_, _endpos__4_) in - let binder = - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - (binder, has_error) - in - let _endpos_binder_, _startpos_binder_ = (_endpos__4_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_binder_ in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in - let _sloc = (_symbolstartpos, _endpos) in - (let binder, has_error = binder in - Parsing_compact.Stmt_func - { - binder; - func = - Match - { cases; has_error; loc_ = i _loc_cases_; fn_loc_ = i _loc_binder_ }; - loc = i _sloc; - } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_683 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ _endpos__4_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos_name_ name = - let cases = - let _1 = _1_inlined1 in - _1 - in - let _endpos_cases_, _startpos_cases_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let binder = - let has_error = false in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - (binder, has_error) - in - let _endpos_binder_, _startpos_binder_ = (_endpos__4_, _startpos__1_) in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_binder_ in - let _loc_cases_ = (_startpos_cases_, _endpos_cases_) in - let _loc_binder_ = (_startpos_binder_, _endpos_binder_) in - let _sloc = (_symbolstartpos, _endpos) in - (let binder, has_error = binder in - Parsing_compact.Stmt_func - { - binder; - func = - Match - { cases; has_error; loc_ = i _loc_cases_; fn_loc_ = i _loc_binder_ }; - loc = i _sloc; - } - : Parsing_compact.semi_expr_prop) - -let _menhir_action_684 _1 : Parsing_compact.semi_expr_prop = _1 - -let _menhir_action_685 _endpos__1_ _startpos__1_ = - let _1 = - let arg = None in - let _endpos_arg_ = _endpos__1_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_686 _endpos_x_ _startpos__1_ x = - let _1 = - let arg = Some x in - let _endpos_arg_ = _endpos_x_ in - let _endpos = _endpos_arg_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_break { arg; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_687 _endpos__1_ _startpos__1_ = - let _1 = - let args = [] in - let _endpos_args_ = _endpos__1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_688 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ = - let _1 = - let args = - let _1 = _1_inlined1 in - _1 - in - let _endpos_args_ = _endpos__1_inlined1_ in - let _endpos = _endpos_args_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_continue { args; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_689 _endpos_expr_ _startpos__1_ expr = - let _1 = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_690 _endpos_expr_ _startpos__1_ expr = - let _1 = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i _sloc } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_691 _endpos__1_ _startpos__1_ = - let _1 = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Pexpr_hole { loc_ = i _sloc; kind = Todo } - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_692 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name = - let _1 = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } - in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_693 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name record = - let _1 = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } + and _menhir_run_0749 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos) in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + _menhir_run_0750 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0749 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v = _menhir_action_328 () in + _menhir_run_0751 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v MenhirState0749 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0750 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_329 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_option_loced_string_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option_loced_string_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1120 -> + _menhir_run_1121 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0749 -> + _menhir_run_0751 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1121 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_loced_string_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1121 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1122 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1121 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1122 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_ + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1122 _menhir_initp + | _ -> _eRR () -let _menhir_action_694 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index record = - let _1 = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } + and _menhir_run_0754 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_695 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ e - ind obj = - let _1 = - let _1 = - let op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - { Parsing_syntax.var_name = Lident _1; loc_ = i _sloc } - in - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set { op; array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_696 _endpos_e_ _endpos_name_ _startpos_name_ e name = - let _1 = - let _1 = - let lv = - let var = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.var_name = name; loc_ = i _loc } + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.TYPE -> + _menhir_run_0755 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.STRUCT -> + _menhir_run_0773 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.LET -> + _menhir_run_0484 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.GUARD -> + _menhir_run_0500 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.ENUM -> + _menhir_run_0807 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0754 _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0535 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0754 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v = _menhir_action_162 () in + _menhir_run_0843 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _endpos _v MenhirState0754 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0754 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0755 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos) in - `Var var - in - let _startpos_lv_ = _startpos_name_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) + let _menhir_s = MenhirState0755 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_697 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record = - let _1 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - if name = "_" then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = i _loc } + and _menhir_run_0773 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos) in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) + let _menhir_s = MenhirState0773 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_698 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record = - let _1 = - let _1 = - let lv = - let acc = - let _endpos = _endpos_index_ in - let _startpos = _startpos_index_ in - let _loc = (_startpos, _endpos) in - Parsing_syntax.Index { tuple_index = index; loc_ = i _loc } + and _menhir_run_0111 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) in - `Field_access (record, acc) - in - let _startpos_lv_ = _startpos_record_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) - -let _menhir_action_699 _endpos_e_ _startpos_obj_ e ind obj = - let _1 = - let _1 = - let lv = `Array_access (obj, ind) in - let _startpos_lv_ = _startpos_obj_ in - let _endpos = _endpos_e_ in - let _symbolstartpos = _startpos_lv_ in - let _sloc = (_symbolstartpos, _endpos) in - let loc_ = i _sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign - { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate - { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set { array; index; value = e; loc_ } - in - _1 - in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) + let _menhir_s = MenhirState0111 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_700 _1 = - let _1 = _1 in - (Parsing_compact.Stmt_expr { expr = _1 } : Parsing_compact.semi_expr_prop) + and _menhir_reduce_172 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp -let _menhir_action_701 _endpos_tycon_ _startpos_tycon_ params tycon = - let vis = Parsing_syntax.Vis_default in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) + and _menhir_run_0370 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DOT_UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) + in + _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v_1 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL + -> + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_1, _startpos, _v) + in + let _v = _menhir_action_372 id ps in + _menhir_goto_qual_ident _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_1, _startpos, _v) + in + let _v = _menhir_action_374 id ps in + _menhir_goto_qual_ident_simple_expr _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_ps_ _v + _menhir_s _tok _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_id_, id, _startpos_ps_, ps = + (_endpos, _v_1, _startpos, _v) + in + let _v = _menhir_action_376 id ps in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_goto_qual_ident : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_122 _endpos_name_ _startpos_name_ name in + _menhir_goto_left_value _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos_name_ _v _menhir_s _tok _menhir_initp -let _menhir_action_702 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ - params tycon = - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) + and _menhir_goto_left_value : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_left_value (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0446 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( + let _v = _v_14 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_AUGMENTED_ASSIGNMENT + (_menhir_stack, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0448 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _menhir_fail () + + and _menhir_goto_qual_ident_simple_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_var_name_, _startpos_var_name_, var_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_419 _endpos_var_name_ _startpos_var_name_ var_name + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_var_name_ _startpos_var_name_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_703 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon = - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) + and _menhir_run_0372 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0018 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_371 i in + _menhir_goto_qual_ident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT + | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_373 i in + _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0484 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0484 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MUTABLE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_MUTABLE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0487 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0489 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_704 () = - let _1 = [] in - (_1 : Parsing_syntax.impls) + and _menhir_run_0500 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0500 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LET -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0501 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_705 _1 = - let _1 = _1 in - (_1 : Parsing_syntax.impls) + and _menhir_run_0526 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, MenhirState0526, _v, _startpos_0, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0527 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v_1 = _menhir_action_337 () in + _menhir_run_0528 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0527 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0526 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v = _menhir_action_337 () in + _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0526 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0528 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0528 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0529 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0529 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos__4_ = _endpos in + let _v = + _menhir_action_079 _endpos_name_ _startpos_name_ has_error name + in + _menhir_goto_fn_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_706 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header = - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_abstract; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_goto_fn_header : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0754 -> + _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0535 -> + _menhir_run_0545 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0554 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fn_header + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0554 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0554 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0554 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0554 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0554 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0554 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0554 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0554 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0554 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0554 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_9 = _menhir_action_152 () in + _menhir_run_0555 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + _menhir_initp + | _ -> _eRR () -let _menhir_action_707 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header = - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_newtype ty; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_run_0555 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_fn_header -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_fn_header + ( _menhir_stack, + _menhir_s, + binder, + _startpos_binder_, + _endpos_binder_ )) = + _menhir_stack + in + _menhir_act_goto_474 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _menhir_s _tok _menhir_initp _endpos _v _endpos_binder_ + _startpos_binder_ binder -let _menhir_action_708 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header = - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_ = type_header in - let exception_decl : Parsing_syntax.exception_decl = - match ty with None -> No_payload | Some ty -> Single_payload ty - in - Ptop_typedef - { - tycon; - tycon_loc_; - params = []; - components = Ptd_error exception_decl; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_act_goto_474 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__4_ -> + fun cases -> + fun _endpos_binder_ -> + fun _startpos_binder_ -> + fun binder -> + match _menhir_s with + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ + _startpos_binder_ binder cases + in + _menhir_run_0552 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ + _startpos_binder_ binder cases + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_binder_ _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ + _startpos_binder_ binder cases + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_binder_ _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ + _startpos_binder_ binder cases + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_binder_ _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_474 _endpos__0_ _endpos__4_ _endpos_binder_ + _startpos_binder_ binder cases + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_binder_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0552 : type ttv_stack ttv_result. + ( ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_statement_, + ttv_result ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ + (_menhir_stack, _menhir_s, xs, _startpos_xs_)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_265 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_statement_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _startpos_xs_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_709 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header = - let cs = [] in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_ = type_header in - let exception_decl : Parsing_syntax.exception_decl = Enum_payload cs in - Ptop_typedef - { - tycon; - tycon_loc_; - params = []; - components = Ptd_error exception_decl; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_semi_rev_aux_statement_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0026 -> + _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0550 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0550 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0550 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0613 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_statement_ + (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> + _menhir_run_0551 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0613 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_292 () in + _menhir_run_0614 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_1 _menhir_initp + | _ -> _eRR () -let _menhir_action_710 _1 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header = - let cs = _1 in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_ = type_header in - let exception_decl : Parsing_syntax.exception_decl = Enum_payload cs in - Ptop_typedef - { - tycon; - tycon_loc_; - params = []; - components = Ptd_error exception_decl; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_run_0551 : type ttv_stack ttv_result. + (( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_statement_ + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0551 _menhir_initp + | Lex_menhir_token.TRY -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0551 _menhir_initp + | Lex_menhir_token.RETURN -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.RAISE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_2 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0551 _menhir_initp + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0551 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_4 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0551 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_5 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0551 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.MATCH -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.LIDENT _v_6 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0551 _menhir_initp + | Lex_menhir_token.LET -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0484 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.INTERP _v_7 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0551 _menhir_initp + | Lex_menhir_token.INT _v_8 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0551 _menhir_initp + | Lex_menhir_token.IF -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.GUARD -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0500 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.FLOAT _v_9 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + MenhirState0551 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.CONTINUE -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.CHAR _v_10 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 + MenhirState0551 _menhir_initp + | Lex_menhir_token.BYTES _v_11 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 + MenhirState0551 _menhir_initp + | Lex_menhir_token.BYTE _v_12 -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 + MenhirState0551 _menhir_initp + | Lex_menhir_token.BREAK -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0535 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0551 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_s = MenhirState0551 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.RBRACE -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_293 x in + _menhir_goto_option_SEMI_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0373 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in + let _v = _menhir_action_066 _endpos__1_ _startpos__1_ in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_711 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header = - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_type_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_alias ty; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_goto_expr_statement : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0754 -> + _menhir_run_0557 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0557 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0557 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0557 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0557 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0515 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0450 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_712 _endpos_deriving__ _startpos_struct_header_ deriving_ - struct_header = - let fs = [] in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_struct_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = struct_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_record fs; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_run_0557 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _startpos__1_, _1 = (_startpos, _v) in + let _v = _menhir_action_476 _1 in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_713 _1 _endpos_deriving__ _startpos_struct_header_ deriving_ - struct_header = - let fs = _1 in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_struct_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = struct_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_record fs; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_goto_statement : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0551 -> + _menhir_run_0552 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0548 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0548 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _startpos_x_, x = (_startpos, _v) in + let _v = _menhir_action_264 x in + _menhir_goto_non_empty_list_semi_rev_aux_statement_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s + _tok _menhir_initp -let _menhir_action_714 _endpos_deriving__ _startpos_enum_header_ deriving_ - enum_header = - let cs = [] in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_enum_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = enum_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_variant cs; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_run_0515 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_pattern + _menhir_cell0_option___anonymous_8_ + _menhir_cell0_FAT_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_option___anonymous_8_ (_menhir_stack, guard)) = + _menhir_stack + in + let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = + _menhir_stack + in + let body = _v in + let _v = _menhir_action_463 body guard pat in + _menhir_goto_single_pattern_case _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_715 _1 _endpos_deriving__ _startpos_enum_header_ deriving_ - enum_header = - let cs = _1 in - let _endpos = _endpos_deriving__ in - let _symbolstartpos = _startpos_enum_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let type_vis, tycon, tycon_loc_, params = enum_header in - Ptop_typedef - { - tycon; - tycon_loc_; - params; - components = Ptd_variant cs; - type_vis; - doc_ = Docstring.empty; - deriving_; - loc_ = aloc _sloc; - } - : Parsing_syntax.impl) + and _menhir_goto_single_pattern_case : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0519 -> + _menhir_run_0520 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0509 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0509 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0509 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0509 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0520 : type ttv_stack ttv_result. + ( ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_single_pattern_case_, + ttv_result ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_single_pattern_case_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_263 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_single_pattern_case_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_716 _endpos_expr_ _startpos_val_header_ expr val_header = - let _endpos = _endpos_expr_ in - let _symbolstartpos = _startpos_val_header_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let is_constant, is_pub, binder, ty = val_header in - Ptop_letdef - { - binder; - ty; - expr; - is_pub; - is_constant; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_semi_rev_aux_single_pattern_case_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_single_pattern_case_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.UIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0519 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.STRING _v_2 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0519 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0519 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.LIDENT _v_4 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0519 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.INT _v_5 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0519 _menhir_initp + | Lex_menhir_token.FLOAT _v_6 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0519 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.CHAR _v_7 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0519 _menhir_initp + | Lex_menhir_token.BYTES _v_8 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0519 _menhir_initp + | Lex_menhir_token.BYTE _v_9 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0519 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0518, _v_0, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0519 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_0521 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0521 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0521 : type ttv_stack ttv_result. + ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_single_pattern_case_ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_single_pattern_case_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_279 xs in + let _1 = _v in + let _v = _menhir_action_273 _1 in + _menhir_goto_non_empty_list_semis_single_pattern_case_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -let _menhir_action_717 _endpos_fname_ _startpos_t_ fname mname t = - let _endpos = _endpos_fname_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = - Decl_stubs (Import { module_name = mname; func_name = fname }); - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_semis_single_pattern_case_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0641 -> + _menhir_run_0643 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0662 -> + _menhir_run_0517 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState0666 -> + _menhir_run_0517 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState0506 -> + _menhir_run_0517 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0643 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _, _, _endpos__3_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr (_menhir_stack, _, e, _, _)) = + _menhir_stack + in + let (MenhirCell1_MATCH (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__3_, mat = (_endpos, _v) in + let _v = + _menhir_action_179 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ e + mat + in + _menhir_goto_match_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_718 _endpos_s_ _startpos_t_ s t = - let _endpos = _endpos_s_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = - Decl_stubs (Embedded { language = None; code = Code_string s }); - } - : Parsing_syntax.impl) + and _menhir_goto_match_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_058 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_719 _endpos_xs_ _startpos_t_ t xs = - let _endpos = _endpos_xs_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = - Decl_stubs - (Embedded { language = None; code = Code_multiline_string xs }); - } - : Parsing_syntax.impl) + and _menhir_goto_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1069 -> + _menhir_run_1070 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0000 -> _menhir_run_0670 _menhir_stack _v _tok + | MenhirState0003 -> + _menhir_run_0656 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0651 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0637 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0632 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0632 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0627 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0619 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0603 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0598 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0566 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0562 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0512 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0495 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0492 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0488 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0483 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0467 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0465 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0461 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0449 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0447 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0400 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0388 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0382 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0382 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0382 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0382 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0367 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0359 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0354 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0343 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0339 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0329 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0324 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0324 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0324 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0318 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0318 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1070 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_val_header + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_val_header + (_menhir_stack, _menhir_s, val_header, _startpos_val_header_)) + = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = + _menhir_action_497 _endpos_expr_ _startpos_val_header_ expr + val_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_720 _endpos_s_ _startpos_t_ s t = - let _endpos = _endpos_s_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let language, decl = t in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = decl; - decl_body = - Decl_stubs - (Embedded { language = Some language; code = Code_string s }); - } - : Parsing_syntax.impl) + and _menhir_run_0656 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_TRY as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_ = (_endpos_1, _startpos_0) in + let _v = _menhir_action_028 _endpos__1_ _startpos__1_ in + _menhir_goto_catch_keyword _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | Lex_menhir_token.CATCH -> ( + let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__2_ = (_startpos_3, _endpos_5) in + let _v = _menhir_action_027 _endpos__2_ _startpos__1_ in + _menhir_goto_catch_keyword _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos__1_, _endpos__3_ = + (_startpos_3, _endpos_10) + in + let _v = _menhir_action_029 _endpos__3_ _startpos__1_ in + _menhir_goto_catch_keyword _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_goto_catch_keyword : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_TRY, ttv_result) _menhir_cell1_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = MenhirCell0_catch_keyword (_menhir_stack, _v) in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0662 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0662 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0662 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0662 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0662 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0662 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0662 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0662 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0662 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0662 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _menhir_s = MenhirState0662 in + let _v = _menhir_action_156 () in + _menhir_goto_list_semis_single_pattern_case_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_goto_list_semis_single_pattern_case_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let cases = _v in + let _v = _menhir_action_464 cases in + _menhir_goto_single_pattern_cases _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp -let _menhir_action_721 _endpos_xs_ _startpos_t_ t xs = - let _endpos = _endpos_xs_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let language, decl = t in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = decl; - decl_body = - Decl_stubs - (Embedded - { language = Some language; code = Code_multiline_string xs }); - } - : Parsing_syntax.impl) - -let _menhir_action_722 _endpos__1_ _endpos__4_ _startpos__1_ _startpos_t_ t = - let body = - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) - -let _menhir_action_723 _endpos__4_ _endpos_xs_ _startpos__1_ _startpos_t_ - _startpos_xs_ t xs = - let body = - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) + and _menhir_goto_single_pattern_cases : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0666 -> + _menhir_run_0667 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0662 -> + _menhir_run_0663 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState0506 -> + _menhir_run_0507 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0667 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_TRY, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_catch_keyword, + ttv_result ) + _menhir_cell1_single_pattern_cases + _menhir_cell0_RBRACE + _menhir_cell0_ELSE + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_)) = + _menhir_stack + in + let (MenhirCell0_ELSE (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_single_pattern_cases (_menhir_stack, _, catch)) = + _menhir_stack + in + let (MenhirCell0_catch_keyword (_menhir_stack, catch_keyword)) = + _menhir_stack + in + let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in + let (MenhirCell1_TRY + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__8_, try_else = (_endpos, _v) in + let _v = + _menhir_action_534 _endpos__1_ _endpos__2_ _endpos__8_ _startpos__1_ + _startpos__1_inlined1_ body catch catch_keyword try_else + in + _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__8_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_724 _endpos__4_ _endpos_x_ _startpos__1_ _startpos_t_ - _startpos_xs_ t x xs = - let body = - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) + and _menhir_goto_try_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_056 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_725 _1_inlined1 _endpos__1_inlined1_ _endpos__4_ - _startpos__1_ _startpos_t_ t = - let body = - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) + and _menhir_run_0663 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_TRY, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_catch_keyword + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> ( + let _menhir_stack = + MenhirCell1_single_pattern_cases (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_ELSE (_menhir_stack, _startpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0666 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RBRACE -> + _menhir_reduce_156 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_catch_keyword (_menhir_stack, catch_keyword)) = + _menhir_stack + in + let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = + _menhir_stack + in + let (MenhirCell1_TRY + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__5_, catch = (_endpos, _v) in + let _v = + _menhir_action_533 _endpos__1_ _endpos__5_ _startpos__1_ body + catch catch_keyword + in + _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_reduce_156 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _v = _menhir_action_156 () in + _menhir_goto_list_semis_single_pattern_case_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -let _menhir_action_726 _1_inlined1 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos_t_ _startpos_xs_ t xs = - let body = - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) + and _menhir_run_0507 : type ttv_stack ttv_result. + ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_GUARD, + ttv_result ) + _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_EQUAL, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_ELSE + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_ELSE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_infix_expr (_menhir_stack, _, expr, _, _)) = + _menhir_stack + in + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = + _menhir_stack + in + let (MenhirCell1_LET (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let cases, _endpos__9_ = (_v, _endpos) in + let _v = _menhir_action_104 _endpos__9_ _startpos__1_ cases expr pat in + _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_727 _1_inlined1 _endpos__4_ _endpos_x_ _startpos__1_ - _startpos_t_ _startpos_xs_ t x xs = - let body = - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_t_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef - { - loc_ = aloc _sloc; - fun_decl = t; - decl_body = Decl_body { expr = body; local_types }; - } - : Parsing_syntax.impl) + and _menhir_goto_guard_statement : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _startpos__1_, _1 = (_startpos, _v) in + let _v = _menhir_action_475 _1 in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_728 _endpos__0_ _endpos__7_ _endpos_name_ _startpos__2_ - _startpos_name_ name supers = - let methods = [] in - let vis = Parsing_syntax.Vis_default in - let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0651 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0652 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_221 x in + _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_729 _1 _endpos__0_ _endpos__7_ _endpos_name_ _startpos__2_ - _startpos_name_ name supers = - let methods = _1 in - let vis = Parsing_syntax.Vis_default in - let _endpos_vis_, _startpos_vis_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev_expr_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0015 -> + _menhir_run_0645 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0311 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0311 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0311 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0645 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_expr_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.UIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0646 _menhir_initp + | Lex_menhir_token.TRY -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.STRING _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0646 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0646 _menhir_initp + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0646 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0646 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0646 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.MATCH -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.LIDENT _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0646 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.INTERP _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0646 _menhir_initp + | Lex_menhir_token.INT _v_9 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0646 _menhir_initp + | Lex_menhir_token.IF -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.FLOAT _v_10 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0646 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.CHAR _v_11 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0646 _menhir_initp + | Lex_menhir_token.BYTES _v_12 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0646 _menhir_initp + | Lex_menhir_token.BYTE _v_13 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0646 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0646 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0645, _endpos_0) + in + let _endpos, _menhir_s = (_endpos_0, MenhirState0646) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0647 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0647 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0647 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_expr_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_expr_ + (_menhir_stack, _, xs, _)) = + _menhir_stack + in + let _v = _menhir_action_193 xs in + let _1 = _v in + let _v = _menhir_action_131 _1 in + _menhir_goto_list_commas_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp -let _menhir_action_730 _endpos__1_ _endpos__7_ _endpos_name_ _startpos__1_ - _startpos__2_ _startpos_name_ name supers = - let methods = [] in - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_expr_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, bs = (_endpos, _v) in + let _v = _menhir_action_439 _endpos__3_ _startpos__1_ bs in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_731 _1_inlined1 _endpos__1_ _endpos__7_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ name supers = - let methods = - let _1 = _1_inlined1 in - _1 - in - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _endpos_vis_, _startpos_vis_ = (_endpos__1_, _startpos__1_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0311 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_expr_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_s = MenhirState0311 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0312 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let _endpos_xs_, xs = (_endpos, _v) in + let _v = _menhir_action_208 xs in + _menhir_goto_non_empty_list_commas_no_trailing_expr_ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_732 _endpos__7_ _endpos_attr_ _endpos_name_ _startpos__1_ - _startpos__2_ _startpos_name_ attr name supers = - let methods = [] in - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_no_trailing_expr_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0374 -> + _menhir_run_0376 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0376 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0319 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0376 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _1 = (_endpos, _v) in + let _v = _menhir_action_147 _1 in + _menhir_goto_list_commas_no_trailing_expr_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_733 _1_inlined1 _endpos__7_ _endpos_attr_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ attr name supers = - let methods = - let _1 = _1_inlined1 in - _1 - in - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _endpos_vis_, _startpos_vis_ = (_endpos_attr_, _startpos__1_) in - let _endpos = _endpos__7_ in - let _symbolstartpos = - if _startpos_vis_ != _endpos_vis_ then _startpos_vis_ else _startpos__2_ - in - let _loc_name_ = (_startpos_name_, _endpos_name_) in - let _sloc = (_symbolstartpos, _endpos) in - (let trait_name : Parsing_syntax.binder = - { binder_name = name; loc_ = i _loc_name_ } - in - enter_next_block (); - let supers = match supers with None -> [] | Some supers -> supers in - Parsing_syntax.Ptop_trait - { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = aloc _sloc; - trait_doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_no_trailing_expr_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0374 -> + _menhir_run_0378 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0377 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0378 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_CONTINUE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_args_, args = (_endpos, _v) in + let _v = _menhir_action_063 _endpos_args_ _startpos__1_ args in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_734 _endpos__1_inlined1_ _endpos__4_ _startpos__1_ - _startpos__1_inlined1_ name params = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_run_0377 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_CONTINUE, + ttv_result ) + _menhir_cell1_POST_LABEL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_POST_LABEL + (_menhir_stack, _, label, _startpos_label_, _endpos_label_)) = + _menhir_stack + in + let (MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_args_, args = (_endpos, _v) in + let _v = + _menhir_action_062 _endpos_args_ _endpos_label_ _startpos__1_ + _startpos_label_ args label + in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_735 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_run_0319 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_LOOP + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_no_trailing_expr_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.UIDENT _v_1 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0320 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.STRING _v_2 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0320 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0320 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.LIDENT _v_4 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0320 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.INT _v_5 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0320 _menhir_initp + | Lex_menhir_token.FLOAT _v_6 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0320 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.CHAR _v_7 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0320 _menhir_initp + | Lex_menhir_token.BYTES _v_8 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0320 _menhir_initp + | Lex_menhir_token.BYTE _v_9 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0320 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0320 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_10 = _menhir_action_152 () in + _menhir_run_0322 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0322 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_LOOP, + ttv_result ) + _menhir_cell1_non_empty_list_commas_no_trailing_expr_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list_commas_no_trailing_expr_ + (_menhir_stack, _, args, _)) = + _menhir_stack + in + let (MenhirCell0_LOOP (_menhir_stack, _startpos__1_, _)) = + _menhir_stack + in + let (MenhirCell1_loop_label_colon + ( _menhir_stack, + _menhir_s, + label, + _startpos_label_, + _endpos_label_ )) = + _menhir_stack + in + let _endpos__4_, body = (_endpos, _v) in + let _v = + _menhir_action_170 _endpos__3_ _endpos__4_ _endpos_label_ + _startpos__1_ _startpos_label_ args body label + in + let _endpos, _startpos = (_endpos__4_, _startpos_label_) in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_052 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ + _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_736 _endpos__4_ _endpos_x_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_run_0637 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT + _menhir_cell0_optional_question + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_optional_question (_menhir_stack, is_question)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) + = + _menhir_stack + in + let arg_value = _v in + let _v = + _menhir_action_002 _endpos_name_ _startpos_name_ arg_value + is_question name + in + _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp -let _menhir_action_737 _1_inlined2 _endpos__1_inlined2_ _endpos__4_ - _startpos__1_ _startpos__1_inlined1_ name params = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_run_0632 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let expr = _v in + let _v = _menhir_action_465 expr in + _menhir_goto_spreadable_elem _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_738 _1_inlined2 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_goto_spreadable_elem : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0630 -> + _menhir_run_0631 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0628 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0631 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_242 x xs in + _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_739 _1_inlined2 _endpos__4_ _endpos_x_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test - { expr = body; name; params; local_types; loc_ = aloc _sloc } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0630 _menhir_initp + | Lex_menhir_token.TRY -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0630 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0630 _menhir_initp + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0630 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0630 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0630 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.MATCH -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.LIDENT _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0630 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.INTERP _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0630 _menhir_initp + | Lex_menhir_token.INT _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0630 _menhir_initp + | Lex_menhir_token.IF -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.FN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.FLOAT _v_9 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0630 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0626 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.CHAR _v_10 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0630 _menhir_initp + | Lex_menhir_token.BYTES _v_11 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0630 _menhir_initp + | Lex_menhir_token.BYTE _v_12 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0630 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0630 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0629, _endpos) + in + let _menhir_s = MenhirState0630 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0633 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _ = _menhir_action_286 () in + _menhir_run_0633 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0626 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0626 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_740 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 quantifiers - self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0633 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_203 xs in + let _1 = _v in + let _v = _menhir_action_139 _1 in + _menhir_goto_list_commas_spreadable_elem_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp -let _menhir_action_741 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_spreadable_elem_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACKET + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__3_, es = (_endpos, _v) in + let _v = _menhir_action_441 _endpos__3_ _startpos__1_ es in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_742 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0628 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_241 x in + _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_743 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0627 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = _menhir_action_466 _endpos_expr_ _startpos__1_ expr in + _menhir_goto_spreadable_elem _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_744 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0619 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_map_syntax_key _menhir_cell0_COLON -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_map_syntax_key + (_menhir_stack, _menhir_s, key, _startpos_key_, _endpos_key_)) + = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = + _menhir_action_175 _endpos_expr_ _endpos_key_ _startpos_key_ expr + key + in + _menhir_goto_map_expr_elem _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_745 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_746 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_747 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_748 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_749 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_750 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_map_expr_elem : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0026 -> + _menhir_run_0623 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0616 -> + _menhir_run_0620 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0623 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_233 x in + _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_751 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0616 _menhir_initp + | Lex_menhir_token.STRING _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0616 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0141 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0616 _menhir_initp + | Lex_menhir_token.INT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0616 _menhir_initp + | Lex_menhir_token.FLOAT _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0616 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0616 _menhir_initp + | Lex_menhir_token.CHAR _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0616 _menhir_initp + | Lex_menhir_token.BYTES _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0616 _menhir_initp + | Lex_menhir_token.BYTE _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0615, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0616 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0621 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_286 () in + _menhir_run_0621 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0621 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_199 xs in + let _1 = _v in + let _v = _menhir_action_133 _1 in + _menhir_goto_list_commas_map_expr_elem_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp -let _menhir_action_752 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_map_expr_elem_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, elems = (_endpos, _v) in + let _v = _menhir_action_412 _endpos__3_ _startpos__1_ elems in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_753 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0620 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_234 x xs in + _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_754 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0603 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_DOTDOT + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell1_LBRACE + (_menhir_stack, _menhir_s, _startpos__2_, _)) = + _menhir_stack + in + _menhir_act_goto_407 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ _endpos_0 _v + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0605 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_3 = _menhir_action_136 () in + _menhir_run_0606 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_755 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__1_inlined4_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_407 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun _endpos__5_ -> + fun oe -> + match _menhir_s with + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + let (MenhirCell0_LOOP (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + let (MenhirCell0_WHILE (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + let (MenhirCell1_AMPERAMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + let (MenhirCell1_BAR (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + let (MenhirCell1_BARBAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + let (MenhirCell1_AMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + let (MenhirCell1_CARET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + let (MenhirCell1_INFIX1 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + let (MenhirCell1_INFIX2 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + let (MenhirCell1_INFIX3 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + let (MenhirCell1_INFIX4 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_407 _endpos__0_ _endpos__5_ _startpos__2_ oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_756 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0123 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0124 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0385 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LBRACKET -> ( + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACKET (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0460 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0460 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0460 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0460 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0460 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0460 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0460 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0460 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0460 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0460 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0460 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0460 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0460 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0460 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0460) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COLON -> + let _v_16 = _menhir_action_324 () in + _menhir_run_0396 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _v_16 MenhirState0460 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0402 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DOT_LIDENT _v_17 -> ( + let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0411 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0415 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EXCLAMATION -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_DOT_LIDENT + (_menhir_stack, _v_17, _startpos_18, _endpos_19) + in + _menhir_run_0418 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.DOTDOT + | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.IS + | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let ( _endpos_name_, + _startpos_name_, + name, + _startpos_record_, + record ) = + (_endpos_19, _startpos_18, _v_17, _startpos, _v) + in + let _v = + _menhir_action_436 _endpos_name_ _startpos_name_ + _startpos_record_ name record + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_name_ _startpos_record_ _v _menhir_s + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.DOT_INT _v_20 -> + let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let ( _startpos_record_, + record, + _endpos_index_, + _startpos_index_, + index ) = + (_startpos, _v, _endpos_22, _startpos_21, _v_20) + in + let _v = + _menhir_action_437 _endpos_index_ _startpos_index_ + _startpos_record_ index record + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_index_ _startpos_record_ _v _menhir_s + _tok _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0427 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACE + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_367 _1 in + _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_757 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0385 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0385 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0385 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0392 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0385 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0392 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = + _menhir_stack + in + let args, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_422 _endpos__5_ _startpos_func_ args func + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_758 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined4_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_759 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0396 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_expr_ (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos_0) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.UIDENT _v_1 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0397 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.STRING _v_2 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0397 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_3 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0397 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_4 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0397 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_5 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0397 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_6 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0397 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.LIDENT _v_7 -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0397 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.INTERP _v_8 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0397 _menhir_initp + | Lex_menhir_token.INT _v_9 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0397 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.FLOAT _v_10 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0397 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.CHAR _v_11 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0397 _menhir_initp + | Lex_menhir_token.BYTES _v_12 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0397 _menhir_initp + | Lex_menhir_token.BYTE _v_13 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0397 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0397 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_0, MenhirState0397) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _v_15 = _menhir_action_324 () in + _menhir_run_0398 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_15 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0398 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, + ttv_result ) + _menhir_cell1_option_expr_ + _menhir_cell0_COLON -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_option_expr_ (_menhir_stack, _, start_index, _)) = + _menhir_stack + in + let (MenhirCell0_LBRACKET (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = + _menhir_stack + in + let _endpos__6_, end_index = (_endpos_0, _v) in + let _v = + _menhir_action_427 _endpos__6_ _startpos__2_ _startpos_array_ + array end_index start_index + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__6_ _startpos_array_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0402 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0403 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0403 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0404 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0403) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION (_menhir_stack, _startpos_2, _endpos_3) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0407 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0407 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0408 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_5, MenhirState0407) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0404 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = + _menhir_stack + in + let args, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_423 _endpos__5_ _startpos_func_ args func + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0408 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr + _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = + _menhir_stack + in + let args, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_424 _endpos__5_ _startpos_func_ args func + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0411 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0412 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0412 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0413 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0412) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0413 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_QUESTION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_DOT_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__6_ = (_v, _endpos) in + let _v = + _menhir_action_431 _endpos__6_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0415 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0415 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0415 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0416 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0415 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0416 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_DOT_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__6_ = (_v, _endpos) in + let _v = + _menhir_action_428 _endpos__6_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0418 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0419 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0419 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0420 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0419) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION (_menhir_stack, _startpos_2, _endpos_3) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v MenhirState0423 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0423 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_126 () in + _menhir_run_0424 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_5, MenhirState0423) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0420 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_DOT_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__6_ = (_v, _endpos) in + let _v = + _menhir_action_429 _endpos__6_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0424 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_DOT_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__6_ = (_v, _endpos) in + let _v = + _menhir_action_430 _endpos__6_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0427 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> ( + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos_2, _endpos_3) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.UIDENT _v_6 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_6 MenhirState0430 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.STRING _v_7 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_7 MenhirState0430 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_8 -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_8 MenhirState0430 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_9 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_9 MenhirState0430 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_10 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_10 MenhirState0430 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_11 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_11 MenhirState0430 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.LIDENT _v_12 -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_12 MenhirState0430 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.INTERP _v_13 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_13 MenhirState0430 _menhir_initp + | Lex_menhir_token.INT _v_14 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_14 MenhirState0430 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.FLOAT _v_15 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_15 MenhirState0430 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.CHAR _v_16 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_16 MenhirState0430 _menhir_initp + | Lex_menhir_token.BYTES _v_17 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_17 MenhirState0430 _menhir_initp + | Lex_menhir_token.BYTE _v_18 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_18 MenhirState0430 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0430 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v_19 = _menhir_action_126 () in + _menhir_run_0431 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_19 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_5, MenhirState0430) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.LPAREN -> ( + let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.UIDENT _v_23 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_23 MenhirState0433 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.STRING _v_24 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_24 MenhirState0433 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_25 -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_25 MenhirState0433 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_26 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_26 MenhirState0433 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_27 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_27 MenhirState0433 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_28 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_28 MenhirState0433 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.LIDENT _v_29 -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_29 MenhirState0433 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.INTERP _v_30 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_30 MenhirState0433 _menhir_initp + | Lex_menhir_token.INT _v_31 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_31 MenhirState0433 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.FLOAT _v_32 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_32 MenhirState0433 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.CHAR _v_33 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_33 MenhirState0433 _menhir_initp + | Lex_menhir_token.BYTES _v_34 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_34 MenhirState0433 _menhir_initp + | Lex_menhir_token.BYTE _v_35 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_35 MenhirState0433 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0433 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v_36 = _menhir_action_126 () in + _menhir_run_0434 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_36 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_22, MenhirState0433) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION + (_menhir_stack, _startpos_38, _endpos_39) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_40, _endpos_41) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.UIDENT _v_42 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_42 MenhirState0437 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.STRING _v_43 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_43 MenhirState0437 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_44 -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_44 MenhirState0437 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_45 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_45 MenhirState0437 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_46 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_46 MenhirState0437 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_47 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_47 MenhirState0437 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.LIDENT _v_48 -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_48 MenhirState0437 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.INTERP _v_49 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_49 MenhirState0437 _menhir_initp + | Lex_menhir_token.INT _v_50 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_50 MenhirState0437 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.FLOAT _v_51 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_51 MenhirState0437 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.CHAR _v_52 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_52 MenhirState0437 _menhir_initp + | Lex_menhir_token.BYTES _v_53 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_53 MenhirState0437 _menhir_initp + | Lex_menhir_token.BYTE _v_54 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_54 MenhirState0437 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0437 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v_55 = _menhir_action_126 () in + _menhir_run_0438 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_55 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_41, MenhirState0437) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EXCLAMATION + (_menhir_stack, _startpos_57, _endpos_58) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos_59 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_60 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN + (_menhir_stack, _startpos_59, _endpos_60) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.UIDENT _v_61 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_61 MenhirState0441 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.STRING _v_62 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_62 MenhirState0441 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_63 -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_63 MenhirState0441 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_64 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_64 MenhirState0441 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_65 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_65 MenhirState0441 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_66 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_66 MenhirState0441 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.LIDENT _v_67 -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_67 MenhirState0441 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.INTERP _v_68 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_68 MenhirState0441 _menhir_initp + | Lex_menhir_token.INT _v_69 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_69 MenhirState0441 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.FLOAT _v_70 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_70 MenhirState0441 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.CHAR _v_71 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_71 MenhirState0441 _menhir_initp + | Lex_menhir_token.BYTES _v_72 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_72 MenhirState0441 _menhir_initp + | Lex_menhir_token.BYTE _v_73 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_73 MenhirState0441 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0441 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v_74 = _menhir_action_126 () in + _menhir_run_0442 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_74 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = + (_endpos_60, MenhirState0441) + in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0431 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_QUESTION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__7_ = (_v, _endpos) in + let _v = + _menhir_action_435 _endpos__7_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0434 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__7_ = (_v, _endpos) in + let _v = + _menhir_action_432 _endpos__7_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0438 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__7_ = (_v, _endpos) in + let _v = + _menhir_action_433 _endpos__7_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0442 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT + _menhir_cell0_LIDENT + _menhir_cell0_EXCLAMATION + _menhir_cell0_EXCLAMATION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = + _menhir_stack + in + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = + _menhir_stack + in + let args, _endpos__7_ = (_v, _endpos) in + let _v = + _menhir_action_434 _endpos__7_ _endpos_meth_ _startpos_meth_ + _startpos_self_ args meth self + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_prefix_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0008 -> + _menhir_run_0655 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0593 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0593 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0457 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0655 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_PLUS -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_PLUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_e_, e = (_endpos, _v) in + let _v = _menhir_action_365 _endpos_e_ _startpos__1_ e in + _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_e_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_760 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0593 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_MINUS -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_e_, e = (_endpos, _v) in + let _v = _menhir_action_366 _endpos_e_ _startpos__1_ e in + _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_e_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_761 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined5_, _startpos__1_inlined4_, _1_inlined5) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0457 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_prefix_expr + _menhir_cell0_RANGE_EXCLUSIVE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RANGE_EXCLUSIVE + (_menhir_stack, _startpos__op_, _endpos__op_)) = + _menhir_stack + in + let (MenhirCell1_prefix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs, _op = (_endpos, _v, ()) in + let _v = + _menhir_action_378 _endpos__op_ _endpos_rhs_ _op _startpos__op_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_range_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp -let _menhir_action_762 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_xs_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_range_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.IS -> ( + let _menhir_stack = + MenhirCell1_range_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0128 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> ( + let _menhir_stack = + MenhirCell1_range_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0257 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACE + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_364 _1 in + _menhir_goto_postfix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () -let _menhir_action_763 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0262 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_prefix_expr + _menhir_cell0_RANGE_INCLUSIVE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RANGE_INCLUSIVE + (_menhir_stack, _startpos__op_, _endpos__op_)) = + _menhir_stack + in + let (MenhirCell1_prefix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs, _op = (_endpos, _v, ()) in + let _v = + _menhir_action_379 _endpos__op_ _endpos_rhs_ _op _startpos__op_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_range_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp -let _menhir_action_764 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 quantifiers - self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0260 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RANGE_INCLUSIVE -> ( + let _menhir_stack = + MenhirCell1_prefix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0261 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RANGE_EXCLUSIVE -> ( + let _menhir_stack = + MenhirCell1_prefix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0456 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACE + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_380 _1 in + _menhir_goto_range_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_765 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0120 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0121 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_391 _endpos_name_ _startpos_name_ name in + _menhir_goto_record_defn_single _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_record_defn_single : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0472 -> + _menhir_run_0473 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0605 -> + _menhir_run_0470 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0599 -> + _menhir_run_0470 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0595 -> + _menhir_run_0470 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0119 -> + _menhir_run_0470 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0469 -> + _menhir_run_0470 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0473 : type ttv_stack ttv_result. + ( ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_record_defn_single_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_record_defn_single_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_240 x xs in + _menhir_goto_non_empty_list_commas_rev_record_defn_single_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_766 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev_record_defn_single_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0599 -> + _menhir_run_0479 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0595 -> + _menhir_run_0479 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0119 -> + _menhir_run_0479 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0605 -> + _menhir_run_0471 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0469 -> + _menhir_run_0471 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0479 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_record_defn_single_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> + _menhir_run_0472 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0479 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_0 = _menhir_action_286 () in + _menhir_run_0480 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0472 : type ttv_stack ttv_result. + (( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ + as + 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, _menhir_s, _endpos) + in + _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0472 _menhir_initp + | Lex_menhir_token.RBRACE -> + let x = () in + let _v = _menhir_action_287 x in + _menhir_goto_option_COMMA_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_767 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0480 : type ttv_stack ttv_result. + ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_record_defn_single_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let comma = _v in + let _v = _menhir_action_249 comma xs in + _menhir_goto_non_empty_list_commas_with_trailing_info_record_defn_single_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_768 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_with_trailing_info_record_defn_single_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0599 -> + _menhir_run_0600 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0595 -> + _menhir_run_0478 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0119 -> + _menhir_run_0478 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0600 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_LIDENT + _menhir_cell0_COLON, + ttv_result ) + _menhir_cell1_expr, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_expr (_menhir_stack, _, e, _, _endpos_e_)) = + _menhir_stack + in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let x = _v in + let _v = + _menhir_action_389 _endpos_e_ _endpos_name_ _startpos_name_ e name x + in + _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp -let _menhir_action_769 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_record_defn : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, x = (_endpos, _v) in + let _v = _menhir_action_405 _endpos__3_ _startpos__1_ x in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_770 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_771 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_772 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0478 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _1 = _v in + let _v = _menhir_action_149 _1 in + _menhir_goto_list_commas_with_trailing_info_record_defn_single_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_773 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_with_trailing_info_record_defn_single_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0595 -> + _menhir_run_0596 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0119 -> + _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0596 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_LIDENT + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_387 _endpos_name_ _startpos_name_ name x in + _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp -let _menhir_action_774 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0481 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_type_name _menhir_cell0_COLONCOLON + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_COLONCOLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_name + ( _menhir_stack, + _menhir_s, + type_name, + _startpos_type_name_, + _ )) = + _menhir_stack + in + let x, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_406 _endpos__5_ _startpos_type_name_ type_name x + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_type_name_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0471 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_DOTDOT, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COMMA + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_record_defn_single_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> + _menhir_run_0472 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0471 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_286 () in + _menhir_run_0474 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0474 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_DOTDOT, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COMMA, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_record_defn_single_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_202 xs in + let _1 = _v in + let _v = _menhir_action_137 _1 in + _menhir_goto_list_commas_record_defn_single_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_775 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_commas_record_defn_single_ : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_DOTDOT, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COMMA + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0605 -> + _menhir_run_0606 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0469 -> + _menhir_run_0476 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0606 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_DOTDOT, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_expr (_menhir_stack, _, oe, _, _)) = + _menhir_stack + in + let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__2_, _)) + = + _menhir_stack + in + _menhir_act_goto_409 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ _endpos _v oe + | _ -> _eRR () + + and _menhir_act_goto_409 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun _endpos__7_ -> + fun fs -> + fun oe -> + match _menhir_s with + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + let (MenhirCell0_LOOP (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + let (MenhirCell0_WHILE (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + let (MenhirCell1_AMPERAMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + let (MenhirCell1_BAR (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + let (MenhirCell1_BARBAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + let (MenhirCell1_AMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + let (MenhirCell1_CARET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + let (MenhirCell1_INFIX1 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + let (MenhirCell1_INFIX2 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + let (MenhirCell1_INFIX3 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + let (MenhirCell1_INFIX4 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_409 _endpos__0_ _endpos__7_ _startpos__2_ fs + oe + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0476 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_type_name + _menhir_cell0_COLONCOLON + _menhir_cell0_LBRACE, + ttv_result ) + _menhir_cell1_DOTDOT, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_expr (_menhir_stack, _, oe, _, _)) = + _menhir_stack + in + let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell0_COLONCOLON (_menhir_stack, _endpos__2_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_type_name + (_menhir_stack, _menhir_s, x, _startpos_x_, _)) = + _menhir_stack + in + let _endpos__7_, fs = (_endpos, _v) in + let _v = + _menhir_action_410 _endpos__2_inlined1_ _endpos__7_ _startpos__2_ + _startpos_x_ fs oe x + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__7_ _startpos_x_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0470 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_239 x in + _menhir_goto_non_empty_list_commas_rev_record_defn_single_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_776 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0598 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_LIDENT + _menhir_cell0_COLON + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA + (_menhir_stack, MenhirState0598, _endpos_0) + in + _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0599 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_2 = + let x = () in + _menhir_action_287 x + in + _menhir_run_0601 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _v_3 = _menhir_action_286 () in + _menhir_run_0601 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_777 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0601 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_LIDENT + _menhir_cell0_COLON, + ttv_result ) + _menhir_cell1_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_expr (_menhir_stack, _, e, _, _endpos_e_)) = + _menhir_stack + in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let comma = _v in + let _v = + _menhir_action_388 _endpos_e_ _endpos_name_ _startpos_name_ comma e + name + in + _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp -let _menhir_action_778 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0566 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_POST_LABEL + ( _menhir_stack, + _menhir_s, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let default = _v in + let _v = + _menhir_action_354 _endpos_binder_name_ _startpos_binder_name_ + binder_name default t + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + + and _menhir_run_0562 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_POST_LABEL + ( _menhir_stack, + _menhir_s, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let default = _v in + let _v = + _menhir_action_353 _endpos_binder_name_ _startpos_binder_name_ + binder_name default + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + + and _menhir_run_0512 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_pattern _menhir_cell0_IF -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_IF (_menhir_stack, _, _)) = _menhir_stack in + let e = _v in + let _v = _menhir_action_317 e in + _menhir_goto_option___anonymous_8_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_goto_option___anonymous_8_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_pattern -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell0_option___anonymous_8_ (_menhir_stack, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FAT_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0514 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0374 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, MenhirState0374, _v, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0375 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0375 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0375 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0375 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0375 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0375 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0375 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + MenhirState0375 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0375 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0375 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.COLON -> + _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0375 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0375 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0375 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0375 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v_15 = _menhir_action_146 () in + _menhir_run_0377 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _v_15 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0375) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0374 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0374 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_146 () in + _menhir_run_0378 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0374 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0379 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, MenhirState0379, _v, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0380 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0380 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0380 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0380 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0380 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0380 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0380 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + MenhirState0380 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0380 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0380 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.COLON -> + _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0380 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0380 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0380 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0380 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0380) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v_16 = _menhir_action_324 () in + _menhir_run_0381 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _v_16 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0379 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0379 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0379 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_324 () in + _menhir_run_0383 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v _tok _menhir_initp + | _ -> _eRR () -let _menhir_action_779 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0381 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_BREAK, + ttv_result ) + _menhir_cell1_POST_LABEL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_POST_LABEL + (_menhir_stack, _, label, _startpos_label_, _endpos_label_)) = + _menhir_stack + in + let (MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_arg_, arg = (_endpos, _v) in + let _v = + _menhir_action_060 _endpos_arg_ _endpos_label_ _startpos__1_ + _startpos_label_ arg label + in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_780 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0383 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_BREAK -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_arg_, arg = (_endpos, _v) in + let _v = _menhir_action_061 _endpos_arg_ _startpos__1_ arg in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_781 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0499 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_COLON, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = + _menhir_stack + in + let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = _menhir_action_468 _endpos_expr_ _startpos__1_ expr pat t in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_782 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0495 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = + _menhir_stack + in + let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = _menhir_action_467 _endpos_expr_ _startpos__1_ expr pat in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_783 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0492 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT + _menhir_cell0_COLON, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_MUTABLE (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = + _menhir_action_470 _endpos_expr_ _endpos_name_ _startpos__1_ + _startpos_name_ expr name t + in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_784 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0488 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_MUTABLE (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = + _menhir_action_469 _endpos_expr_ _endpos_name_ _startpos__1_ + _startpos_name_ expr name + in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_785 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0483 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_RAISE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = _menhir_action_065 _endpos_expr_ _startpos__1_ expr in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_786 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0467 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_type_name _menhir_cell0_COLONCOLON + _menhir_cell0_LBRACE, + ttv_result ) + _menhir_cell1_DOTDOT + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell0_COLONCOLON (_menhir_stack, _endpos__2_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_type_name + (_menhir_stack, _menhir_s, x, _startpos_x_, _)) = + _menhir_stack + in + let _endpos__5_, oe = (_endpos_0, _v) in + let _v = + _menhir_action_408 _endpos__2_inlined1_ _endpos__5_ + _startpos__2_ _startpos_x_ oe x + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__5_ _startpos_x_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0469 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_3 = _menhir_action_136 () in + _menhir_run_0476 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_787 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers - self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0465 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) + = + _menhir_stack + in + let _endpos_e_, e = (_endpos, _v) in + let _v = + _menhir_action_390 _endpos_e_ _endpos_name_ _startpos_name_ e name + in + _menhir_goto_record_defn_single _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_788 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0461 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = + _menhir_stack + in + let _endpos__4_, index = (_endpos_0, _v) in + let _v = + _menhir_action_426 _endpos__4_ _startpos_array_ array index + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _startpos_array_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COLON -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_325 x in + _menhir_goto_option_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_option_expr_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0027 -> + _menhir_run_0589 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0398 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0396 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0396 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0383 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0381 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0589 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_RETURN -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_RETURN (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = _menhir_action_064 _endpos_expr_ _startpos__1_ expr in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_789 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0451 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _startpos__1_, _1 = (_startpos, _v) in + let _v = _menhir_action_069 _1 in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_790 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0449 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_left_value + _menhir_cell0_AUGMENTED_ASSIGNMENT -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_AUGMENTED_ASSIGNMENT + (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_left_value + (_menhir_stack, _menhir_s, lv, _startpos_lv_)) = + _menhir_stack + in + let _endpos_e_, e = (_endpos, _v) in + let _v = + _menhir_action_067 _1 _endpos__1_ _endpos_e_ _startpos__1_ + _startpos_lv_ e lv + in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_lv_ _v _menhir_s _tok _menhir_initp -let _menhir_action_791 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0447 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_left_value _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_left_value + (_menhir_stack, _menhir_s, lv, _startpos_lv_)) = + _menhir_stack + in + let _endpos_e_, e = (_endpos, _v) in + let _v = _menhir_action_068 _endpos_e_ _startpos_lv_ e lv in + _menhir_goto_expr_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos_lv_ _v _menhir_s _tok _menhir_initp -let _menhir_action_792 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0400 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, obj, _startpos_obj_, _)) = + _menhir_stack + in + let ind = _v in + let _v = _menhir_action_125 ind obj in + _menhir_goto_left_value _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos_obj_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ + | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.IS | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE + | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE + | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, array, _startpos_array_, _)) + = + _menhir_stack + in + let _endpos__4_, index = (_endpos_0, _v) in + let _v = + _menhir_action_426 _endpos__4_ _startpos_array_ array index + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _startpos_array_ _v _menhir_s + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_325 x in + _menhir_goto_option_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0388 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let arg_value = _v in + let _v = _menhir_action_003 arg_value in + _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp -let _menhir_action_793 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_794 _2_inlined1 _endpos__1_inlined3_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0382 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_325 x in + _menhir_goto_option_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_x_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0367 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_pattern_ + _menhir_cell0_IF -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_IF (_menhir_stack, _, _)) = _menhir_stack in + let e = _v in + let _v = _menhir_action_319 e in + _menhir_goto_option___anonymous_9_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_goto_option___anonymous_9_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_pattern_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell0_option___anonymous_9_ (_menhir_stack, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FAT_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0369 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0359 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_non_empty_list_commas_rev___anonymous_11_ + _menhir_cell0_COMMA + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_non_empty_list_commas_rev___anonymous_11_ + (_menhir_stack, xs)) = + _menhir_stack + in + let e = _v in + let _v = _menhir_action_212 _endpos_name_ _startpos_name_ e name xs in + _menhir_goto_non_empty_list_commas_rev___anonymous_11_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -let _menhir_action_795 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev___anonymous_11_ : + type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell0_non_empty_list_commas_rev___anonymous_11_ + (_menhir_stack, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0358 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE -> + let xs = _v in + let _v = _menhir_action_207 xs in + let _1 = _v in + let _v = _menhir_action_145 _1 in + _menhir_goto_list_commas_no_trailing___anonymous_11_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_initp + | _ -> _eRR () + + and _menhir_goto_list_commas_no_trailing___anonymous_11_ : + type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell0_list_commas_no_trailing___anonymous_11_ (_menhir_stack, _v) + in + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0361 _menhir_initp -let _menhir_action_796 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0110 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.LET -> + _menhir_run_0484 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.GUARD -> + _menhir_run_0500 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0110 _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0535 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0110 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v = _menhir_action_162 () in + _menhir_run_0559 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE + -> + let _menhir_s = MenhirState0110 in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0535 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_ASYNC (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_FN (_menhir_stack, MenhirState0535, _startpos_0) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, MenhirState0536, _v, _startpos_2, _endpos_3) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0537 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v_4 = _menhir_action_337 () in + _menhir_run_0538 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0537 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0536 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v = _menhir_action_337 () in + _menhir_run_0104 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0536 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_797 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0538 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0538 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0529 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0559 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__3_, ls = (_endpos_0, _v) in + let _v = _menhir_action_025 _endpos__3_ _startpos__1_ ls in + _menhir_goto_block_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _v _menhir_s _tok _menhir_initp -let _menhir_action_798 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_block_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0586 -> + _menhir_run_0588 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0584 -> + _menhir_run_0585 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0582 -> + _menhir_run_0583 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0109 -> + _menhir_run_0561 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0540 -> + _menhir_run_0541 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0533 -> + _menhir_run_0534 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0524 -> + _menhir_run_0525 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0348 -> + _menhir_run_0365 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0361 -> + _menhir_run_0362 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0343 -> + _menhir_run_0344 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0307 -> + _menhir_run_0308 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0305 -> + _menhir_run_0306 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0588 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_block_expr + _menhir_cell0_ELSE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_block_expr (_menhir_stack, _, ifso, _)) = + _menhir_stack + in + let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = + _menhir_stack + in + let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_ifnot_, ifnot = (_endpos, _v) in + let _v = + _menhir_action_105 _endpos_ifnot_ _startpos__1_ b ifnot ifso + in + _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_ifnot_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_799 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_if_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0586 -> + _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0587 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_block_expr + _menhir_cell0_ELSE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_block_expr (_menhir_stack, _, ifso, _)) = + _menhir_stack + in + let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = + _menhir_stack + in + let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_ifnot_, ifnot = (_endpos, _v) in + let _v = + _menhir_action_106 _endpos_ifnot_ _startpos__1_ b ifnot ifso + in + _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_ifnot_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_800 _1_inlined2 _endpos__1_inlined3_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0315 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_057 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_801 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0585 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_IF, + ttv_result ) + _menhir_cell1_infix_expr + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> ( + let _menhir_stack = + MenhirCell1_block_expr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_ELSE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0586 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = + _menhir_stack + in + let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_ifso_, ifso = (_endpos, _v) in + let _v = _menhir_action_107 _endpos_ifso_ _startpos__1_ b ifso in + _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_ifso_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0583 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_option___anonymous_14_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_14_ (_menhir_stack, _, ty_opt)) = + _menhir_stack + in + let (MenhirCell1_parameters + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__2_)) = + _menhir_stack + in + _menhir_act_goto_414 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ _endpos_ps_ _startpos_ps_ + ps has_error _endpos _v ty_opt -let _menhir_action_802 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_414 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun _endpos_ps_ -> + fun _startpos_ps_ -> + fun ps -> + fun has_error -> + fun _endpos_f_ -> + fun f -> + fun ty_opt -> + match _menhir_s with + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + let (MenhirCell1_IF (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) + = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + let (MenhirCell0_LOOP (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + let (MenhirCell0_WHILE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + let (MenhirCell1_AMPERAMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + let (MenhirCell1_BAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + let (MenhirCell1_BARBAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + let (MenhirCell1_AMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + let (MenhirCell1_CARET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + let (MenhirCell1_INFIX1 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + let (MenhirCell1_INFIX2 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + let (MenhirCell1_INFIX3 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + let (MenhirCell1_INFIX4 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_414 _endpos__0_ _endpos_f_ _endpos_ps_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0561 : type ttv_stack ttv_result. + ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_option___anonymous_14_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_14_ (_menhir_stack, _, ty_opt)) = + _menhir_stack + in + let (MenhirCell1_parameters + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _, _startpos__2_)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_f_, f = (_endpos, _v) in + let _v = + _menhir_action_413 _endpos__1_ _endpos_f_ _endpos_ps_ _startpos__1_ + _startpos__2_ _startpos_ps_ f has_error ps ty_opt + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_f_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_803 _1_inlined2 _1_inlined4 _endpos__1_inlined4_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0541 : type ttv_stack ttv_result. + ( ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_option___anonymous_7_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_7_ (_menhir_stack, _, ty_opt)) = + _menhir_stack + in + let (MenhirCell1_parameters + (_menhir_stack, _, params, _startpos_params_, _endpos_params_)) + = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _, _startpos__2_)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_block_, block = (_endpos, _v) in + let _v = + _menhir_action_471 _endpos__1_ _endpos_block_ _endpos_name_ + _endpos_params_ _startpos__1_ _startpos__2_ _startpos_name_ + _startpos_params_ block has_error name params ty_opt + in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_804 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0534 : type ttv_stack ttv_result. + ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_option___anonymous_7_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_7_ (_menhir_stack, _, ty_opt)) = + _menhir_stack + in + let (MenhirCell1_parameters + (_menhir_stack, _, params, _startpos_params_, _endpos_params_)) + = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__2_)) = + _menhir_stack + in + _menhir_act_goto_472 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ + name _startpos__2_ _endpos_params_ _startpos_params_ params + has_error _endpos _v ty_opt -let _menhir_action_805 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_472 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__2_ -> + fun _endpos_params_ -> + fun _startpos_params_ -> + fun params -> + fun has_error -> + fun _endpos_block_ -> + fun block -> + fun ty_opt -> + match _menhir_s with + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_472 _endpos__0_ _endpos_block_ + _endpos_name_ _endpos_params_ _startpos__2_ + _startpos_name_ _startpos_params_ block has_error + name params ty_opt + in + _menhir_run_0552 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _tok _menhir_initp + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_472 _endpos__0_ _endpos_block_ + _endpos_name_ _endpos_params_ _startpos__2_ + _startpos_name_ _startpos_params_ block has_error + name params ty_opt + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__2_ _v _menhir_s _tok + _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_472 _endpos__0_ _endpos_block_ + _endpos_name_ _endpos_params_ _startpos__2_ + _startpos_name_ _startpos_params_ block has_error + name params ty_opt + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__2_ _v _menhir_s _tok + _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_472 _endpos__0_ _endpos_block_ + _endpos_name_ _endpos_params_ _startpos__2_ + _startpos_name_ _startpos_params_ block has_error + name params ty_opt + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__2_ _v _menhir_s _tok + _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_472 _endpos__0_ _endpos_block_ + _endpos_name_ _endpos_params_ _startpos__2_ + _startpos_name_ _startpos_params_ block has_error + name params ty_opt + in + _menhir_run_0548 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__2_ _v _menhir_s _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0525 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_GUARD, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_ELSE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_ELSE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = + _menhir_stack + in + let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_else__, else_ = (_endpos, _v) in + let _v = _menhir_action_102 _endpos_else__ _startpos__1_ cond else_ in + _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_806 _1_inlined2 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined4_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0365 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_block_expr (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> + _menhir_run_0307 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0365 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_339 () in + _menhir_run_0366 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0307 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_block_expr as 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0307 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_807 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0366 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_block_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_block_expr (_menhir_stack, _, body, _)) = + _menhir_stack + in + let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_loop_label_colon + ( _menhir_stack, + _menhir_s, + label, + _startpos_label_, + _endpos_label_ )) = + _menhir_stack + in + let _endpos_for_else_, for_else = (_endpos, _v) in + let _v = + _menhir_action_083 _endpos_for_else_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body for_else label + in + _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_for_else_ _startpos_label_ _v _menhir_s _tok _menhir_initp -let _menhir_action_808 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined4_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_809 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__1_inlined5_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined5_, _startpos__1_inlined4_, _1_inlined5) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_for_expr : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_053 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_810 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0362 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_list_commas_no_trailing___anonymous_11_ + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_block_expr (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> + _menhir_run_0307 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0362 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_339 () in + _menhir_run_0363 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0363 : type ttv_stack ttv_result. + ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_list_commas_no_trailing___anonymous_11_, + ttv_result ) + _menhir_cell1_block_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_block_expr (_menhir_stack, _, body, _)) = + _menhir_stack + in + let (MenhirCell0_list_commas_no_trailing___anonymous_11_ + (_menhir_stack, continue_block)) = + _menhir_stack + in + let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = + _menhir_stack + in + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_loop_label_colon + ( _menhir_stack, + _menhir_s, + label, + _startpos_label_, + _endpos_label_ )) = + _menhir_stack + in + let _endpos_for_else_, for_else = (_endpos, _v) in + let _v = + _menhir_action_082 _endpos_for_else_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body condition continue_block for_else + label + in + _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_for_else_ _startpos_label_ _v _menhir_s _tok _menhir_initp -let _menhir_action_811 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined4_, x_inlined1, _1_inlined5) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0344 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN, + ttv_result ) + _menhir_cell1_expr + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_block_expr (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> + _menhir_run_0307 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0344 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_339 () in + _menhir_run_0345 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0345 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN, + ttv_result ) + _menhir_cell1_expr, + ttv_result ) + _menhir_cell1_block_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_block_expr (_menhir_stack, _, body, _)) = + _menhir_stack + in + let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = + _menhir_stack + in + let (MenhirCell0_IN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_foreach_binder_ + (_menhir_stack, _, binders)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_loop_label_colon + ( _menhir_stack, + _menhir_s, + label, + _startpos_label_, + _endpos_label_ )) = + _menhir_stack + in + let _endpos_else_block_, else_block = (_endpos, _v) in + let _v = + _menhir_action_086 _endpos_else_block_ _endpos_label_ _startpos__2_ + _startpos_label_ binders body else_block expr label + in + let _endpos, _startpos = (_endpos_else_block_, _startpos_label_) in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_054 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0308 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_block_expr, + ttv_result ) + _menhir_cell1_ELSE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_ELSE (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let _endpos_else__, else_ = (_endpos, _v) in + let _v = _menhir_action_338 else_ in + _menhir_goto_optional_else _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_else__ _v _menhir_s _tok _menhir_initp -let _menhir_action_812 _endpos__1_inlined1_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_optional_else : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_block_expr as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0365 -> + _menhir_run_0366 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0362 -> + _menhir_run_0363 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0344 -> + _menhir_run_0345 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0306 -> + _menhir_run_0309 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0309 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_WHILE, + ttv_result ) + _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_block_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_block_expr (_menhir_stack, _, body, _)) = + _menhir_stack + in + let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = + _menhir_stack + in + let (MenhirCell0_WHILE (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_loop_label_colon + ( _menhir_stack, + _menhir_s, + label, + _startpos_label_, + _endpos_label_ )) = + _menhir_stack + in + let _endpos_while_else_, while_else = (_endpos, _v) in + let _v = + _menhir_action_600 _endpos_label_ _endpos_while_else_ _startpos__2_ + _startpos_label_ body cond label while_else + in + let _endpos, _startpos = (_endpos_while_else_, _startpos_label_) in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_055 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0306 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_WHILE, + ttv_result ) + _menhir_cell1_infix_expr + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_block_expr (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ELSE -> + _menhir_run_0307 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0306 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_339 () in + _menhir_run_0309 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0354 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI, + ttv_result ) + _menhir_cell1_option_infix_expr_ + _menhir_cell0_SEMI + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let e = _v in + let _v = _menhir_action_211 _endpos_name_ _startpos_name_ e name in + _menhir_goto_non_empty_list_commas_rev___anonymous_11_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -let _menhir_action_813 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0343 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_foreach_binder_ + _menhir_cell0_IN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0343 _menhir_initp + | _ -> _eRR () -let _menhir_action_814 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined1_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0339 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev___anonymous_10_ + _menhir_cell0_COMMA + _menhir_cell0_LIDENT + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev___anonymous_10_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let e = _v in + let _v = _menhir_action_210 _endpos_name_ _startpos_name_ e name xs in + _menhir_goto_non_empty_list_commas_rev___anonymous_10_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_815 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_commas_rev___anonymous_10_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev___anonymous_10_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0338 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE | Lex_menhir_token.SEMI _ -> + let xs = _v in + let _v = _menhir_action_206 xs in + let _1 = _v in + let _v = _menhir_action_143 _1 in + _menhir_goto_list_commas_no_trailing___anonymous_10_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_list_commas_no_trailing___anonymous_10_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let binders = _v in + let _v = _menhir_action_081 binders in + let _menhir_stack = + MenhirCell1_for_binders (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _v, _menhir_s = (_v_0, MenhirState0348) in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_SEMI (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_s = MenhirState0349 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_326 () in + _menhir_goto_option_infix_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0348 _menhir_initp + | _ -> _menhir_fail () + + and _menhir_goto_option_infix_expr_ : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_infix_expr_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _v = _v_0 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_SEMI (_menhir_stack, _v, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0353 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.LBRACE -> + let _v = _menhir_action_144 () in + _menhir_goto_list_commas_no_trailing___anonymous_11_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp + | _ -> _eRR ()) + | _ -> _menhir_fail () + + and _menhir_run_0329 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_LIDENT + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) + = + _menhir_stack + in + let e = _v in + let _v = _menhir_action_209 _endpos_name_ _startpos_name_ e name in + _menhir_goto_non_empty_list_commas_rev___anonymous_10_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_816 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0324 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_221 x in + _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_817 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined1_, x_inlined1, _1_inlined2) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0318 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_expr_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_expr_ + (_menhir_stack, _menhir_s, xs, _)) = + _menhir_stack + in + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_222 x xs in + _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_818 _2_inlined1 _endpos__1_inlined2_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0517 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _1 = _v in + let _v = _menhir_action_157 _1 in + _menhir_goto_list_semis_single_pattern_case_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -let _menhir_action_819 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0509 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_262 x in + _menhir_goto_non_empty_list_semi_rev_aux_single_pattern_case_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_820 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0450 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_pattern_ + _menhir_cell0_option___anonymous_9_ + _menhir_cell0_FAT_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_option___anonymous_9_ (_menhir_stack, guard)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list_commas_pattern_ + (_menhir_stack, _menhir_s, pats)) = + _menhir_stack + in + let body = _v in + let _v = _menhir_action_181 body guard pats in + _menhir_goto_multi_pattern_case _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp -let _menhir_action_821 _1_inlined3 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_multi_pattern_case : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0271 -> + _menhir_run_0452 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0321 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0321 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0321 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0321 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0321 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0452 : type ttv_stack ttv_result. + ( ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_multi_pattern_case_, + ttv_result ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_multi_pattern_case_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_259 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_multi_pattern_case_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_822 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_non_empty_list_semi_rev_aux_multi_pattern_case_ : + type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_multi_pattern_case_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.UIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0271 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.STRING _v_2 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0271 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0271 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.LIDENT _v_4 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0271 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.INT _v_5 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0271 _menhir_initp + | Lex_menhir_token.FLOAT _v_6 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0271 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.CHAR _v_7 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0271 _menhir_initp + | Lex_menhir_token.BYTES _v_8 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0271 _menhir_initp + | Lex_menhir_token.BYTE _v_9 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0271 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0270, _v_0, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0271 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_0453 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0453 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0453 : type ttv_stack ttv_result. + ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_multi_pattern_case_ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_multi_pattern_case_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_277 xs in + let _1 = _v in + let _v = _menhir_action_271 _1 in + let _1 = _v in + let _v = _menhir_action_153 _1 in + _menhir_goto_list_semis_multi_pattern_case_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + + and _menhir_goto_list_semis_multi_pattern_case_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0554 -> + _menhir_run_0555 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0545 -> + _menhir_run_0546 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0542 -> + _menhir_run_0543 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0267 -> + _menhir_run_0454 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0320 -> + _menhir_run_0322 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0546 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_fn_header -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_fn_header + (_menhir_stack, _, binder, _startpos_binder_, _endpos_binder_)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__4_, cases = (_endpos, _v) in + let _v = + _menhir_action_473 _endpos__1_ _endpos__4_ _endpos_binder_ + _startpos__1_ _startpos_binder_ binder cases + in + _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_823 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_824 _1_inlined1 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers self_ty x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0543 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_fn_header_no_binder -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_fn_header_no_binder + ( _menhir_stack, + _, + has_error, + _startpos_has_error_, + _endpos_has_error_ )) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__4_, cases = (_endpos, _v) in + let _v = + _menhir_action_415 _endpos__1_ _endpos__4_ _endpos_has_error_ + _startpos__1_ _startpos_has_error_ cases has_error + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos__1_ _v _menhir_s _tok _menhir_initp -let _menhir_action_825 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0454 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_fn_header_no_binder -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_fn_header_no_binder + ( _menhir_stack, + _menhir_s, + has_error, + _startpos_has_error_, + _endpos_has_error_ )) = + _menhir_stack + in + _menhir_act_goto_416 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos _endpos_has_error_ + _startpos_has_error_ has_error _v -let _menhir_action_826 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_416 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__4_ -> + fun _endpos_has_error_ -> + fun _startpos_has_error_ -> + fun has_error -> + fun cases -> + match _menhir_s with + | MenhirState0841 -> + let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0754 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0026 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0551 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0110 -> + let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0514 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0369 -> + let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState1069 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0761 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0000 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0003 -> + let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0008 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0014 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0646 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0015 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0016 -> + let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0019 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0024 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0630 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0025 -> + let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0626 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0618 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0602 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0597 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0590 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0027 -> + let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0030 -> + let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0565 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0096 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0500 -> + let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0511 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0503 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0498 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0494 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0491 -> + let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0487 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0111 -> + let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0466 -> + let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0460 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0456 -> + let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0448 -> + let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) + = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0446 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0441 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0437 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0433 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0430 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0423 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0419 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0415 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0412 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0407 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0403 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0397 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0395 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0387 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0385 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0379 -> + let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0380 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0374 -> + let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0375 -> + let (MenhirCell1_POST_LABEL (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0358 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0353 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0349 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0342 -> + let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0338 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0328 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0312 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0310 -> + let (MenhirCell0_LOOP (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0304 -> + let (MenhirCell0_WHILE (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0300 -> + let (MenhirCell1_AMPERAMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0298 -> + let (MenhirCell1_BAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0296 -> + let (MenhirCell1_BARBAR (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0294 -> + let (MenhirCell1_AMPER (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0292 -> + let (MenhirCell1_CARET (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0290 -> + let (MenhirCell1_INFIX1 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0288 -> + let (MenhirCell1_INFIX2 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0286 -> + let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0284 -> + let (MenhirCell1_INFIX3 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0280 -> + let (MenhirCell1_INFIX4 (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0278 -> + let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0276 -> + let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0273 -> + let (MenhirCell0_IF (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0261 -> + let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0125 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | MenhirState0121 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_416 _endpos__0_ _endpos__4_ + _endpos_has_error_ _startpos_has_error_ cases has_error + in + _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__4_ _startpos_has_error_ _v _menhir_s _tok + _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_827 _1_inlined1 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0321 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_258 x in + _menhir_goto_non_empty_list_semi_rev_aux_multi_pattern_case_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp -let _menhir_action_828 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_option_SEMI_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1096 -> _menhir_run_1349 _menhir_stack _tok + | MenhirState0830 -> + _menhir_run_0833 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | MenhirState0800 -> + _menhir_run_0803 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | MenhirState0743 -> + _menhir_run_0746 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | MenhirState0613 -> + _menhir_run_0614 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_initp + | MenhirState0550 -> + _menhir_run_0558 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_initp + | MenhirState0518 -> + _menhir_run_0521 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | MenhirState0270 -> + _menhir_run_0453 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0803 : type ttv_stack. + ( ttv_stack _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_278 xs in + let _1 = _v in + let _v = _menhir_action_272 _1 in + let _1 = _v in + let _v = _menhir_action_155 _1 in + _menhir_goto_list_semis_record_decl_field_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + + and _menhir_goto_list_semis_record_decl_field_ : type ttv_stack. + (ttv_stack _menhir_cell0_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1090 -> + _menhir_run_1091 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | MenhirState0775 -> + _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1091 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_struct_header + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_semis_record_decl_field_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1092 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1093 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1093 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_struct_header + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_record_decl_field_ + _menhir_cell0_RBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_semis_record_decl_field_ (_menhir_stack, _, fs)) + = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_struct_header + ( _menhir_stack, + _menhir_s, + struct_header, + _startpos_struct_header_ )) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_495 _endpos_deriving__ _startpos_struct_header_ + deriving_ fs struct_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_829 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0804 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_semis_record_decl_field_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0805 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_0806 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0806 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_record_decl_field_ + _menhir_cell0_RBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_semis_record_decl_field_ (_menhir_stack, _, fs)) + = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_164 _endpos_tycon_ _startpos_tycon_ deriving_ fs + tycon + in + _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_deriving__ _startpos__1_ _v _menhir_s _tok + _menhir_initp -let _menhir_action_830 _1_inlined1 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_local_type_decl : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _menhir_stack = + MenhirCell1_local_type_decl + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0841 _menhir_initp + | Lex_menhir_token.TYPE -> + _menhir_run_0755 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.STRUCT -> + _menhir_run_0773 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0841 _menhir_initp + | Lex_menhir_token.RETURN -> + _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.RAISE -> + _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0841 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0370 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0841 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0841 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0841 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0841 _menhir_initp + | Lex_menhir_token.LET -> + _menhir_run_0484 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0841 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0841 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.GUARD -> + _menhir_run_0500 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0841 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.ENUM -> + _menhir_run_0807 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.ELLIPSIS -> + _menhir_run_0373 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.CONTINUE -> + _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0841 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0841 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0841 _menhir_initp + | Lex_menhir_token.BREAK -> + _menhir_run_0379 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0535 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0841 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_15 = _menhir_action_162 () in + _menhir_run_0843 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _endpos_1 _v_15 MenhirState0841 _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0841) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _endpos_t_, _startpos_t_, t = (_endpos, _startpos, _v) in + let _v = _menhir_action_167 _endpos_t_ _startpos_t_ t in + _menhir_goto_local_types_and_stmts _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_831 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0807 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0807 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_832 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0843 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos_ls_, _startpos_ls_, ls = (_endpos, _startpos, _v) in + let _v = _menhir_action_168 _endpos_ls_ _startpos_ls_ ls in + _menhir_goto_local_types_and_stmts _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + + and _menhir_goto_local_types_and_stmts : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0841 -> + _menhir_run_0842 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0754 -> + _menhir_run_0838 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0842 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_local_type_decl + _menhir_cell0_SEMI -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_local_type_decl (_menhir_stack, _menhir_s, t, _, _)) = + _menhir_stack + in + let rest = _v in + let _v = _menhir_action_169 rest t in + _menhir_goto_local_types_and_stmts _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp -let _menhir_action_833 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers self_ty - x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0838 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let _endpos__3_, block = (_endpos, _v) in + let _v = _menhir_action_026 block in + _menhir_goto_block_expr_with_local_types _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _v _menhir_s _tok _menhir_initp -let _menhir_action_834 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_block_expr_with_local_types : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1331 -> + _menhir_run_1339 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1122 -> + _menhir_run_1123 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1297 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1289 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1244 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1236 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1169 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1161 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1033 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1025 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0980 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0972 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0897 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0884 -> + _menhir_run_0888 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0753 -> + _menhir_run_0844 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1339 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) + = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = _menhir_action_503 _endpos_body_ _startpos_t_ body t in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_835 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1123 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ (_menhir_stack, _, params, _, _)) + = + _menhir_stack + in + let (MenhirCell1_option_loced_string_ (_menhir_stack, _, name)) = + _menhir_stack + in + let (MenhirCell0_TEST (_menhir_stack, _startpos__2_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_517 _1 _endpos__1_ _endpos_body_ _startpos__1_ + _startpos__2_ body name params + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_836 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0888 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_block_, block = (_endpos, _v) in + let _v = _menhir_action_108 block in + _menhir_goto_impl_body _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_block_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_impl_body : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1297 -> + _menhir_run_1298 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1289 -> + _menhir_run_1290 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1244 -> + _menhir_run_1245 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1236 -> + _menhir_run_1237 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1169 -> + _menhir_run_1170 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1161 -> + _menhir_run_1162 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1033 -> + _menhir_run_1034 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1025 -> + _menhir_run_1026 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0980 -> + _menhir_run_0981 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0972 -> + _menhir_run_0973 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0897 -> + _menhir_run_0898 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0884 -> + _menhir_run_0887 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1298 : type ttv_stack. + ( ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_521 _1 _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty self_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_837 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1290 : type ttv_stack. + ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_527 _1 _endpos__1_ _endpos_body_ _endpos_name_ + _endpos_ret_ty_ _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_838 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1245 : type ttv_stack. + ( ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_522 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ body has_error name params + quantifiers ret_ty self_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_839 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1237 : type ttv_stack. + ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_528 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ body has_error name params + quantifiers ret_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_840 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1170 : type ttv_stack. + ( ( ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_523 _1 _endpos__1_ _endpos_attr_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ attr body has_error name params + quantifiers ret_ty self_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_841 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1162 : type ttv_stack. + ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_body_, body = (_endpos, _v) in + let _v = + _menhir_action_529 _1 _endpos__1_ _endpos_attr_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__1_ _startpos__1_inlined1_ + _startpos__3_ _startpos_name_ attr body has_error name params + quantifiers ret_ty trait + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_842 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1034 : type ttv_stack. + ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + _menhir_act_goto_518 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name + _startpos__3_ params _endpos _v has_error trait quantifiers + _endpos_ret_ty_ ret_ty self_ty -let _menhir_action_843 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_518 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + fun self_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_518 _endpos__0_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__3_ + _startpos_name_ body has_error name params + quantifiers ret_ty self_ty trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_518 _endpos__0_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__3_ + _startpos_name_ body has_error name params + quantifiers ret_ty self_ty trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1087 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_266 x in + _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_1026 : type ttv_stack. + ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + _menhir_act_goto_524 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name + _startpos__3_ params _endpos _v has_error trait quantifiers + _endpos_ret_ty_ ret_ty -let _menhir_action_844 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_524 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_524 _endpos__0_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__3_ + _startpos_name_ body has_error name params + quantifiers ret_ty trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_524 _endpos__0_ _endpos_body_ + _endpos_name_ _endpos_ret_ty_ _startpos__3_ + _startpos_name_ body has_error name params + quantifiers ret_ty trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0981 : type ttv_stack. + ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + _menhir_act_goto_519 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos__1_ _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ params _endpos _v has_error trait + quantifiers _endpos_ret_ty_ ret_ty self_ty -let _menhir_action_845 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_519 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__1_ -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + fun self_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_519 _endpos__0_ _endpos__1_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty self_ty + trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_519 _endpos__0_ _endpos__1_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty self_ty + trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0973 : type ttv_stack. + ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + _menhir_act_goto_525 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos__1_ _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ params _endpos _v has_error trait + quantifiers _endpos_ret_ty_ ret_ty -let _menhir_action_846 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_525 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__1_ -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_525 _endpos__0_ _endpos__1_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_525 _endpos__0_ _endpos__1_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ body + has_error name params quantifiers ret_ty trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0898 : type ttv_stack. + ( ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_3_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_3_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_FOR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + _menhir_act_goto_520 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos_attr_ attr params _endpos + _v has_error trait quantifiers _endpos_ret_ty_ ret_ty self_ty -let _menhir_action_847 _1_inlined4 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_520 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_attr_ -> + fun attr -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + fun self_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_520 _endpos__0_ _endpos_attr_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ + attr body has_error name params quantifiers + ret_ty self_ty trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_520 _endpos__0_ _endpos_attr_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ + attr body has_error name params quantifiers + ret_ty self_ty trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0887 : type ttv_stack. + ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_4_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option___anonymous_4_ + (_menhir_stack, _, ret_ty, _endpos_ret_ty_)) = + _menhir_stack + in + let (MenhirCell1_parameters (_menhir_stack, _, params, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_type_name (_menhir_stack, _, trait, _, _)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell0_IMPL (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + _menhir_act_goto_526 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos_attr_ attr params _endpos + _v has_error trait quantifiers _endpos_ret_ty_ ret_ty -let _menhir_action_848 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_526 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_attr_ -> + fun attr -> + fun params -> + fun _endpos_body_ -> + fun body -> + fun has_error -> + fun trait -> + fun quantifiers -> + fun _endpos_ret_ty_ -> + fun ret_ty -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_526 _endpos__0_ _endpos_attr_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ attr + body has_error name params quantifiers ret_ty + trait + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_526 _endpos__0_ _endpos_attr_ + _endpos_body_ _endpos_name_ _endpos_ret_ty_ + _startpos__1_ _startpos__3_ _startpos_name_ attr + body has_error name params quantifiers ret_ty + trait + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0844 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ (_menhir_stack, _, params, _, _)) + = + _menhir_stack + in + let (MenhirCell1_option_loced_string_ (_menhir_stack, _, name)) = + _menhir_stack + in + let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__2_)) = + _menhir_stack + in + _menhir_act_goto_516 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp name _startpos__2_ params _endpos _v -let _menhir_action_849 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_516 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun name -> + fun _startpos__2_ -> + fun params -> + fun _endpos_body_ -> + fun body -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_516 _endpos__0_ _endpos_body_ _startpos__2_ + body name params + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_516 _endpos__0_ _endpos_body_ _startpos__2_ + body name params + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_850 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0746 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_282 xs in + let _1 = _v in + let _v = _menhir_action_275 _1 in + let _1 = _v in + let _v = _menhir_action_161 _1 in + _menhir_goto_list_semis_trait_method_decl_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + + and _menhir_goto_list_semis_trait_method_decl_ : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1219 -> + _menhir_run_1220 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState1144 -> + _menhir_run_1145 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState1117 -> + _menhir_run_1118 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0955 -> + _menhir_run_0956 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0865 -> + _menhir_run_0866 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | MenhirState0707 -> + _menhir_run_0747 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1220 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAIT (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__8_, methods = (_endpos, _v) in + let _v = + _menhir_action_508 _1 _endpos__1_ _endpos__1_inlined1_ _endpos__8_ + _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ methods name supers + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_851 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__1_inlined4_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1145 : type ttv_stack. + ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAIT (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__8_, methods = (_endpos, _v) in + let _v = + _menhir_action_509 _1 _endpos__1_ _endpos__8_ _endpos_attr_ + _endpos_name_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ attr methods name supers + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_852 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_1118 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAIT (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos__8_, methods = (_endpos, _v) in + let _v = + _menhir_action_507 _1 _endpos__1_ _endpos__8_ _endpos_name_ + _startpos__1_ _startpos__3_ _startpos_name_ methods name supers + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp -let _menhir_action_853 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0956 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAIT (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + _menhir_act_goto_505 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos__1_ _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos _v supers -let _menhir_action_854 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined4_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_505 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__1_ -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos__8_ -> + fun methods -> + fun supers -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_505 _endpos__0_ _endpos__1_ _endpos__8_ + _endpos_name_ _startpos__1_ _startpos__3_ + _startpos_name_ methods name supers + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_505 _endpos__0_ _endpos__1_ _endpos__8_ + _endpos_name_ _startpos__1_ _startpos__3_ + _startpos_name_ methods name supers + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0866 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAIT (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + _menhir_act_goto_506 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos_attr_ attr _endpos _v + supers -let _menhir_action_855 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_506 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_attr_ -> + fun attr -> + fun _endpos__8_ -> + fun methods -> + fun supers -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_506 _endpos__0_ _endpos__8_ + _endpos_attr_ _endpos_name_ _startpos__1_ + _startpos__3_ _startpos_name_ attr methods name + supers + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_506 _endpos__0_ _endpos__8_ + _endpos_attr_ _endpos_name_ _startpos__1_ + _startpos__3_ _startpos_name_ attr methods name + supers + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0747 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_TRAIT (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + _menhir_act_goto_504 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name + _startpos__3_ _endpos _v supers -let _menhir_action_856 _1_inlined2 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_act_goto_504 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos__8_ -> + fun methods -> + fun supers -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_504 _endpos__0_ _endpos__8_ _endpos_name_ + _startpos__3_ _startpos_name_ methods name supers + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_504 _endpos__0_ _endpos__8_ _endpos_name_ + _startpos__3_ _startpos_name_ methods name supers + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () -let _menhir_action_857 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined5_, _startpos__1_inlined4_, _1_inlined5) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_858 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_xs_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0614 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_statement_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ + (_menhir_stack, _, xs, _startpos_xs_)) = + _menhir_stack + in + let _endpos_semi_, semi = (_endpos, _v) in + let _v = _menhir_action_285 semi xs in + let _endpos, _startpos = (_endpos_semi_, _startpos_xs_) in + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let ( _endpos__3_, + _endpos__1_inlined1_, + _startpos__1_inlined1_, + _1_inlined1 ) = + (_endpos_0, _endpos, _startpos, _v) + in + let _v = + _menhir_action_411 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ + _startpos__1_ _startpos__1_inlined1_ + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0558 : type ttv_stack ttv_result. + ( ttv_stack, + ttv_result ) + _menhir_cell1_non_empty_list_semi_rev_aux_statement_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ + (_menhir_stack, _menhir_s, xs, _startpos_xs_)) = + _menhir_stack + in + let _endpos__2_ = _endpos in + let _v = _menhir_action_280 xs in + let _endpos, _startpos = (_endpos__2_, _startpos_xs_) in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_163 _1 in + _menhir_goto_list_semis_rev_statement_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _menhir_initp -let _menhir_action_859 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_goto_list_semis_rev_statement_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0754 -> + _menhir_run_0843 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _menhir_initp + | MenhirState0841 -> + _menhir_run_0843 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _menhir_initp + | MenhirState0110 -> + _menhir_run_0559 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0550 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_statement_ + (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> + _menhir_run_0551 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0550 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0558 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_initp + | _ -> _eRR () -let _menhir_action_860 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0545 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_ASYNC as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fn_header + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0545 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0545 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0545 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0545 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0545 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0545 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0545 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0545 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0545 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0545 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_9 = _menhir_action_152 () in + _menhir_run_0546 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + _menhir_initp + | _ -> _eRR () -let _menhir_action_861 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0033 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_FN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0033 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0105 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () -let _menhir_action_862 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0751 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TEST as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_loced_string_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0751 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0753 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0751 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0753 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST, + _menhir_box_structure ) + _menhir_cell1_option_loced_string_ + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0753 _menhir_initp + | _ -> _eRR () -let _menhir_action_863 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0845 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0845 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () -let _menhir_action_864 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) + and _menhir_run_0848 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0777 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0848 _menhir_initp + | Lex_menhir_token.ASYNC | Lex_menhir_token.CONST + | Lex_menhir_token.ENUM | Lex_menhir_token.EXTERN | Lex_menhir_token.FN + | Lex_menhir_token.IMPL | Lex_menhir_token.LET | Lex_menhir_token.STRUCT + | Lex_menhir_token.TRAIT | Lex_menhir_token.TRAITALIAS + | Lex_menhir_token.TYPE | Lex_menhir_token.TYPEALIAS -> + let _v = _menhir_action_368 () in + _menhir_run_0849 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v MenhirState0848 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0777 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.READONLY -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__3_ = _endpos_0 in + let _v = _menhir_action_369 () in + _menhir_goto_pub_attr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LIDENT _v -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__3_, attr = (_endpos_3, _v) in + let _v = _menhir_action_370 attr in + _menhir_goto_pub_attr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () -let _menhir_action_865 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_866 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_867 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_868 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_869 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_870 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_871 _1_inlined3 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_872 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_873 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_874 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ name - name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_875 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_876 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_877 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_878 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_879 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_880 _1_inlined1 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_881 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_882 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_883 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = None in - let _endpos_pub_, _startpos_pub_ = (_endpos__0_, _endpos__0_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_884 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_885 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_886 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_887 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_888 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_889 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_890 _2_inlined1 _endpos__1_inlined3_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_891 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_892 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_893 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_894 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_895 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_896 _1_inlined2 _endpos__1_inlined3_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_897 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_898 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_899 _1_inlined2 _1_inlined4 _endpos__1_inlined4_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_900 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_901 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_902 _1_inlined2 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined4_, _startpos__1_inlined4_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_903 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined4_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_904 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined4_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_905 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__1_inlined5_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined5_, _startpos__1_inlined4_, _1_inlined5) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_906 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined4_, _1_inlined5) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_907 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined4_, x_inlined1, _1_inlined5) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1_inlined1 = _1_inlined2 in - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = true in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_908 _endpos__1_inlined1_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_909 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_910 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined1_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_911 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined2_, _startpos__1_inlined1_, _1_inlined2) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_912 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined1_, _1_inlined2) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_913 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined1_, x_inlined1, _1_inlined2) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_914 _2_inlined1 _endpos__1_inlined2_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_915 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_916 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_917 _1_inlined3 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_918 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_919 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = [] in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_920 _1_inlined1 _endpos__1_inlined2_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ name - name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined2_, _startpos__1_inlined2_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_921 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined2_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_922 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_923 _1_inlined1 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_924 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined2_, _1_inlined3) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_925 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined2_, x_inlined1, _1_inlined3) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = None in - let _endpos_ret_ty_ = _endpos__3_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_926 _1_inlined1 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined3_, _startpos__1_inlined3_) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = (_endpos__1_, _endpos__1_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_927 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_ = _startpos__1_inlined3_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_928 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = [] in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_929 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers x = - let body = - let _endpos__1_inlined1_, _startpos__1_, _1_inlined1 = - (_endpos__1_inlined4_, _startpos__1_inlined3_, _1_inlined4) - in - let ls = [] in - let _endpos_ls_, _startpos_ls_ = - (_endpos__1_inlined1_, _endpos__1_inlined1_) - in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_930 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x xs = - let body = - let _startpos__1_, _1_inlined1 = (_startpos__1_inlined3_, _1_inlined4) in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_xs_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_931 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name name_inlined1 - quantifiers x x_inlined1 xs = - let body = - let _endpos_x_, _startpos__1_, x, _1_inlined1 = - (_endpos_x_inlined1_, _startpos__1_inlined3_, x_inlined1, _1_inlined4) - in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos_ls_, _startpos_ls_ = (_endpos_x_, _startpos_xs_) in - let ts = - let _1 = _1_inlined1 in - _1 - in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _loc_ls_ = (_startpos_ls_, _endpos_ls_) in - let _sloc = (_symbolstartpos, _endpos) in - ( ts, - Parsing_compact.compact_rev ls (if ts = [] then i _sloc else i _loc_ls_) - ) - in - let _endpos_body_ = _endpos__4_ in - let ret_ty = - let _2 = _2_inlined1 in - let x = _2 in - Some x - in - let _endpos_ret_ty_ = _endpos__2_inlined1_ in - let params = - let _1 = - let x = - let _1 = _1_inlined1 in - _1 - in - x - in - _1 - in - let has_error = false in - let method_name = - let _endpos_name_, _startpos_name_, name = - (_endpos_name_inlined1_, _startpos_name_inlined1_, name_inlined1) - in - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let trait = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.name; loc_ = i _loc } - in - let pub = Some x in - let _endpos_pub_, _startpos_pub_ = (_endpos_x_, _startpos_x_) in - let _endpos = _endpos_body_ in - let _symbolstartpos = - if _startpos_pub_ != _endpos_pub_ then _startpos_pub_ else _startpos__2_ - in - let _sloc = (_symbolstartpos, _endpos) in - (let header_loc_ = i (_startpos__2_, _endpos_ret_ty_) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { - self_ty = None; - trait; - method_name; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = Option.is_some pub; - local_types; - header_loc_; - loc_ = aloc _sloc; - doc_ = Docstring.empty; - } - : Parsing_syntax.impl) - -let _menhir_action_932 _endpos_name_ _endpos_return_type_ _startpos_name_ name - quantifiers return_type = - let params = [] in - let has_error = true in - let name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_return_type_ in - let _symbolstartpos = _startpos_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Trait_method - { name; has_error; quantifiers; params; return_type; loc_ = i _sloc } - : Parsing_syntax.trait_method_decl) - -let _menhir_action_933 _1_inlined1 _endpos_name_ _endpos_return_type_ - _startpos_name_ name quantifiers return_type = - let params = - let _1 = _1_inlined1 in - _1 - in - let has_error = true in - let name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_return_type_ in - let _symbolstartpos = _startpos_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Trait_method - { name; has_error; quantifiers; params; return_type; loc_ = i _sloc } - : Parsing_syntax.trait_method_decl) - -let _menhir_action_934 _endpos_name_ _endpos_return_type_ _startpos_name_ name - quantifiers return_type = - let params = [] in - let has_error = false in - let name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_return_type_ in - let _symbolstartpos = _startpos_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Trait_method - { name; has_error; quantifiers; params; return_type; loc_ = i _sloc } - : Parsing_syntax.trait_method_decl) - -let _menhir_action_935 _1 _endpos_name_ _endpos_return_type_ _startpos_name_ - name quantifiers return_type = - let params = _1 in - let has_error = false in - let name = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let _endpos = _endpos_return_type_ in - let _symbolstartpos = _startpos_name_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Trait_method - { name; has_error; quantifiers; params; return_type; loc_ = i _sloc } - : Parsing_syntax.trait_method_decl) - -let _menhir_action_936 typ : Parsing_syntax.trait_method_param = - { Parsing_syntax.tmparam_typ = typ; tmparam_label = None } - -let _menhir_action_937 _endpos_label_name_ _startpos_label_name_ label_name typ - = - let _loc_label_name_ = (_startpos_label_name_, _endpos_label_name_) in - (let label = - { - Parsing_syntax.label_name; - loc_ = Rloc.trim_first_char (i _loc_label_name_); - } - in - { Parsing_syntax.tmparam_typ = typ; tmparam_label = Some label } - : Parsing_syntax.trait_method_param) - -let _menhir_action_938 _endpos_label_name_ _startpos_label_name_ label_name typ - = - let _loc_label_name_ = (_startpos_label_name_, _endpos_label_name_) in - (let label = - { - Parsing_syntax.label_name; - loc_ = Rloc.trim_last_char (i _loc_label_name_); - } - in - { Parsing_syntax.tmparam_typ = typ; tmparam_label = Some label } - : Parsing_syntax.trait_method_param) - -let _menhir_action_939 _endpos__1_ _endpos__2_ _endpos__5_ _startpos__1_ - _startpos__1_inlined1_ body catch = - let catch_keyword = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (false, i _sloc) - in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = None; - else_loc_ = Rloc.no_location; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_940 _endpos__1_ _endpos__1_inlined1_ _endpos__5_ - _startpos__1_ _startpos__1_inlined1_ body catch = - let catch_keyword = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (false, i _sloc) - in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = None; - else_loc_ = Rloc.no_location; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_941 _endpos__1_ _endpos__3_ _endpos__5_ _startpos__1_ - _startpos__1_inlined1_ body catch = - let catch_keyword = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (true, i _sloc) - in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = None; - else_loc_ = Rloc.no_location; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_942 _endpos__1_ _endpos__2_ _endpos__2_inlined1_ _endpos__8_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ body catch - try_else = - let else_loc_ = - let _endpos__2_, _startpos__1_ = - (_endpos__2_inlined1_, _startpos__1_inlined2_) - in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - i _sloc - in - let catch_keyword = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (false, i _sloc) - in - let _endpos = _endpos__8_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = Some try_else; - else_loc_; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_943 _endpos__1_ _endpos__1_inlined1_ _endpos__2_ _endpos__8_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ body catch - try_else = - let else_loc_ = - let _startpos__1_ = _startpos__1_inlined2_ in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - i _sloc - in - let catch_keyword = - let _endpos__1_, _startpos__1_ = - (_endpos__1_inlined1_, _startpos__1_inlined1_) - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (false, i _sloc) - in - let _endpos = _endpos__8_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = Some try_else; - else_loc_; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_944 _endpos__1_ _endpos__2_inlined1_ _endpos__3_ _endpos__8_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ body catch - try_else = - let else_loc_ = - let _endpos__2_, _startpos__1_ = - (_endpos__2_inlined1_, _startpos__1_inlined2_) - in - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - i _sloc - in - let catch_keyword = - let _startpos__1_ = _startpos__1_inlined1_ in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (true, i _sloc) - in - let _endpos = _endpos__8_ in - let _symbolstartpos = _startpos__1_ in - let _loc__1_ = (_startpos__1_, _endpos__1_) in - let _sloc = (_symbolstartpos, _endpos) in - (let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try - { - loc_ = i _sloc; - body; - catch; - catch_all; - try_else = Some try_else; - else_loc_; - try_loc_ = i _loc__1_; - catch_loc_; - } - : Parsing_syntax.expr) - -let _menhir_action_945 _endpos__2_ _startpos__2_ _startpos_ty_ ty = - let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos_ty_ in - let _loc__2_ = (_startpos__2_, _endpos__2_) in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ptype_option ~loc_:(i _sloc) ~constr_loc:(i _loc__2_) ty - : Parsing_syntax.typ) - -let _menhir_action_946 _endpos__5_ _startpos__1_ t ts = - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (make_Ptype_tuple ~loc_:(i _sloc) (t :: ts) : Parsing_syntax.typ) - -let _menhir_action_947 _endpos_rty_ _startpos__1_ rty t ts = - let _endpos = _endpos_rty_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let ty_res, ty_err = rty in - Ptype_arrow { loc_ = i _sloc; ty_arg = t :: ts; ty_res; ty_err } - : Parsing_syntax.typ) - -let _menhir_action_948 _endpos_rty_ _startpos__1_ rty = - let _endpos = _endpos_rty_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (let ty_res, ty_err = rty in - Ptype_arrow { loc_ = i _sloc; ty_arg = []; ty_res; ty_err } - : Parsing_syntax.typ) - -let _menhir_action_949 _endpos_rty_ _startpos__1_ rty t = - let _endpos = _endpos_rty_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (match rty with - | None -> t - | Some rty -> - let ty_res, ty_err = rty in - Ptype_arrow { loc_ = i _sloc; ty_arg = [ t ]; ty_res; ty_err } - : Parsing_syntax.typ) - -let _menhir_action_950 _endpos_id_ _endpos_params_ _startpos_id_ id params = - let _endpos = _endpos_params_ in - let _symbolstartpos = _startpos_id_ in - let _loc_id_ = (_startpos_id_, _endpos_id_) in - let _sloc = (_symbolstartpos, _endpos) in - (Ptype_name - { - loc_ = i _sloc; - constr_id = { lid = id; loc_ = i _loc_id_ }; - tys = params; - } - : Parsing_syntax.typ) - -let _menhir_action_951 _endpos__1_ _startpos__1_ = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Ptype_any { loc_ = i _sloc } : Parsing_syntax.typ) - -let _menhir_action_952 _endpos_tycon_ _startpos_tycon_ params tycon = - let vis = Parsing_syntax.Vis_default in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_953 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ - params tycon = - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_954 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon = - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_955 _endpos_tycon_ _startpos_tycon_ params tycon = - let vis = Parsing_syntax.Vis_default in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_956 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ - params tycon = - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_957 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon = - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_, params) - : Parsing_syntax.visibility - * string - * Rloc.t - * Parsing_syntax.type_decl_binder list) - -let _menhir_action_958 _endpos_tycon_ _startpos_tycon_ tycon = - let vis = Parsing_syntax.Vis_default in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_) : Parsing_syntax.visibility * string * Rloc.t) - -let _menhir_action_959 _endpos__1_ _endpos_tycon_ _startpos__1_ _startpos_tycon_ - tycon = - let vis = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_priv { loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_) : Parsing_syntax.visibility * string * Rloc.t) - -let _menhir_action_960 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr tycon = - let vis = - let _endpos = _endpos_attr_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_syntax.Vis_pub { attr; loc_ = i _sloc } - in - let _loc_tycon_ = (_startpos_tycon_, _endpos_tycon_) in - ((vis, tycon, i _loc_tycon_) : Parsing_syntax.visibility * string * Rloc.t) - -let _menhir_action_961 x = - let _1 = x in - (_1 : Parsing_syntax.tvar_binder list) - -let _menhir_action_962 _endpos_name_ _startpos_name_ name = - let t = - let _1 = None in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let pub = None in - ((false, pub <> None, binder, t) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_963 _endpos_name_ _startpos_name_ name t = - let t = - let _1 = - let x = t in - Some x - in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let pub = None in - ((false, pub <> None, binder, t) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_964 _endpos_name_ _startpos_name_ name x = - let t = - let _1 = None in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let pub = Some x in - ((false, pub <> None, binder, t) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_965 _endpos_name_ _startpos_name_ name t x = - let t = - let _1 = - let x = t in - Some x - in - _1 - in - let binder = - let _endpos = _endpos_name_ in - let _startpos = _startpos_name_ in - let _loc = (_startpos, _endpos) in - { Parsing_syntax.binder_name = name; loc_ = i _loc } - in - let pub = Some x in - ((false, pub <> None, binder, t) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_966 _endpos_binder_name_ _startpos_binder_name_ binder_name = - let t = - let _1 = None in - _1 - in - let pub = None in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (( true, - pub <> None, - { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, - t ) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_967 _endpos_binder_name_ _startpos_binder_name_ binder_name t - = - let t = - let _1 = - let x = t in - Some x - in - _1 - in - let pub = None in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (( true, - pub <> None, - { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, - t ) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_968 _endpos_binder_name_ _startpos_binder_name_ binder_name x - = - let t = - let _1 = None in - _1 - in - let pub = Some x in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (( true, - pub <> None, - { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, - t ) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_969 _endpos_binder_name_ _startpos_binder_name_ binder_name t - x = - let t = - let _1 = - let x = t in - Some x - in - _1 - in - let pub = Some x in - let _loc_binder_name_ = (_startpos_binder_name_, _endpos_binder_name_) in - (( true, - pub <> None, - { Parsing_syntax.binder_name; loc_ = i _loc_binder_name_ }, - t ) - : bool * bool * Parsing_syntax.binder * Parsing_syntax.typ option) - -let _menhir_action_970 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = [] in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_while_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_while - { loc_ = i _sloc; loop_cond = cond; loop_body = body; while_else } - : Parsing_syntax.expr) - -let _menhir_action_971 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = None in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_while_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_while - { loc_ = i _sloc; loop_cond = cond; loop_body = body; while_else } - : Parsing_syntax.expr) - -let _menhir_action_972 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else x xs = - let body = - let _startpos__1_ = _startpos__1_inlined1_ in - let ls = - let _1 = - let _2 = Some x in - xs - in - _1 - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - Parsing_compact.compact_rev ls (i _sloc) - in - let _endpos = _endpos_while_else_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - (Parsing_syntax.Pexpr_while - { loc_ = i _sloc; loop_cond = cond; loop_body = body; while_else } - : Parsing_syntax.expr) - -let _menhir_print_token : token -> string = - fun _tok -> - match _tok with - | Lex_menhir_token.AMPER -> "AMPER" - | Lex_menhir_token.AMPERAMPER -> "AMPERAMPER" - | Lex_menhir_token.AS -> "AS" - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ -> "AUGMENTED_ASSIGNMENT" - | Lex_menhir_token.BAR -> "BAR" - | Lex_menhir_token.BARBAR -> "BARBAR" - | Lex_menhir_token.BREAK -> "BREAK" - | Lex_menhir_token.BYTE _ -> "BYTE" - | Lex_menhir_token.BYTES _ -> "BYTES" - | Lex_menhir_token.CARET -> "CARET" - | Lex_menhir_token.CATCH -> "CATCH" - | Lex_menhir_token.CHAR _ -> "CHAR" - | Lex_menhir_token.COLON -> "COLON" - | Lex_menhir_token.COLONCOLON -> "COLONCOLON" - | Lex_menhir_token.COMMA -> "COMMA" - | Lex_menhir_token.COMMENT _ -> "COMMENT" - | Lex_menhir_token.CONST -> "CONST" - | Lex_menhir_token.CONTINUE -> "CONTINUE" - | Lex_menhir_token.DERIVE -> "DERIVE" - | Lex_menhir_token.DOTDOT -> "DOTDOT" - | Lex_menhir_token.DOT_INT _ -> "DOT_INT" - | Lex_menhir_token.DOT_LIDENT _ -> "DOT_LIDENT" - | Lex_menhir_token.DOT_UIDENT _ -> "DOT_UIDENT" - | Lex_menhir_token.ELLIPSIS -> "ELLIPSIS" - | Lex_menhir_token.ELSE -> "ELSE" - | Lex_menhir_token.ENUM -> "ENUM" - | Lex_menhir_token.EOF -> "EOF" - | Lex_menhir_token.EQUAL -> "EQUAL" - | Lex_menhir_token.EXCLAMATION -> "EXCLAMATION" - | Lex_menhir_token.EXTERN -> "EXTERN" - | Lex_menhir_token.FALSE -> "FALSE" - | Lex_menhir_token.FAT_ARROW -> "FAT_ARROW" - | Lex_menhir_token.FLOAT _ -> "FLOAT" - | Lex_menhir_token.FN -> "FN" - | Lex_menhir_token.FOR -> "FOR" - | Lex_menhir_token.GUARD -> "GUARD" - | Lex_menhir_token.IF -> "IF" - | Lex_menhir_token.IMPL -> "IMPL" - | Lex_menhir_token.IMPORT -> "IMPORT" - | Lex_menhir_token.IN -> "IN" - | Lex_menhir_token.INFIX1 _ -> "INFIX1" - | Lex_menhir_token.INFIX2 _ -> "INFIX2" - | Lex_menhir_token.INFIX3 _ -> "INFIX3" - | Lex_menhir_token.INFIX4 _ -> "INFIX4" - | Lex_menhir_token.INT _ -> "INT" - | Lex_menhir_token.INTERP _ -> "INTERP" - | Lex_menhir_token.LABEL _ -> "LABEL" - | Lex_menhir_token.LBRACE -> "LBRACE" - | Lex_menhir_token.LBRACKET -> "LBRACKET" - | Lex_menhir_token.LET -> "LET" - | Lex_menhir_token.LIDENT _ -> "LIDENT" - | Lex_menhir_token.LOOP -> "LOOP" - | Lex_menhir_token.LPAREN -> "LPAREN" - | Lex_menhir_token.MATCH -> "MATCH" - | Lex_menhir_token.MINUS -> "MINUS" - | Lex_menhir_token.MULTILINE_INTERP _ -> "MULTILINE_INTERP" - | Lex_menhir_token.MULTILINE_STRING _ -> "MULTILINE_STRING" - | Lex_menhir_token.MUTABLE -> "MUTABLE" - | Lex_menhir_token.NEWLINE -> "NEWLINE" - | Lex_menhir_token.PACKAGE_NAME _ -> "PACKAGE_NAME" - | Lex_menhir_token.PIPE -> "PIPE" - | Lex_menhir_token.PLUS -> "PLUS" - | Lex_menhir_token.POST_LABEL _ -> "POST_LABEL" - | Lex_menhir_token.PRIV -> "PRIV" - | Lex_menhir_token.PUB -> "PUB" - | Lex_menhir_token.QUESTION -> "QUESTION" - | Lex_menhir_token.RAISE -> "RAISE" - | Lex_menhir_token.RANGE_EXCLUSIVE -> "RANGE_EXCLUSIVE" - | Lex_menhir_token.RANGE_INCLUSIVE -> "RANGE_INCLUSIVE" - | Lex_menhir_token.RBRACE -> "RBRACE" - | Lex_menhir_token.RBRACKET -> "RBRACKET" - | Lex_menhir_token.READONLY -> "READONLY" - | Lex_menhir_token.RETURN -> "RETURN" - | Lex_menhir_token.RPAREN -> "RPAREN" - | Lex_menhir_token.SEMI _ -> "SEMI" - | Lex_menhir_token.STRING _ -> "STRING" - | Lex_menhir_token.STRUCT -> "STRUCT" - | Lex_menhir_token.TEST -> "TEST" - | Lex_menhir_token.THIN_ARROW -> "THIN_ARROW" - | Lex_menhir_token.THROW -> "THROW" - | Lex_menhir_token.TRAIT -> "TRAIT" - | Lex_menhir_token.TRUE -> "TRUE" - | Lex_menhir_token.TRY -> "TRY" - | Lex_menhir_token.TYPE -> "TYPE" - | Lex_menhir_token.TYPEALIAS -> "TYPEALIAS" - | Lex_menhir_token.UIDENT _ -> "UIDENT" - | Lex_menhir_token.UNDERSCORE -> "UNDERSCORE" - | Lex_menhir_token.WHILE -> "WHILE" - | Lex_menhir_token.WITH -> "WITH" - -let _menhir_fail : unit -> 'a = - fun () -> - Printf.eprintf - "Internal failure -- please contact the parser generator's developers.\n%!"; - assert false - -include struct - [@@@ocaml.warning "-4-37-39"] - - let rec _menhir_run_1252 : - type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_expression = - fun _menhir_stack _v _tok -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EOF -> - let _1 = _v in - let _v = _menhir_action_047 _1 in - MenhirBox_expression _v - | _ -> _eRR () - - let rec _menhir_goto_structure : - type ttv_stack. ttv_stack -> _ -> _menhir_box_structure = - fun _menhir_stack _v -> MenhirBox_structure _v - - let rec _menhir_goto_non_empty_list_semis_structure_item_ : - type ttv_stack. ttv_stack -> _ -> _menhir_box_structure = - fun _menhir_stack _v -> - let _1 = _v in - let _v = _menhir_action_705 _1 in - _menhir_goto_structure _menhir_stack _v - - let rec _menhir_run_0001 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_WHILE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0001 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0002 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_604 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_simple_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1173 -> - _menhir_run_1183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_1144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_1104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_1069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0769 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0705 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0670 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0544 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0506 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1183 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1184 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1192 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1194 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1197 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1199 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0085 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _endpos__5_ = _endpos_2 in - let _v = _menhir_action_615 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0086 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0086 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0003 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_119 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_606 _endpos_name_ _startpos_name_ name in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_name_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_luident : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1996 -> - _menhir_run_1997 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1733 -> - _menhir_run_1734 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1730 -> - _menhir_run_1731 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1723 -> - _menhir_run_1724 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1718 -> - _menhir_run_1721 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1719 -> - _menhir_run_1720 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _tok _menhir_initp - | MenhirState1715 -> - _menhir_run_1716 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1711 -> - _menhir_run_1712 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1708 -> - _menhir_run_1709 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1701 -> - _menhir_run_1702 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1696 -> - _menhir_run_1699 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1697 -> - _menhir_run_1698 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _tok _menhir_initp - | MenhirState1693 -> - _menhir_run_1694 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1417 -> - _menhir_run_1418 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1376 -> - _menhir_run_1377 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1344 -> - _menhir_run_1345 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1288 -> - _menhir_run_1296 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1290 -> - _menhir_run_1291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1273 -> - _menhir_run_1274 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1268 -> - _menhir_run_1271 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1269 -> - _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _tok _menhir_initp - | MenhirState1257 -> - _menhir_run_1265 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1260 -> - _menhir_run_1262 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _tok _menhir_initp - | MenhirState1255 -> - _menhir_run_1256 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2035 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2030 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2006 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2010 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2018 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2001 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1986 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1975 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1741 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1858 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1949 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1921 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1892 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1864 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1832 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1804 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1775 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1747 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1738 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1690 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1682 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1677 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1669 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1660 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1426 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1543 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1634 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1606 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1577 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1549 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1517 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1489 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1460 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1432 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1423 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1381 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1386 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1383 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1368 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1363 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1358 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1323 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1302 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1316 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1311 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1308 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1304 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1297 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1292 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1275 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1278 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1281 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1237 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1224 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1228 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1216 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1220 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1208 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1212 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1131 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1171 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0640 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0636 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0628 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0626 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0620 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0576 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0482 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0487 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0532 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0248 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0477 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0470 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0454 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0261 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0450 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0263 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0441 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0432 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0415 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0413 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0409 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0407 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0403 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0401 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0397 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0395 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0391 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0389 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0385 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0383 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0379 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0377 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0373 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0371 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0366 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0364 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0360 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0358 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0347 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0345 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0341 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0339 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0335 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0333 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0329 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0327 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0323 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0321 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0317 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0315 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0311 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0308 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0306 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0302 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0300 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0294 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0292 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0288 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0267 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0282 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0279 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0273 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0101 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0033 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0039 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0064 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0067 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0061 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0041 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0045 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0048 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0051 -> - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1997 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1997 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1997 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1257 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _menhir_s, _endpos__1_, _startpos__1_ = - (MenhirState1257, _endpos_1, _startpos_0) - in - let _v = _menhir_action_183 _endpos__1_ _startpos__1_ in - _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState1257 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState1257 _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, xs = (_endpos_0, _startpos, _v) in - let _v = _menhir_action_185 _endpos__1_ _startpos__1_ xs in - _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1260 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1260 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let x, xs = ((), _v) in - let _v = _menhir_action_142 x xs in - _menhir_goto_non_empty_list_commas_id_type_decl_binder__ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let xs = _v in - let _v = _menhir_action_141 xs in - _menhir_goto_non_empty_list_commas_id_type_decl_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_run_0035 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_119 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ - _startpos_i_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0042 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ - _startpos_i_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_id_type_decl_binder__ : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _, _)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_488 x in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - - and _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let params = _v in - let _v = _menhir_action_510 params in - _menhir_goto_optional_type_parameters_no_constraints _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - - and _menhir_goto_optional_type_parameters_no_constraints : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1997 -> - _menhir_run_1998 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1734 -> - _menhir_run_1735 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1731 -> - _menhir_run_1732 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1721 -> - _menhir_run_1722 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1716 -> - _menhir_run_1717 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1712 -> - _menhir_run_1713 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1709 -> - _menhir_run_1710 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1699 -> - _menhir_run_1700 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1694 -> - _menhir_run_1695 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1418 -> - _menhir_run_1419 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1271 -> - _menhir_run_1272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1256 -> - _menhir_run_1266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1998 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let params = _v in - let _v = _menhir_action_036 _endpos_tycon_ _startpos_tycon_ params tycon in - _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_enum_header : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_enum_header (_menhir_stack, _menhir_s, _v, _startpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_1 -> - _menhir_run_1379 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2077 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState2077, _endpos_2) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2078 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_3 = _menhir_action_032 () in - _menhir_run_2079 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_2 _v_3 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1379 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_UIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MUTABLE -> - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1380 _menhir_initp - | Lex_menhir_token.LABEL _ | Lex_menhir_token.LIDENT _ - | Lex_menhir_token.LPAREN | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.POST_LABEL _ | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE -> - let _v_2 = _menhir_action_465 () in - _menhir_run_1381 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _endpos_1 _v_2 MenhirState1380 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v = _menhir_action_481 () in - _menhir_goto_option___anonymous_20_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1355 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_x_, _startpos_x_, x = (_endpos, _startpos, ()) in - let _v = _menhir_action_466 x in - _menhir_goto_option_MUTABLE_ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_x_ _startpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option_MUTABLE_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1390 -> - _menhir_run_1381 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1380 -> - _menhir_run_1381 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2041 -> - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1373 -> - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1346 -> - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1360 -> - _menhir_run_1361 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1354 -> - _menhir_run_1356 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1381 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_MUTABLE_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1381 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1381 _menhir_initp - | Lex_menhir_token.POST_LABEL _v_1 -> ( - let _v, _menhir_s = (_v_1, MenhirState1381) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_POST_LABEL - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1383 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.PACKAGE_NAME _v_8 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1381 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1381 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1381 _menhir_initp - | Lex_menhir_token.LABEL _v_10 -> ( - let _v, _menhir_s = (_v_10, MenhirState1381) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LABEL (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1386 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0034 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_951 _endpos__1_ _startpos__1_ in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_type_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState2035 -> - _menhir_run_2036 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2030 -> - _menhir_run_2031 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2006 -> - _menhir_run_2027 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2001 -> - _menhir_run_2002 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1858 -> - _menhir_run_1859 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1738 -> - _menhir_run_1739 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1690 -> - _menhir_run_1691 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1543 -> - _menhir_run_1544 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1423 -> - _menhir_run_1424 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1381 -> - _menhir_run_1388 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1386 -> - _menhir_run_1387 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1383 -> - _menhir_run_1384 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1368 -> - _menhir_run_1369 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1363 -> - _menhir_run_1364 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1358 -> - _menhir_run_1359 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1323 -> - _menhir_run_1313 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1316 -> - _menhir_run_1313 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1302 -> - _menhir_run_1313 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1311 -> - _menhir_run_1312 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1308 -> - _menhir_run_1309 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1237 -> - _menhir_run_1238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0640 -> - _menhir_run_0641 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0636 -> - _menhir_run_0637 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0628 -> - _menhir_run_0629 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0626 -> - _menhir_run_0627 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0620 -> - _menhir_run_0621 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0477 -> - _menhir_run_0478 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0470 -> - _menhir_run_0471 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0450 -> - _menhir_run_0451 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0039 -> - _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0051 -> - _menhir_run_0052 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0064 -> - _menhir_run_0049 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0048 -> - _menhir_run_0049 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0045 -> - _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1949 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1921 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1892 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1864 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1832 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1804 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1775 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1747 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1682 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1669 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1634 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1606 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1577 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1549 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1517 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1489 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1460 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1432 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1304 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0576 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0033 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0067 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0061 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0041 -> - _menhir_run_0043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2036 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_alias_header - _menhir_cell0_EQUAL - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2036 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2037 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0044 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_type_ -> _ -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_type_ (_menhir_stack, _menhir_s, ty, _startpos_ty_, _)) = - _menhir_stack - in - let _endpos__2_, _startpos__2_ = (_endpos, _startpos) in - let _v = _menhir_action_945 _endpos__2_ _startpos__2_ _startpos_ty_ ty in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ - _startpos_ty_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_2009 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = MenhirCell1_DERIVE (_menhir_stack, _menhir_s) in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState2010 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__4_ = _endpos_0 in - let _v = _menhir_action_033 () in - _menhir_goto_deriving_directive_list _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__4_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = MenhirCell1_DERIVE (_menhir_stack, _menhir_s) in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState2010 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = MenhirCell1_DERIVE (_menhir_stack, _menhir_s) in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState2010 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_deriving_directive_list : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2081 -> - _menhir_run_2082 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2078 -> - _menhir_run_2079 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2045 -> - _menhir_run_2046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2042 -> - _menhir_run_2043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2036 -> - _menhir_run_2037 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2030 -> - _menhir_run_2033 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2031 -> - _menhir_run_2032 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2028 -> - _menhir_run_2029 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2025 -> - _menhir_run_2026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2008 -> - _menhir_run_2023 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2082 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_enum_constructor_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semis_enum_constructor_ - (_menhir_stack, _, _1)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_enum_header - (_menhir_stack, _menhir_s, enum_header, _startpos_enum_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_715 _1 _endpos_deriving__ _startpos_enum_header_ deriving_ - enum_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_goto_structure_item : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2050 -> - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2051 : - type ttv_stack. - ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_structure_item_ - _menhir_cell0_SEMI -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_439 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TYPEALIAS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1255 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.TYPE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1268 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.TRAIT -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1273 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.TEST -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1335 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1417 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.PUB -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1420 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.PRIV -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1714 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1736 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.IMPL -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1740 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1975 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.EXTERN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1984 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1996 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.CONST -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_structure_item_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1999 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2050 _menhir_initp - | Lex_menhir_token.EOF -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_459 x xs in - _menhir_goto_non_empty_list_semis_structure_item_ _menhir_stack _v - | _ -> _eRR ()) - | Lex_menhir_token.EOF -> - let xs = _v in - let _v = _menhir_action_458 xs in - _menhir_goto_non_empty_list_semis_structure_item_ _menhir_stack _v - | _ -> _eRR () - - and _menhir_run_1255 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_TYPEALIAS (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1255 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1268 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1268 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1269 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1273 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_TRAIT (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1273 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1335 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v -> - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos_0, _v) in - let _v = _menhir_action_496 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_option_loced_string_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _tok _menhir_initp - | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> - let _v = _menhir_action_495 () in - _menhir_goto_option_loced_string_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option_loced_string_ : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let _menhir_stack = MenhirCell0_option_loced_string_ (_menhir_stack, _v) in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1337 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1342 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1337 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1338 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__3_ = (_startpos, _endpos_0) in - let _v = _menhir_action_498 () in - _menhir_goto_option_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState1338 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState1338 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState1338 _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option_parameters_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1992 -> - _menhir_run_1993 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1989 -> - _menhir_run_1990 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1981 -> - _menhir_run_1982 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1978 -> - _menhir_run_1979 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1685 -> - _menhir_run_1686 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1680 -> - _menhir_run_1681 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1672 -> - _menhir_run_1673 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1667 -> - _menhir_run_1668 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1337 -> - _menhir_run_1342 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1993 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1682 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1993 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _v_0 = _menhir_action_469 () in - _menhir_run_1994 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1682 : - type ttv_stack. - (( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - as - 'stack) -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _menhir_stack = MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s) in - let _menhir_s = MenhirState1682 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0036 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DOT_UIDENT _v_0 -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_0, _startpos, _v) - in - let _v = _menhir_action_545 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_id_ _startpos_ps_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_qual_ident_ty : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState2018 -> - _menhir_run_2012 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2010 -> - _menhir_run_2012 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1741 -> - _menhir_run_1742 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1986 -> - _menhir_run_1662 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1975 -> - _menhir_run_1662 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1677 -> - _menhir_run_1662 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1660 -> - _menhir_run_1662 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1426 -> - _menhir_run_1427 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1297 -> - _menhir_run_1280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1292 -> - _menhir_run_1280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1275 -> - _menhir_run_1280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1281 -> - _menhir_run_1280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1278 -> - _menhir_run_1280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1224 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1228 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1216 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1220 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1208 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1212 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1171 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1131 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0532 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0487 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0482 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0248 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0454 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0261 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0441 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0263 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0432 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0415 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0413 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0409 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0407 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0403 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0401 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0397 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0395 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0391 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0389 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0385 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0383 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0379 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0377 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0373 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0371 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0366 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0364 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0360 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0358 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0347 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0345 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0341 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0339 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0335 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0333 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0329 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0327 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0323 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0321 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0317 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0315 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0311 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0308 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0306 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0302 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0300 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0294 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0292 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0288 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0267 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0282 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0279 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0273 -> - _menhir_run_0275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0101 -> - _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2035 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2030 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2006 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2001 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1858 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1949 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1921 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1892 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1864 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1832 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1804 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1775 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1747 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1738 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1690 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1682 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1669 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1543 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1634 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1606 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1577 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1549 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1517 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1489 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1460 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1432 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1423 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1381 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1386 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1383 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1368 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1363 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1358 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1323 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1316 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1302 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1311 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1308 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1304 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1237 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0640 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0636 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0628 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0626 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0620 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0576 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0477 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0470 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0450 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0033 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0039 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0067 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0064 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0061 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0041 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0051 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0048 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0045 -> - _menhir_run_0047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2012 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2013 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState2013 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_name_, _startpos_name_, name, _endpos__4_ = - (_endpos, _startpos, _v, _endpos_4) - in - let _v = - _menhir_action_030 _endpos__4_ _endpos_name_ _startpos_name_ name - in - _menhir_goto_deriving_directive _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v_5 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState2013 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState2013 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState2013 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState2013 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState2013 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.LABEL _v_10 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState2013 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState2013 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState2013 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState2013 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2013 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState2013 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState2013 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState2013 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_029 _endpos_name_ _startpos_name_ name in - _menhir_goto_deriving_directive _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0014 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_TRY (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0014 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0004 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_594 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0005 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_601 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0006 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_PLUS (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0006 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0007 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DOT_UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_1 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.CATCH - | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_1, _startpos, _v) - in - let _v = _menhir_action_542 id ps in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_1, _startpos, _v) - in - let _v = _menhir_action_544 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0008 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_PACKAGE_NAME -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> - let (MenhirCell1_PACKAGE_NAME - (_menhir_stack, _menhir_s, ps, _startpos_ps_)) = - _menhir_stack - in - let _endpos_id_, id = (_endpos, _v) in - let _v = _menhir_action_545 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_id_ _startpos_ps_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell1_PACKAGE_NAME - (_menhir_stack, _menhir_s, pkg, _startpos_pkg_)) = - _menhir_stack - in - let _endpos_constr_name_, _startpos_constr_name_, constr_name = - (_endpos, _startpos, _v) - in - let _v = - _menhir_action_607 _endpos_constr_name_ _startpos_constr_name_ - _startpos_pkg_ constr_name pkg - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_constr_name_ _startpos_pkg_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_qual_ident_simple_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos_var_name_, _startpos_var_name_, var_name = - (_endpos, _startpos, _v) - in - let _v = - _menhir_action_605 _endpos_var_name_ _startpos_var_name_ var_name - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_var_name_ _startpos_var_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0010 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_266 _1 in - _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - - and _menhir_goto_non_empty_list_rev_multiline_string_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MULTILINE_STRING _v_0 -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _1, _startpos_xs_, xs = - (_endpos_2, _v_0, _startpos, _v) - in - let _v = _menhir_action_268 _1 xs in - _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_xs_ _v _menhir_s - _tok _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_3 -> - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _1, _startpos_xs_, xs = - (_endpos_5, _v_3, _startpos, _v) - in - let _v = _menhir_action_269 _1 xs in - _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_xs_ _v _menhir_s - _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos_xs_, _startpos_xs_, xs = (_endpos, _startpos, _v) in - let _v = _menhir_action_126 xs in - let _endpos, _startpos = (_endpos_xs_, _startpos_xs_) in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_602 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0011 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_267 _1 in - _menhir_goto_non_empty_list_rev_multiline_string_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0012 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0012 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0013 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__3_ = (_startpos, _endpos_0) in - let _v = _menhir_action_637 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0013 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0013 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0015 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_MATCH (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0015 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0016 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_541 i in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0017 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT -> _ -> _ -> _ -> ttv_result - = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_0018 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0018 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, func, _startpos_func_, _endpos_func_)) - = - _menhir_stack - in - let _endpos__5_ = _endpos_0 in - let _v = - _menhir_action_609 _endpos__5_ _endpos_func_ _startpos_func_ func - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0018 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0018 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0020 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_label_, _startpos_label_, label = (_endpos, _startpos, _v) in - let _v = _menhir_action_007 _endpos_label_ _startpos_label_ label in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_goto_argument : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2013 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0168 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0171 : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_166 x in - _menhir_goto_non_empty_list_commas_rev_argument_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_argument_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0164 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0164 _menhir_initp - | Lex_menhir_token.POST_LABEL _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0164 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0164 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0164 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0164 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0164 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.LABEL _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0164 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0164 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0164 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0164 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0164 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0164 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0164 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0164 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_128 x xs in - _menhir_goto_non_empty_list_commas_argument_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_127 xs in - _menhir_goto_non_empty_list_commas_argument_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_0021 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LOOP (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0021 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0022 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__3_ = (_startpos, _endpos_0) in - let _v = _menhir_action_640 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0022 _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0022 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1041 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0022 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0024 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0024 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.TRUE -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_TRUE - (_menhir_stack, MenhirState0024, _startpos_0, _endpos_1) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0026 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_ = (_endpos_1, _startpos_0) in - _menhir_action_594 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _startpos_0 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.STRING _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_STRING - (_menhir_stack, MenhirState0024, _v, _startpos_3, _endpos_4) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0956 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_4, _startpos_3, _v) - in - _menhir_action_601 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _startpos_3 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_18 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__3_ = (_startpos, _endpos_18) in - let _v = _menhir_action_576 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0024 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0024 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0024 _menhir_initp - | Lex_menhir_token.MINUS -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_19 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_20 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_MINUS - (_menhir_stack, MenhirState0024, _startpos_19, _endpos_20) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.INT _v -> ( - let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_INT - ( _menhir_stack, - MenhirState0959, - _v, - _startpos_21, - _endpos_22 ) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0961 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR - | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION - | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_22, _startpos_21, _v) - in - _menhir_action_599 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_22 _startpos_21 _v MenhirState0959 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.FLOAT _v -> ( - let _startpos_36 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_37 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_FLOAT - ( _menhir_stack, - MenhirState0959, - _v, - _startpos_36, - _endpos_37 ) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0964 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR - | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.QUESTION - | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_37, _startpos_36, _v) - in - _menhir_action_600 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_37 _startpos_36 _v MenhirState0959 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0959 _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0959 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.LIDENT _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_51 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_52 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, MenhirState0024, _v, _startpos_51, _endpos_52) - in - _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA -> ( - let _endpos_53 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_54 -> - let _menhir_stack = - MenhirCell1_LIDENT - ( _menhir_stack, - MenhirState0024, - _v, - _startpos_51, - _endpos_52 ) - in - let _menhir_stack = - MenhirCell0_COMMA (_menhir_stack, _endpos_53) - in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState0968 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_name_, _startpos_name_, name = - (_endpos_52, _startpos_51, _v) - in - let _v = - _menhir_action_552 _endpos_name_ _startpos_name_ name - in - _menhir_goto_record_defn _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, MenhirState0024, _v, _startpos_51, _endpos_52) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0970 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLONCOLON -> - let _v = - let i = _v in - _menhir_action_118 i - in - _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_52 _startpos_51 _v MenhirState0024 _tok _menhir_initp - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL -> - let _v = - let i = _v in - _menhir_action_539 i - in - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_52 _startpos_51 _v MenhirState0024 _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _menhir_s, _endpos_i_, _startpos_i_, i = - (MenhirState0024, _endpos_52, _startpos_51, _v) - in - let _v = _menhir_action_541 i in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0024 _menhir_initp - | Lex_menhir_token.INT _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_68 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_69 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_INT - (_menhir_stack, MenhirState0024, _v, _startpos_68, _endpos_69) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0976 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_69, _startpos_68, _v) - in - _menhir_action_599 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_69 _startpos_68 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.FLOAT _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_83 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_84 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_FLOAT - (_menhir_stack, MenhirState0024, _v, _startpos_83, _endpos_84) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0979 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_84, _startpos_83, _v) - in - _menhir_action_600 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_84 _startpos_83 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.FALSE -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_98 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_99 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_FALSE - (_menhir_stack, MenhirState0024, _startpos_98, _endpos_99) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0982 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_ = (_endpos_99, _startpos_98) in - _menhir_action_595 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_99 _startpos_98 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0024 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0984 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | Lex_menhir_token.CHAR _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_103 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_104 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_CHAR - (_menhir_stack, MenhirState0024, _v, _startpos_103, _endpos_104) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0992 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_104, _startpos_103, _v) - in - _menhir_action_598 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_104 _startpos_103 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.BYTES _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_118 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_119 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_BYTES - (_menhir_stack, MenhirState0024, _v, _startpos_118, _endpos_119) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0995 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_119, _startpos_118, _v) - in - _menhir_action_597 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_119 _startpos_118 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.BYTE _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _startpos_133 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_134 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_BYTE - (_menhir_stack, MenhirState0024, _v, _startpos_133, _endpos_134) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0998 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _v = - let _endpos__1_, _startpos__1_, _1 = - (_endpos_134, _startpos_133, _v) - in - _menhir_action_596 _1 _endpos__1_ _startpos__1_ - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_134 _startpos_133 _v MenhirState0024 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0024 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0027 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_603 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0028 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_599 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0029 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0029 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0030 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - _menhir_run_0828 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0031 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN -> _ -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, MenhirState0031, _endpos_0) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0032 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v = _menhir_action_471 () in - _menhir_run_0070 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0032 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v -> - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0031 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0031 _menhir_initp - | Lex_menhir_token.LABEL _v -> - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0031 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0033 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _menhir_stack = MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s) in - let _menhir_s = MenhirState0033 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0039 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0039 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.RPAREN -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_s = MenhirState0041 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0070 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0071 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0071 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, ty_opt, _startpos__1_inlined2_ = - (_endpos_2, _v, _startpos) - in - let _v = - _menhir_action_584 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0071 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0071 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0071 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0071 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0071 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0071 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0071 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0071 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0071 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0071 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0071 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0072 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0072 _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0072 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v = _menhir_action_491 () in - _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0073 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0074 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0073 _menhir_initp - | Lex_menhir_token.LIDENT _v -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, MenhirState0073, _v, _startpos_0, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0076 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.IN -> - let _v = - let _endpos_name_, _startpos_name_, name = - (_endpos, _startpos_0, _v) - in - _menhir_action_066 _endpos_name_ _startpos_name_ name - in - _menhir_run_0866 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0073 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE | Lex_menhir_token.SEMI _ -> - let _menhir_s = MenhirState0073 in - let _v = _menhir_action_055 () in - _menhir_goto_for_binders _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0074 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - let _v = _menhir_action_067 () in - _menhir_goto_foreach_binder _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_goto_foreach_binder : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0073 -> - _menhir_run_0866 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0226 -> - _menhir_run_0228 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0866 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FOR as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_176 x in - _menhir_goto_non_empty_list_commas_rev_foreach_binder_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_foreach_binder_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FOR as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_foreach_binder_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0074 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0226 _menhir_initp - | Lex_menhir_token.LIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_foreach_binder_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _v_2 = - let _endpos_name_, _startpos_name_, name = - (_endpos_1, _startpos, _v_0) - in - _menhir_action_066 _endpos_name_ _startpos_name_ name - in - _menhir_run_0228 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _tok _menhir_initp - | Lex_menhir_token.IN -> - let x, xs = ((), _v) in - let _v = _menhir_action_138 x xs in - _menhir_goto_non_empty_list_commas_foreach_binder_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.IN -> - let xs = _v in - let _v = _menhir_action_137 xs in - _menhir_goto_non_empty_list_commas_foreach_binder_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_0228 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_foreach_binder_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_foreach_binder_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_177 x xs in - _menhir_goto_non_empty_list_commas_rev_foreach_binder_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_foreach_binder_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FOR as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_foreach_binder_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_IN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0236 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0077 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_600 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0078 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_595 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0079 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_598 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0080 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_597 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0081 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_596 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_for_binders : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FOR as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_for_binders (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _v = _v_0 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v, _endpos) in - let _menhir_s = MenhirState0868 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.SEMI _ -> - let _v = _menhir_action_493 () in - _menhir_goto_option_infix_expr_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.UIDENT _v_14 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0899 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.STRING _v_15 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0899 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0899, _endpos_16) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0900 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_18 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_18 - MenhirState0899 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_19 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_19 - MenhirState0899 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_20 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_20 - MenhirState0899 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.LIDENT _v_21 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_21 - MenhirState0899 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.INTERP _v_22 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_22 - MenhirState0899 _menhir_initp - | Lex_menhir_token.INT _v_23 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_23 - MenhirState0899 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.FLOAT _v_24 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_24 - MenhirState0899 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | Lex_menhir_token.CHAR _v_25 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_25 - MenhirState0899 _menhir_initp - | Lex_menhir_token.BYTES _v_26 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_26 - MenhirState0899 _menhir_initp - | Lex_menhir_token.BYTE _v_27 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_27 - MenhirState0899 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0899 _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_goto_option_infix_expr_ : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_infix_expr_ (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_1 -> ( - let _v = _v_1 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_EQUAL (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0872 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_16) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.UIDENT _v_17 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_17 MenhirState0874 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.STRING _v_18 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_18 MenhirState0874 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0874, _endpos_19) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0875 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_20 = _menhir_action_507 () in - _menhir_run_0876 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_19 _v_20 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_21 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_21 MenhirState0874 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_22 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_22 MenhirState0874 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_23 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_23 MenhirState0874 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.LIDENT _v_24 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState0874 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.INTERP _v_25 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState0874 _menhir_initp - | Lex_menhir_token.INT _v_26 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState0874 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.FLOAT _v_27 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_27 MenhirState0874 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | Lex_menhir_token.CHAR _v_28 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_28 MenhirState0874 _menhir_initp - | Lex_menhir_token.BYTES _v_29 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_29 MenhirState0874 _menhir_initp - | Lex_menhir_token.BYTE _v_30 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_30 MenhirState0874 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0874 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0240 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__3_, _startpos__1_inlined1_ = - (_endpos_1, _startpos_0) - in - let _v = _menhir_action_504 _endpos__3_ _startpos__1_inlined1_ in - _menhir_goto_optional_else _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0241 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0241 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_optional_else : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1249 -> - _menhir_run_1250 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1247 -> - _menhir_run_1248 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1243 -> - _menhir_run_1244 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0906 -> - _menhir_run_0907 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0904 -> - _menhir_run_0905 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0900 -> - _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0896 -> - _menhir_run_0897 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0894 -> - _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0890 -> - _menhir_run_0891 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0881 -> - _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0879 -> - _menhir_run_0880 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0875 -> - _menhir_run_0876 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0864 -> - _menhir_run_0865 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0862 -> - _menhir_run_0863 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0239 -> - _menhir_run_0859 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1250 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_WHILE, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = - _menhir_stack - in - let (MenhirCell1_WHILE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_while_else_, while_else = (_endpos, _v) in - let _v = - _menhir_action_971 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else xs - in - _menhir_goto_while_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_while_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_while_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_042 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState2004 -> - _menhir_run_2005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0000 -> _menhir_run_1252 _menhir_stack _v _tok - | MenhirState0013 -> - _menhir_run_1236 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_1207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_1206 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1204 -> - _menhir_run_1205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_1203 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_1200 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_1198 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_1193 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_1190 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_1188 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_1185 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_1182 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_1177 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_1167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1165 -> - _menhir_run_1166 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_1161 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_1159 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_1156 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_1154 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_1151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_1149 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_1146 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_1143 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_1138 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_1127 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1125 -> - _menhir_run_1126 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_1124 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_1121 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_1119 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_1116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_1114 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_1111 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_1109 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_1106 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_1103 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_1092 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1090 -> - _menhir_run_1091 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_1089 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_1086 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_1084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_1081 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_1079 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_1074 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_1071 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_1068 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_1063 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_1050 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_1047 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1045 -> - _menhir_run_1046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_1042 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_1038 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_1035 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_1032 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_1029 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_1026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_1023 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_1020 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_1013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_1010 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0999 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0996 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0993 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0985 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0983 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0980 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0977 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0971 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0965 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0962 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0957 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0954 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0887 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0872 -> - _menhir_run_0873 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0794 -> - _menhir_run_0827 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0826 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0824 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0821 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0819 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0814 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0811 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0809 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0806 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0803 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0798 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0791 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0789 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0786 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0784 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0781 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0779 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0776 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0774 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0771 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0768 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0763 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0728 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0725 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0722 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0720 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0717 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0715 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0712 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0707 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0704 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0699 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0693 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0692 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0690 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0687 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0685 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0682 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0680 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0677 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0672 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0669 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0664 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0643 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0638 -> - _menhir_run_0639 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0622 -> - _menhir_run_0623 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0618 -> - _menhir_run_0619 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState2053 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0615 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0609 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0607 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0604 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0602 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0599 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0597 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0594 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0592 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0589 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0585 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0567 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0565 -> - _menhir_run_0566 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0561 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0559 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0556 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0554 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0551 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0549 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0546 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0543 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0538 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0529 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0527 -> - _menhir_run_0528 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0526 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0523 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0521 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0518 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0516 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0513 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0511 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0508 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0505 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0503 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0501 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0501 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0496 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0494 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0480 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0476 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0473 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0469 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0244 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0237 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0233 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0076 -> - _menhir_run_0224 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0183 -> - _menhir_run_0185 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0176 -> - _menhir_run_0181 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0179 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState2013 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0161 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0090 -> - _menhir_run_0159 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0144 -> - _menhir_run_0145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0143 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2005 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_val_header - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_val_header - (_menhir_stack, _menhir_s, val_header, _startpos_val_header_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_716 _endpos_expr_ _startpos_val_header_ expr val_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1236 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1237 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_172 x in - _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_rev_expr_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0013 -> - _menhir_run_1232 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1232 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1233 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1233 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1233 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1233 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1233 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1233 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1233 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1233 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1233 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1233 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1233 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1233 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1233 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_134 x xs in - _menhir_goto_non_empty_list_commas_expr_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_133 xs in - _menhir_goto_non_empty_list_commas_expr_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_expr_ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_638 _1_inlined1 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0499 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0500 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _endpos_xs_, xs = (_endpos, _v) in - let _v = _menhir_action_161 xs in - _menhir_goto_non_empty_list_commas_no_trailing_expr_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_xs_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_no_trailing_expr_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1179 -> - _menhir_run_1180 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_1141 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_1101 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_1066 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_1051 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0801 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0766 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0702 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0667 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0583 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0541 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0502 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1180 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_inlined2_, _1_inlined2 = (_endpos, _v) in - let _v = - _menhir_action_417 _1 _1_inlined2 _endpos__1_inlined2_ - _startpos__1_inlined1_ xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1171 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1171 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1171 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1171 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.INT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1171 _menhir_initp - | Lex_menhir_token.FLOAT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1171 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1171 _menhir_initp - | Lex_menhir_token.CHAR _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1171 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_451 x xs in - _menhir_goto_non_empty_list_semis___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_450 xs in - _menhir_goto_non_empty_list_semis___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_run_0249 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_650 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_simple_pattern : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState0279 -> - _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0273 -> - _menhir_run_0274 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1224 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1228 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1216 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1220 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1208 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1212 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1171 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1131 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0532 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0487 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0482 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0248 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0454 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0261 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0441 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0263 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0432 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0415 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0413 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0409 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0407 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0403 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0401 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0397 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0395 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0391 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0389 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0385 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0383 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0379 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0377 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0373 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0371 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0366 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0364 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0360 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0358 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0347 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0345 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0341 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0339 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0335 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0333 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0329 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0327 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0323 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0321 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0317 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0315 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0311 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0308 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0306 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0302 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0300 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0294 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0292 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0288 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0282 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0267 -> - _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0280 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_pattern - _menhir_cell0_RANGE_EXCLUSIVE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_pattern - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = _menhir_action_546 _endpos_rhs_ _startpos_lhs_ lhs rhs in - _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_range_pattern : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.BAR -> ( - let _menhir_stack = - MenhirCell1_range_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BAR (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0282 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AS | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EQUAL | Lex_menhir_token.FAT_ARROW - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_512 _1 in - _menhir_goto_or_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0250 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_UIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0251 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0250 _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_119 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EQUAL - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _menhir_stack = - MenhirCell1_UIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _v_0 = _menhir_action_473 () in - _menhir_run_0465 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0251 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0251 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0453 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LABEL _v -> - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.DOTDOT -> - _menhir_run_0456 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0252 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_642 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0253 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_649 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0254 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_id_, _startpos_id_, id = (_endpos, _startpos, _v) in - let _v = _menhir_action_019 _endpos_id_ _startpos_id_ id in - _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - - and _menhir_goto_constr_pat_argument : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0463 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0463 _menhir_initp - | Lex_menhir_token.POST_LABEL _v_2 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0463 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0463 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0453 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0463 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.LABEL _v_5 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0463 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0463 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0463 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0456 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0463 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - let _menhir_stack = - MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0463 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _1, x = (_v, ()) in - let _v = _menhir_action_022 _1 x in - _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let _1 = _v in - let _v = _menhir_action_021 _1 in - _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0255 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DOT_UIDENT _v_0 -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_DOT_UIDENT (_menhir_stack, _v_0, _startpos_1, _endpos) - in - _menhir_run_0251 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0256 _menhir_initp - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EQUAL - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_DOT_UIDENT (_menhir_stack, _v_0, _startpos_1, _endpos) - in - let _v_2 = _menhir_action_473 () in - _menhir_run_0257 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _v_2 _tok _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_0, _startpos, _v) - in - let _v = _menhir_action_545 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0257 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_PACKAGE_NAME - _menhir_cell0_DOT_UIDENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_DOT_UIDENT - ( _menhir_stack, - constr_name, - _startpos_constr_name_, - _endpos_constr_name_ )) = - _menhir_stack - in - let (MenhirCell1_PACKAGE_NAME - (_menhir_stack, _menhir_s, pkg, _startpos_pkg_)) = - _menhir_stack - in - let _endpos_ps_, ps = (_endpos, _v) in - let _v = - _menhir_action_653 _endpos_constr_name_ _endpos_ps_ _startpos_constr_name_ - _startpos_pkg_ constr_name pkg ps - in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ps_ _startpos_pkg_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0038 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_PACKAGE_NAME -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, ps, _startpos_ps_)) - = - _menhir_stack - in - let _endpos_id_, id = (_endpos, _v) in - let _v = _menhir_action_544 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_id_ _startpos_ps_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0258 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INT _v -> - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_1, _v) in - let _v = _menhir_action_647 _2 _endpos__2_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__2_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__2_, _2 = (_startpos, _endpos_3, _v) in - let _v = _menhir_action_648 _2 _endpos__2_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__2_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0261 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0261 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0262 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EQUAL - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_651 _endpos_name_ _startpos_name_ name in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_name_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0263 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0263 _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_DOTDOT - (_menhir_stack, MenhirState0263, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - _menhir_run_0426 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0425 _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> - let _v = _menhir_action_475 () in - _menhir_run_0428 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0425 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0263 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let _v = _menhir_action_009 () in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0264 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TRUE -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_TRUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0267 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0288 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.STRING _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_STRING (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0292 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0294 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_26 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos__1_, _endpos__2_ = (_startpos, _endpos_26) in - let _v = _menhir_action_659 _endpos__2_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__2_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.MINUS -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0300 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0302 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FLOAT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0306 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0308 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0310 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0264 _menhir_initp - | Lex_menhir_token.INT _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_INT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0315 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0317 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_FLOAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0321 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0323 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FALSE -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_FALSE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0327 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0329 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0333 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0335 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTES _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_BYTES (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0339 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0341 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTE _v -> ( - let _menhir_stack = - MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0264 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_BYTE (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0345 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0347 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0268 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_645 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0269 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_646 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0270 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_643 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0271 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_644 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0310 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0311 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_053 _endpos_name_ _startpos_name_ name in - _menhir_goto_fields_pat_single _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_fields_pat_single : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0264 -> - _menhir_run_0424 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0418 -> - _menhir_run_0419 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0424 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_174 x in - _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0310 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0418 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = ((), _v) in - let _v = _menhir_action_136 x xs in - _menhir_goto_non_empty_list_commas_fields_pat_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let xs = _v in - let _v = _menhir_action_260 xs in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> - let _tok = _menhir_lexer _menhir_lexbuf in - let x, fps = ((), _v) in - let _v = _menhir_action_124 fps x in - _menhir_goto_non_empty_fields_pat _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | Lex_menhir_token.RBRACE -> - let fps = _v in - let _v = _menhir_action_123 fps in - _menhir_goto_non_empty_fields_pat _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_135 xs in - _menhir_goto_non_empty_list_commas_fields_pat_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_goto_non_empty_list_commas_fields_pat_single_ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let fps = _v in - let _v = _menhir_action_122 fps in - _menhir_goto_non_empty_fields_pat _menhir_stack _menhir_lexbuf _menhir_lexer - _v _tok _menhir_initp - - and _menhir_goto_non_empty_fields_pat : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, p = (_endpos, _v) in - let _v = _menhir_action_660 _endpos__3_ _startpos__1_ p in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0419 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_175 x xs in - _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0426 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_476 _endpos_name_ _startpos_name_ name in - _menhir_goto_option___anonymous_18_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option___anonymous_18_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0436 -> - _menhir_run_0437 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0425 -> - _menhir_run_0428 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0437 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_non_empty_list_commas_with_tail_pattern_ - _menhir_cell0_DOTDOT - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0438 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0438 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0438 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0438 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.INT _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0438 _menhir_initp - | Lex_menhir_token.FLOAT _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0438 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0438 _menhir_initp - | Lex_menhir_token.CHAR _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0438 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_with_tail_pattern_ - (_menhir_stack, _, ps)) = - _menhir_stack - in - let x, b = ((), _v) in - let _v = _menhir_action_015 b ps x in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_with_tail_pattern_ - (_menhir_stack, _, ps)) = - _menhir_stack - in - let b = _v in - let _v = _menhir_action_014 b ps in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_array_sub_patterns : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__1_, _)) - = - _menhir_stack - in - let _endpos__3_, pats = (_endpos, _v) in - let _v = _menhir_action_658 _endpos__3_ _startpos__1_ pats in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0428 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_DOTDOT - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0429 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0429 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0429 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0429 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.INT _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0429 _menhir_initp - | Lex_menhir_token.FLOAT _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0429 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0429 _menhir_initp - | Lex_menhir_token.CHAR _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_18_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0429 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let x, b = ((), _v) in - let _v = _menhir_action_011 b x in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let b = _v in - let _v = _menhir_action_010 b in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf - _menhir_lexer _v _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0453 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0454 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COMMA - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RPAREN -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_651 _endpos_name_ _startpos_name_ name in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_name_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0162 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_054 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_fn_label _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_fn_label : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1919 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1862 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1802 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1745 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1604 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1547 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1487 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1430 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1338 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0031 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0829 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0730 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0574 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0632 -> - _menhir_run_0634 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0459 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0459 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0634 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_fn_label - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0636 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let label = _v in - let _v = _menhir_action_519 label in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_fn_label (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0638 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_fn_label (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0640 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let label = _v in - let _v = _menhir_action_515 label in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_parameter : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0632 -> - _menhir_run_0633 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1919 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1862 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1802 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1745 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1604 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1547 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1487 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1430 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1338 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0031 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0829 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0730 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0574 -> - _menhir_run_0630 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0633 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_parameter_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_parameter_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_247 x xs in - _menhir_goto_non_empty_list_commas_rev_parameter_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_parameter_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.POST_LABEL _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0632 _menhir_initp - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0632 _menhir_initp - | Lex_menhir_token.LABEL _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0632 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_148 x xs in - _menhir_goto_non_empty_list_commas_parameter_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_147 xs in - _menhir_goto_non_empty_list_commas_parameter_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_0617 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_POST_LABEL - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0618 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_POST_LABEL - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0620 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_binder_name_, _startpos_binder_name_, binder_name = - (_endpos, _startpos, _v) - in - let _v = - _menhir_action_521 _endpos_binder_name_ _startpos_binder_name_ - binder_name - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0624 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0626 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_binder_name_, _startpos_binder_name_, binder_name = - (_endpos, _startpos, _v) - in - let _v = - _menhir_action_525 _endpos_binder_name_ _startpos_binder_name_ - binder_name - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0628 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_513 _endpos_name_ _startpos_name_ name in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_parameter_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState1919 -> - _menhir_run_1947 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1862 -> - _menhir_run_1890 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1802 -> - _menhir_run_1830 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1745 -> - _menhir_run_1773 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1604 -> - _menhir_run_1632 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1547 -> - _menhir_run_1575 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1487 -> - _menhir_run_1515 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1430 -> - _menhir_run_1458 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1338 -> - _menhir_run_1340 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0031 -> - _menhir_run_0914 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState0829 -> - _menhir_run_0838 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState0730 -> - _menhir_run_0739 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState0574 -> - _menhir_run_0644 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1947 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1949 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1963 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1963 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_752 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _endpos_6 _endpos_3 _startpos _v - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1963 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1963 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1963 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1963 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1963 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1963 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1963 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1963 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1963 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1963 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1963 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1344 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1344 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_act_goto_752 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined3_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_752 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_752 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2038 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_438 x in - _menhir_goto_non_empty_list_semi_rev_aux_structure_item_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0243 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0243 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0245 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DOT_UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_PACKAGE_NAME (_menhir_stack, _menhir_s, _v, _startpos) - in - _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_1 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_1, _startpos, _v) - in - let _v = _menhir_action_540 id ps in - _menhir_goto_qual_ident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_id_ _startpos_ps_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_1, _startpos, _v) - in - let _v = _menhir_action_542 id ps in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_id_, id, _startpos_ps_, ps = - (_endpos, _v_1, _startpos, _v) - in - let _v = _menhir_action_544 id ps in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_id_ _startpos_ps_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_qual_ident : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1173 -> - _menhir_run_1201 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_1162 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_1122 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0822 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0723 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0688 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0605 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0562 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0524 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1201 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1202 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1204 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_1162 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1163 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1165 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_1122 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1123 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1125 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_1087 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1088 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1090 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0822 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0823 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0825 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0787 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0788 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0790 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0723 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0724 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0726 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0688 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0689 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0691 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0605 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0606 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0608 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0562 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0563 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0565 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0524 : - type ttv_stack ttv_result. - ((ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0525 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_13 -> ( - let _v = _v_13 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0527 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _menhir_fail () - - and _menhir_run_0247 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _ | Lex_menhir_token.EQUAL -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_539 i in - _menhir_goto_qual_ident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_541 i in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0248 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) in - let _menhir_s = MenhirState0248 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MUTABLE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_MUTABLE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_EQUAL (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0468 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0470 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0481 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0481 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LET -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState0482 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0572 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LIDENT _v -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_1, _endpos_2) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, MenhirState0574, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0576 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0575 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_4 = _menhir_action_485 () in - _menhir_run_0578 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_4 MenhirState0575 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_5 -> - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0574 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0574 _menhir_initp - | Lex_menhir_token.LABEL _v_7 -> - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0574 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_8 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.UIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0653 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.STRING _v_11 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0653 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_12 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let ( _startpos__1_, - _endpos_name_, - _startpos_name_, - name, - _endpos__3_, - _endpos__4_ ) = - (_startpos, _endpos, _startpos_0, _v, _endpos_12, _endpos_9) - in - let _v = - _menhir_action_682 _endpos__3_ _endpos__4_ _endpos_name_ - _startpos__1_ _startpos_name_ name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_13 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0653 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.LIDENT _v_14 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0653 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.INT _v_15 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0653 _menhir_initp - | Lex_menhir_token.FLOAT _v_16 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState0653 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0653 _menhir_initp - | Lex_menhir_token.CHAR _v_17 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_8, _endpos_9) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_17 MenhirState0653 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _startpos_20 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_21 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_20, _endpos_21) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState0730, _endpos_22) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0576 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0731 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_23 = _menhir_action_485 () in - _menhir_run_0732 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_23 MenhirState0731 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_24 -> - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState0730 _menhir_initp - | Lex_menhir_token.LIDENT _v_25 -> - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState0730 _menhir_initp - | Lex_menhir_token.LABEL _v_26 -> - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState0730 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.UIDENT _v_29 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_29 MenhirState0748 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.STRING _v_30 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_30 MenhirState0748 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let ( _startpos__1_, - _endpos_name_, - _startpos_name_, - name, - _endpos__3_, - _endpos__4_ ) = - ( _startpos, - _endpos, - _startpos_0, - _v, - _endpos_31, - _endpos_28 ) - in - let _v = - _menhir_action_680 _endpos__3_ _endpos__4_ _endpos_name_ - _startpos__1_ _startpos_name_ name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_32 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_32 MenhirState0748 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.LIDENT _v_33 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_33 MenhirState0748 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.INT _v_34 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_34 MenhirState0748 _menhir_initp - | Lex_menhir_token.FLOAT _v_35 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_35 MenhirState0748 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0748 _menhir_initp - | Lex_menhir_token.CHAR _v_36 -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_18, _endpos_19) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_27, _endpos_28) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_36 MenhirState0748 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - _menhir_run_0828 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0576 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _menhir_stack = MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s) in - let _menhir_s = MenhirState0576 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0578 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0579 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0579 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, ty_opt, _startpos__1_inlined2_ = - (_endpos_2, _v, _startpos) - in - let _v = - _menhir_action_674 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - _startpos_name_ name ty_opt - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0579 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0579 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0579 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0579 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0579 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0579 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0579 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0579 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0579 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0579 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0579 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_statement : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState2062 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0613 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0586 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0613 : - type ttv_stack ttv_result. - ( ttv_stack, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_437 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_statement_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_statement_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState2053 -> - _menhir_run_2061 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_2057 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_1971 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_1967 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_1959 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_1955 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_1943 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_1939 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_1931 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_1927 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_1914 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_1910 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_1902 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_1898 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_1886 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_1882 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_1874 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_1870 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_1854 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_1850 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_1842 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_1838 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_1826 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_1822 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_1814 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_1810 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_1797 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_1793 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_1785 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_1781 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_1769 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_1765 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_1757 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_1753 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_1656 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_1652 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_1644 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_1640 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_1628 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_1624 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_1616 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_1612 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_1599 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_1595 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_1587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_1583 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_1571 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_1567 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_1559 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_1555 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_1539 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_1535 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_1527 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_1523 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_1511 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_1507 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_1499 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_1495 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_1482 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_1478 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_1470 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_1466 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_1454 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_1450 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_1442 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_1438 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_1409 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_1405 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_1245 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_1002 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0949 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0940 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0934 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0929 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0919 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0910 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0902 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0892 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0877 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0860 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0855 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0851 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0843 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0834 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0744 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0735 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0649 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0610 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2061 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2062 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState2062 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell1_fun_header - (_menhir_stack, _menhir_s, t, _startpos_t_)) = - _menhir_stack - in - let _endpos_x_, x, _startpos_xs_, xs, _endpos__4_ = - (_endpos_1, _v_0, _startpos, _v, _endpos_4) - in - let _v = - _menhir_action_724 _endpos__4_ _endpos_x_ _startpos__1_ - _startpos_t_ _startpos_xs_ t x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState2062 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState2062 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState2062 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState2062 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState2062 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState2062 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState2062 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState2062 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState2062 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState2062 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2062 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) - = - _menhir_stack - in - let _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - (_endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_723 _endpos__4_ _endpos_xs_ _startpos__1_ _startpos_t_ - _startpos_xs_ t xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0581 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_691 _endpos__1_ _startpos__1_ in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0582 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0582 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0582 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_687 _endpos__1_ _startpos__1_ in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0584 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0584 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0584 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_ = (_endpos, _startpos) in - let _v = _menhir_action_685 _endpos__1_ _startpos__1_ in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_2057 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2058 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState2058 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined1, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell1_fun_header - (_menhir_stack, _menhir_s, t, _startpos_t_)) = - _menhir_stack - in - let _endpos_x_, x, _startpos_xs_, xs, _endpos__4_ = - (_endpos_1, _v_0, _startpos, _v, _endpos_4) - in - let _v = - _menhir_action_727 _1_inlined1 _endpos__4_ _endpos_x_ - _startpos__1_ _startpos_t_ _startpos_xs_ t x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState2058 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState2058 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState2058 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState2058 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState2058 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState2058 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState2058 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState2058 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState2058 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState2058 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2058 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined1, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) - = - _menhir_stack - in - let _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - (_endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_726 _1_inlined1 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos_t_ _startpos_xs_ t xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1971 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1972 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1972 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_754 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined3_ _1_inlined2 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1972 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1972 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1972 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1972 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1972 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1972 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1972 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1972 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1972 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1972 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1972 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_753 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined3_ _1_inlined2 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_754 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_754 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_754 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_753 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_753 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_753 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1967 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1968 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1968 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_757 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined3_ _1_inlined2 _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1968 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1968 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1968 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1968 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1968 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1968 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1968 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1968 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1968 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1968 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1968 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_756 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined3_ _1_inlined2 _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_757 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_757 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_757 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_756 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_756 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_756 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1959 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1960 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1960 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_760 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1960 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1960 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1960 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1960 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1960 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1960 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1960 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1960 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1960 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1960 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1960 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_759 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined2 _startpos__1_inlined4_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_760 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_760 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_760 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_759 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_759 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_759 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1955 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1956 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1956 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_763 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers _1_inlined5 - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1956 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1956 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1956 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1956 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1956 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1956 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1956 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1956 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1956 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1956 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1956 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_762 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined2 _startpos__1_inlined4_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers _1_inlined5 - | _ -> _eRR () - - and _menhir_act_goto_763 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_763 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_763 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_762 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_762 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_762 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1943 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1944 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1944 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_742 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1944 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1944 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1944 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1944 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1944 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1944 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1944 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1944 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1944 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1944 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1944 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_741 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_742 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_742 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_742 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_741 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_741 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_741 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1939 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1940 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1940 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_745 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1940 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1940 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1940 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1940 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1940 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1940 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1940 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1940 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1940 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1940 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1940 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_744 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_745 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_745 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_745 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_744 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_744 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_744 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1931 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1932 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1932 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_748 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1932 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1932 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1932 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1932 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1932 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1932 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1932 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1932 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1932 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1932 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1932 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_747 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined3_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_748 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_748 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_748 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_747 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_747 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_747 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1927 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1928 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1928 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_751 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined3_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1928 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1928 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1928 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1928 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1928 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1928 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1928 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1928 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1928 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1928 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1928 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_750 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_751 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_751 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_751 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_750 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_750 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_750 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1914 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1915 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1915 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_778 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos_4 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1915 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1915 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1915 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1915 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1915 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1915 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1915 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1915 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1915 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1915 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1915 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_777 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _1_inlined1 _endpos_15 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_778 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_778 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_778 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_777 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_777 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_777 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1910 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1911 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1911 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_781 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos_4 _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1911 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1911 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1911 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1911 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1911 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1911 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1911 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1911 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1911 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1911 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1911 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_780 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _1_inlined1 _endpos_15 - _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_781 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_781 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_781 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_780 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_780 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_780 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1902 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1903 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1903 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_784 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1903 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1903 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1903 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1903 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1903 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1903 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1903 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1903 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1903 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1903 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1903 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_783 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _1_inlined1 _endpos__2_inlined1_ - _2_inlined1 _endpos_15 _startpos__1_inlined3_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_784 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_784 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_784 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_783 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_783 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_783 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1898 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1899 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1899 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_787 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1899 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1899 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1899 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1899 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1899 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1899 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1899 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1899 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1899 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1899 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1899 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_786 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _1_inlined1 _endpos__2_inlined1_ - _2_inlined1 _endpos_15 _startpos__1_inlined3_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers - | _ -> _eRR () - - and _menhir_act_goto_787 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_787 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_787 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_786 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_786 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_786 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1886 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1887 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1887 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_766 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v - _startpos__1_inlined1_ _endpos_4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1887 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1887 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1887 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1887 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1887 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1887 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1887 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1887 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1887 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1887 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1887 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_765 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _startpos__1_inlined1_ - _endpos_15 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_766 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_766 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_766 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_765 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_765 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_765 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1882 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1883 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1883 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_769 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v - _startpos__1_inlined1_ _endpos_4 _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1883 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1883 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1883 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1883 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1883 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1883 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1883 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1883 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1883 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1883 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1883 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_768 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _startpos__1_inlined1_ - _endpos_15 _1_inlined2 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_769 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_769 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_769 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_768 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_768 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_768 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1874 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1875 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1875 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_772 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1875 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1875 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1875 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1875 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1875 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1875 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1875 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1875 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1875 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1875 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1875 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_771 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_772 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_772 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_772 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_771 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_771 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_771 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1870 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1871 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1871 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_775 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1871 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1871 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1871 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1871 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1871 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1871 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1871 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1871 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1871 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1871 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1871 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_774 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | _ -> _eRR () - - and _menhir_act_goto_775 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_775 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_775 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_774 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_774 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_774 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers self_ty xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1854 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1855 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1855 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_850 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined3_ _1_inlined2 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1855 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1855 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1855 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1855 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1855 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1855 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1855 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1855 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1855 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1855 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1855 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_849 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined3_ _1_inlined2 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_850 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_850 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_850 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_849 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_849 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_849 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1850 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1851 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1851 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_853 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined3_ _1_inlined2 _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1851 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1851 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1851 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1851 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1851 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1851 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1851 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1851 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1851 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1851 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1851 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_852 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined3_ _1_inlined2 _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_853 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_853 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_853 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_852 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined3_ _1_inlined2 - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_852 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_852 _1_inlined2 _1_inlined4 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1842 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1843 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1843 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_856 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1843 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1843 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1843 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1843 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1843 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1843 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1843 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1843 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1843 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1843 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1843 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_855 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined2 _startpos__1_inlined4_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_856 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_856 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_856 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_855 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_855 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_855 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1838 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1839 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1839 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_859 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers _1_inlined5 - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1839 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1839 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1839 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1839 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1839 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1839 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1839 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1839 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1839 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1839 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1839 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_858 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined2 _startpos__1_inlined4_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers _1_inlined5 - | _ -> _eRR () - - and _menhir_act_goto_859 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_859 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_859 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_858 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_858 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_858 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1826 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1827 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1827 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_838 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1827 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1827 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1827 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1827 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1827 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1827 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1827 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1827 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1827 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1827 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1827 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_837 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_838 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_838 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_838 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_837 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_837 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_837 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1822 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1823 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1823 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_841 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _endpos_4 - _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1823 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1823 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1823 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1823 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1823 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1823 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1823 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1823 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1823 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1823 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1823 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_840 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _endpos_15 _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_841 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _endpos__4_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_841 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_841 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_840 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _endpos__4_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_840 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_840 _1_inlined3 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1814 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1815 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1815 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_844 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1815 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1815 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1815 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1815 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1815 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1815 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1815 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1815 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1815 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1815 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1815 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_843 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined3_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_844 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_844 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_844 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_843 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_843 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_843 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1810 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1811 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1811 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_847 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined3_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1811 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1811 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1811 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1811 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1811 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1811 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1811 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1811 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1811 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1811 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1811 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_846 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_847 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_847 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_847 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_846 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_846 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_846 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1797 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1798 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1798 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_874 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos_4 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1798 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1798 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1798 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1798 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1798 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1798 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1798 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1798 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1798 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1798 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1798 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_873 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _1_inlined1 _endpos_15 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_874 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_874 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_874 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_873 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__4_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_873 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_873 _1_inlined1 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1793 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1794 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1794 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_877 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos_4 _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1794 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1794 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1794 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1794 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1794 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1794 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1794 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1794 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1794 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1794 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1794 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_876 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _1_inlined1 _endpos_15 - _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_877 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_877 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_877 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_876 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_876 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_876 _1_inlined1 _1_inlined3 _endpos__0_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1785 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1786 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1786 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_880 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1786 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1786 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1786 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1786 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1786 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1786 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1786 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1786 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1786 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1786 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1786 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_879 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _1_inlined1 _endpos__2_inlined1_ - _2_inlined1 _endpos_15 _startpos__1_inlined3_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_880 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_880 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_880 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_879 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_879 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_879 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1781 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1782 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1782 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_883 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos_4 _startpos__1_inlined3_ - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1782 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1782 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1782 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1782 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1782 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1782 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1782 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1782 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1782 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1782 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1782 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_882 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _1_inlined1 _endpos__2_inlined1_ - _2_inlined1 _endpos_15 _startpos__1_inlined3_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | _ -> _eRR () - - and _menhir_act_goto_883 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_883 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_883 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_882 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined3_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_882 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_882 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1769 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1770 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1770 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_862 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v - _startpos__1_inlined1_ _endpos_4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1770 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1770 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1770 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1770 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1770 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1770 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1770 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1770 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1770 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1770 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1770 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_861 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _startpos__1_inlined1_ - _endpos_15 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_862 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_862 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_862 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_861 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_861 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_861 _endpos__0_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1765 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1766 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1766 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_865 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_1 _v_0 _startpos _v - _startpos__1_inlined1_ _endpos_4 _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1766 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1766 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1766 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1766 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1766 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1766 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1766 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1766 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1766 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1766 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1766 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_864 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos _startpos _v _startpos__1_inlined1_ - _endpos_15 _1_inlined2 _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_865 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_x_ x - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_865 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_865 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_864 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos_xs_ - _startpos_xs_ xs _startpos__1_inlined1_ _endpos__4_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_864 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_864 _1_inlined2 _endpos__0_ _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1757 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1758 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1758 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_868 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1758 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1758 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1758 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1758 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1758 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1758 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1758 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1758 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1758 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1758 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1758 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_867 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_868 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_868 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_868 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_867 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_867 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_867 _2_inlined1 _endpos__0_ _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_xs_ name name_inlined1 - quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1753 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1754 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1754 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_871 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_1 _v_0 _startpos _v _endpos__2_inlined1_ - _2_inlined1 _endpos_4 _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1754 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1754 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1754 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1754 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1754 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1754 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1754 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1754 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1754 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1754 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1754 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_870 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _startpos _v _endpos__2_inlined1_ _2_inlined1 - _endpos_15 _1_inlined3 _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | _ -> _eRR () - - and _menhir_act_goto_871 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_x_ x - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_871 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_871 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers x xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_870 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos_xs_ - _startpos_xs_ xs _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_870 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_870 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_xs_ - name name_inlined1 quantifiers xs - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1656 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1657 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1657 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_802 _1_inlined2 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1657 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1657 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1657 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1657 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1657 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1657 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1657 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1657 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1657 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1657 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1657 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_801 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1652 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1653 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1653 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_805 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1653 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1653 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1653 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1653 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1653 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1653 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1653 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1653 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1653 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1653 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1653 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_804 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1644 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1645 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1645 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_808 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1645 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1645 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1645 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1645 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1645 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1645 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1645 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1645 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1645 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1645 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1645 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_807 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1640 : - type ttv_stack. - (( ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1641 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1641 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_811 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1641 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1641 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1641 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1641 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1641 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1641 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1641 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1641 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1641 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1641 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1641 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_810 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1628 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1629 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1629 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_790 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1629 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1629 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1629 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1629 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1629 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1629 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1629 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1629 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1629 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1629 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1629 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_789 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1624 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1625 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1625 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_793 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1625 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1625 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1625 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1625 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1625 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1625 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1625 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1625 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1625 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1625 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1625 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_792 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1616 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1617 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1617 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_796 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1617 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1617 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1617 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1617 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1617 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1617 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1617 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1617 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1617 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1617 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1617 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_795 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1612 : - type ttv_stack. - (( ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1613 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1613 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_799 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1613 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1613 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1613 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1613 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1613 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1613 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1613 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1613 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1613 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1613 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1613 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_798 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1599 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1600 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1600 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_826 _1_inlined1 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1600 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1600 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1600 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1600 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1600 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1600 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1600 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1600 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1600 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1600 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1600 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_825 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1595 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1596 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1596 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_829 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1596 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1596 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1596 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1596 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1596 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1596 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1596 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1596 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1596 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1596 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1596 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_828 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1587 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1588 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1588 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_832 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1588 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1588 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1588 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1588 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1588 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1588 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1588 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1588 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1588 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1588 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1588 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_831 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1583 : - type ttv_stack. - (( ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1584 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1584 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_835 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1584 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1584 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1584 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1584 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1584 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1584 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1584 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1584 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1584 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1584 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1584 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_834 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1571 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1572 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1572 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_814 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1572 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1572 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1572 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1572 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1572 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1572 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1572 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1572 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1572 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1572 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1572 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_813 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1567 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1568 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1568 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_817 _1_inlined2 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1568 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1568 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1568 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1568 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1568 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1568 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1568 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1568 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1568 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1568 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1568 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_816 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1559 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1560 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1560 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_820 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1560 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1560 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1560 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1560 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1560 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1560 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1560 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1560 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1560 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1560 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1560 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_819 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1555 : - type ttv_stack. - (( ( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1556 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1556 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_823 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers self_ty x - x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1556 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1556 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1556 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1556 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1556 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1556 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1556 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1556 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1556 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1556 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1556 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_822 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers self_ty x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1539 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1540 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1540 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_898 _1_inlined2 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1540 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1540 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1540 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1540 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1540 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1540 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1540 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1540 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1540 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1540 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1540 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_897 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1535 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1536 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1536 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_901 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1536 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1536 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1536 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1536 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1536 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1536 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1536 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1536 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1536 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1536 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1536 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_900 _1_inlined2 _1_inlined4 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1527 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1528 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1528 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_904 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1528 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1528 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1528 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1528 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1528 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1528 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1528 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1528 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1528 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1528 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1528 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_903 _1_inlined2 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1523 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1524 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1524 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_907 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined4_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1524 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1524 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1524 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1524 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1524 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1524 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1524 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1524 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1524 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1524 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1524 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined5, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_906 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1511 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1512 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1512 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_886 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1512 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1512 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1512 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1512 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1512 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1512 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1512 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1512 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1512 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1512 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1512 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_885 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1507 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1508 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1508 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_889 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1508 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1508 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1508 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1508 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1508 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1508 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1508 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1508 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1508 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1508 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1508 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_888 _1_inlined3 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1499 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1500 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1500 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_892 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1500 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1500 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1500 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1500 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1500 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1500 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1500 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1500 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1500 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1500 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1500 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_891 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1495 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1496 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1496 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_895 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1496 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1496 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1496 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1496 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1496 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1496 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1496 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1496 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1496 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1496 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1496 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_894 _1_inlined4 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1482 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1483 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1483 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_922 _1_inlined1 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1483 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1483 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1483 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1483 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1483 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1483 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1483 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1483 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1483 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1483 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1483 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_921 _1_inlined1 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1478 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1479 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1479 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_925 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1479 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1479 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1479 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1479 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1479 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1479 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1479 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1479 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1479 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1479 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1479 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_924 _1_inlined1 _1_inlined3 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1470 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1471 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1471 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_928 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1471 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1471 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1471 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1471 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1471 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1471 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1471 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1471 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1471 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1471 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1471 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_927 _1_inlined1 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1466 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1467 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1467 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_931 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1467 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1467 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1467 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1467 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1467 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1467 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1467 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1467 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1467 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1467 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1467 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined4, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_930 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1454 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1455 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1455 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_910 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_x_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1455 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1455 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1455 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1455 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1455 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1455 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1455 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1455 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1455 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1455 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1455 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_909 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1450 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1451 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1451 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_913 _1_inlined2 _endpos__3_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1451 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1451 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1451 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1451 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1451 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1451 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1451 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1451 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1451 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1451 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1451 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_912 _1_inlined2 _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ _startpos__1_inlined1_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1442 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1443 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1443 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_916 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1443 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1443 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1443 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1443 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1443 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1443 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1443 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1443 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1443 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1443 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1443 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_915 _2_inlined1 _endpos__2_inlined1_ _endpos__4_ - _endpos_name_ _endpos_name_inlined1_ _endpos_x_ _endpos_xs_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1438 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1439 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1439 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _startpos_xs_, - xs, - _endpos__4_, - _endpos_x_inlined1_, - x_inlined1 ) = - ((), _startpos, _v, _endpos_4, _endpos_1, _v_0) - in - let _v = - _menhir_action_919 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_x_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - _startpos_xs_ name name_inlined1 quantifiers x x_inlined1 xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1439 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1439 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1439 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1439 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1439 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1439 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1439 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1439 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1439 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1439 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1439 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined3, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - ((), _endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_918 _1_inlined3 _2_inlined1 _endpos__2_inlined1_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _endpos_xs_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ _startpos_xs_ name - name_inlined1 quantifiers x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1409 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1410 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1410 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, params, _, _)) = - _menhir_stack - in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_x_, x, _startpos_xs_, xs, _endpos__4_ = - (_endpos_1, _v_0, _startpos, _v, _endpos_4) - in - let _v = - _menhir_action_736 _endpos__4_ _endpos_x_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params x xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1410 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1410 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1410 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1410 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1410 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1410 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1410 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1410 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1410 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1410 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1410 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_option_parameters_ (_menhir_stack, _, params, _, _)) = - _menhir_stack - in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - (_endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_735 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1405 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_local_type_decl_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1406 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1406 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, params, _, _)) = - _menhir_stack - in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_x_, x, _startpos_xs_, xs, _endpos__4_ = - (_endpos_1, _v_0, _startpos, _v, _endpos_4) - in - let _v = - _menhir_action_739 _1_inlined2 _endpos__4_ _endpos_x_ - _startpos__1_ _startpos__1_inlined1_ _startpos_xs_ name params x - xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1406 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1406 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1406 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1406 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1406 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1406 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1406 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1406 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1406 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1406 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1406 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _, _1_inlined2, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_option_parameters_ (_menhir_stack, _, params, _, _)) = - _menhir_stack - in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_xs_, _startpos_xs_, xs, _endpos__4_ = - (_endpos, _startpos, _v, _endpos_15) - in - let _v = - _menhir_action_738 _1_inlined2 _endpos__4_ _endpos_xs_ _startpos__1_ - _startpos__1_inlined1_ _startpos_xs_ name params xs - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1245 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_WHILE, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1246 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1246 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState1246, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1247 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_1248 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1246 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1246 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1246 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1246 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1246 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1246 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1246 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1246 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1246 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1246 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1246 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos_16) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1249 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_1250 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1248 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_WHILE, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = - _menhir_stack - in - let (MenhirCell1_WHILE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_while_else_, while_else = (_endpos, _v) in - let _v = - _menhir_action_972 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else x xs - in - _menhir_goto_while_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_while_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1002 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1003 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1003 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _endpos_x_, x, _startpos_xs_, xs = - (_endpos_4, _endpos_1, _v_0, _startpos, _v) - in - let _v = - _menhir_action_575 _endpos__3_ _endpos_x_ _startpos__1_ - _startpos_xs_ x xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1003 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1003 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1003 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1003 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1003 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1003 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1003 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1003 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1003 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1003 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1003 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _endpos_xs_, _startpos_xs_, xs = - (_endpos_15, _endpos, _startpos, _v) - in - let _v = - _menhir_action_574 _endpos__3_ _endpos_xs_ _startpos__1_ _startpos_xs_ - xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0949 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE - _menhir_cell0_ELSE, - ttv_result ) - _menhir_cell1_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0950 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0950 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE - (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs_inlined1 = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_088 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs xs_inlined1 - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0950 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0950 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0950 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0950 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0950 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0950 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0950 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0950 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0950 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0950 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0950 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs_inlined1 = (_endpos_15, _v) in - let _v = - _menhir_action_087 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b xs xs_inlined1 - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_if_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState0946 -> - _menhir_run_0953 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0937 -> - _menhir_run_0944 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0926 -> - _menhir_run_0933 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0953 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE - _menhir_cell0_ELSE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = _menhir_stack in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_ifnot_, ifnot = (_endpos, _v) in - let _v = - _menhir_action_093 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ifnot_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0944 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = _menhir_stack in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_ifnot_, ifnot = (_endpos, _v) in - let _v = - _menhir_action_094 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot x xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ifnot_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0933 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = _menhir_stack in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_ifnot_, ifnot = (_endpos, _v) in - let _v = - _menhir_action_092 _endpos__3_ _endpos_ifnot_ _startpos__1_ - _startpos__1_inlined1_ b ifnot - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ifnot_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0140 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_044 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0940 : - type ttv_stack ttv_result. - (( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - ttv_result ) - _menhir_cell1_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0941 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0941 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE - (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs_inlined1, x_inlined1 = - (_endpos_4, _v, _v_0) - in - let _v = - _menhir_action_091 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x x_inlined1 xs - xs_inlined1 - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0941 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0941 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0941 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0941 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0941 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0941 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0941 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0941 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0941 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0941 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0941 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs_inlined1 = (_endpos_15, _v) in - let _v = - _menhir_action_090 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs xs_inlined1 - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0934 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0935 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0935 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_7 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.UIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_8 MenhirState0938 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.STRING _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_9 MenhirState0938 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE - (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) - = - _menhir_stack - in - let (MenhirCell1_IF - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let ( _endpos__3_, - _endpos__3_inlined1_, - x, - xs, - _startpos__1_inlined2_ ) = - (_endpos_4, _endpos_10, _v_0, _v, _startpos_6) - in - let _v = - _menhir_action_089 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined2_ b x xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_inlined1_ _startpos__1_ _v - _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState0938 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState0938 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_13 MenhirState0938 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.LIDENT _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState0938 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.INTERP _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState0938 _menhir_initp - | Lex_menhir_token.INT _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState0938 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.FLOAT _v_17 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState0938 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | Lex_menhir_token.CHAR _v_18 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState0938 _menhir_initp - | Lex_menhir_token.BYTES _v_19 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState0938 _menhir_initp - | Lex_menhir_token.BYTE _v_20 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState0938 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0937, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0938 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0935, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0937 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACE - (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_097 _endpos__3_ _startpos__1_ - _startpos__1_inlined1_ b x xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_21 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_21 - MenhirState0935 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_22 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_22 - MenhirState0935 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_23 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_23 - MenhirState0935 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.LIDENT _v_24 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_24 - MenhirState0935 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.INTERP _v_25 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_25 - MenhirState0935 _menhir_initp - | Lex_menhir_token.INT _v_26 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_26 - MenhirState0935 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.FLOAT _v_27 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_27 - MenhirState0935 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | Lex_menhir_token.CHAR _v_28 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_28 - MenhirState0935 _menhir_initp - | Lex_menhir_token.BYTES _v_29 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_29 - MenhirState0935 _menhir_initp - | Lex_menhir_token.BYTE _v_30 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_30 - MenhirState0935 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0935 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _startpos_32 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_33 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_34 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.UIDENT _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_35 MenhirState0947 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.STRING _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_36 MenhirState0947 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_37 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE - (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let ( _endpos__3_, - _endpos__3_inlined1_, - xs, - _startpos__1_inlined2_ ) = - (_endpos_31, _endpos_37, _v, _startpos_33) - in - let _v = - _menhir_action_086 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined2_ b xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_inlined1_ _startpos__1_ _v - _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_38 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_38 MenhirState0947 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_39 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_39 MenhirState0947 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_40 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_40 MenhirState0947 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.LIDENT _v_41 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_41 MenhirState0947 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.INTERP _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0947 _menhir_initp - | Lex_menhir_token.INT _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0947 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.FLOAT _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0947 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | Lex_menhir_token.CHAR _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0947 _menhir_initp - | Lex_menhir_token.BYTES _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0947 _menhir_initp - | Lex_menhir_token.BYTE _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0947 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0946, - _startpos_33, - _endpos_34 ) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0947 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACE (_menhir_stack, _endpos_31) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_32) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0946 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, xs = (_endpos_31, _v) in - let _v = - _menhir_action_096 _endpos__3_ _startpos__1_ - _startpos__1_inlined1_ b xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0929 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_IF, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE - _menhir_cell0_ELSE, - ttv_result ) - _menhir_cell1_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0930 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0930 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE - (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_085 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b x xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0930 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0930 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0930 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0930 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0930 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0930 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0930 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0930 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0930 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0930 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0930 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, b, _, _)) = - _menhir_stack - in - let (MenhirCell1_IF (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_084 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ b xs - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0919 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0920 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0920 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_589 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ - ty_opt x xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0920 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0920 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0920 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0920 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0920 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0920 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0920 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0920 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0920 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0920 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0920 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_588 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ ty_opt - xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0910 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0911 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0911 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_586 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt x xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0911 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0911 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0911 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0911 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0911 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0911 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0911 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0911 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0911 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0911 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0911 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_585 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ _startpos__1_inlined2_ ty_opt xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0902 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0903 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0903 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0903, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0904 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_0905 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0903 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0903 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0903 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0903 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0903 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0903 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0903 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0903 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0903 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0903 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0903 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos_16) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0906 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_0907 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0905 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_065 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else x xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_for_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_040 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0907 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_064 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0892 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0893 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0893 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0893, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0894 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0893 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0893 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0893 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0893 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0893 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0893 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0893 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0893 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0893 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0893 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0893 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos_16) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0896 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_0897 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0895 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_non_empty_list_commas_no_trailing___anonymous_12_ - (_menhir_stack, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_062 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else x xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0897 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_non_empty_list_commas_no_trailing___anonymous_12_ - (_menhir_stack, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_061 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0877 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0878 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0878 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0878, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0879 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_0880 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0878 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0878 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0878 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0878 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0878 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0878 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0878 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0878 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0878 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0878 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0878 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos_16) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0881 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0880 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_059 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else x xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0882 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_058 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else xs - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0860 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0861 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0861 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0861, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0862 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_0863 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0861 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0861 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0861 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0861 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0861 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0861 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0861 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0861 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0861 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0861 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0861 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos_16) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0864 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_507 () in - _menhir_run_0865 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_16 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0863 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, x, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = _menhir_stack in - let (MenhirCell0_IN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_foreach_binder_ - (_menhir_stack, _, binders)) = - _menhir_stack - in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_else_block_, else_block = (_endpos, _v) in - let _v = - _menhir_action_070 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr x xs - in - _menhir_goto_foreach_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_else_block_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_foreach_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_041 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0865 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux_statement_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _, xs, _, _)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = _menhir_stack in - let (MenhirCell0_IN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_foreach_binder_ - (_menhir_stack, _, binders)) = - _menhir_stack - in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_else_block_, else_block = (_endpos, _v) in - let _v = - _menhir_action_069 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr xs - in - _menhir_goto_foreach_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_else_block_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0855 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_ELSE _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0856 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0856 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_ELSE (_menhir_stack, _menhir_s, _)) = - _menhir_stack - in - let _endpos__3_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_506 _endpos__3_ _startpos__1_inlined1_ x xs - in - _menhir_goto_optional_else _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0856 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0856 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0856 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0856 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0856 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0856 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0856 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0856 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0856 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0856 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0856 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_ELSE (_menhir_stack, _menhir_s, _)) = _menhir_stack in - let _endpos__3_, xs = (_endpos_15, _v) in - let _v = _menhir_action_505 _endpos__3_ _startpos__1_inlined1_ xs in - _menhir_goto_optional_else _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0851 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_GUARD, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_ELSE - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0852 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0852 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = - _menhir_stack - in - let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) - = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_080 _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ cond x xs - in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0852 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0852 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0852 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0852 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0852 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0852 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0852 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0852 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0852 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0852 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0852 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = - _menhir_stack - in - let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_079 _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ cond xs - in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_guard_statement : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_684 _1 in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0843 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0844 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0844 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) - = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_583 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ - ty_opt x xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0844 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0844 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0844 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0844 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0844 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0844 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0844 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0844 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0844 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0844 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0844 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_582 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ ty_opt - xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0834 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_15_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0835 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0835 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) - = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_580 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt x xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0835 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0835 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0835 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0835 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0835 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0835 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0835 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0835 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0835 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0835 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0835 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_15_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_579 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt xs - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0744 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0745 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0745 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_673 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ - _startpos__1_inlined4_ _startpos_name_ name ty_opt x xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0745 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0745 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0745 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0745 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0745 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0745 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0745 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0745 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0745 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0745 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0745 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_672 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ - _startpos__1_inlined4_ _startpos_name_ name ty_opt xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0735 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0736 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0736 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_670 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt x xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0736 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0736 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0736 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0736 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0736 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0736 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0736 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0736 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0736 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0736 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0736 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_669 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0649 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0650 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0650 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_679 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined3_ _startpos_name_ name ty_opt x xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0650 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0650 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0650 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0650 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0650 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0650 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0650 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0650 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0650 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0650 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0650 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_678 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined3_ _startpos_name_ name ty_opt xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0610 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN, - ttv_result ) - _menhir_cell1_option___anonymous_6_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0611 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0611 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, x, xs = (_endpos_4, _v_0, _v) in - let _v = - _menhir_action_676 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - _startpos_name_ name ty_opt x xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0611 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0611 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0611 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0611 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0611 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0611 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0611 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0611 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0611 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0611 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_statement_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0611 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_option___anonymous_6_ (_menhir_stack, _, ty_opt)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, xs = (_endpos_15, _v) in - let _v = - _menhir_action_675 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - _startpos_name_ name ty_opt xs - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0586 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos_x_, _startpos_x_, x = (_endpos, _startpos, _v) in - let _v = _menhir_action_436 x in - _menhir_goto_non_empty_list_semi_rev_aux_statement_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0732 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0733 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0733 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, _startpos__1_inlined3_, ty_opt = - (_endpos_2, _startpos, _v) - in - let _v = - _menhir_action_668 _endpos__3_ _endpos__3_inlined1_ _endpos_name_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined3_ - _startpos_name_ name ty_opt - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0733 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0733 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0733 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0733 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0733 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0733 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0733 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0733 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0733 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0733 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0733 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0752 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN -> _ -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__3_inlined1_ = (_endpos_0, _endpos) in - let _v = - _menhir_action_592 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0752 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0752 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0828 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN -> _ -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, MenhirState0829, _endpos_2) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0830 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v = _menhir_action_471 () in - _menhir_run_0831 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0830 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v -> - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0829 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0829 _menhir_initp - | Lex_menhir_token.LABEL _v -> - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0829 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__3_inlined1_ = (_endpos_5, _endpos_4) in - let _v = - _menhir_action_590 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0847 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0847 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0831 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0832 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0832 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, _startpos__1_inlined3_, ty_opt = - (_endpos_2, _startpos, _v) - in - let _v = - _menhir_action_578 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined2_ _startpos__1_inlined3_ ty_opt - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0832 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0832 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0832 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0832 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0832 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0832 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0832 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0832 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0832 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0832 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0832 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1376 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1376 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1890 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1892 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1906 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1906 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_776 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_6 _endpos_3 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1906 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1906 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1906 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1906 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1906 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1906 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1906 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1906 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1906 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1906 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1906 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_776 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _1_inlined1 - _endpos__4_ _endpos__1_inlined2_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_776 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_776 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1830 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1832 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1846 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1846 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_848 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _endpos_6 _endpos_3 _startpos _v - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1846 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1846 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1846 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1846 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1846 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1846 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1846 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1846 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1846 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1846 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1846 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_848 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined3_ _startpos__1_inlined3_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_848 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_848 _1_inlined2 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1773 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1775 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1789 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1789 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_872 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_6 _endpos_3 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1789 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1789 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1789 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1789 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1789 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1789 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1789 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1789 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1789 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1789 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1789 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_872 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _1_inlined1 - _endpos__4_ _endpos__1_inlined2_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_872 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_872 _1_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1632 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1634 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1648 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1648 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( _endpos__3_, - x, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_, - _1_inlined2 ) = - (_endpos, (), _endpos_6, _endpos_3, _startpos, _v) - in - let _v = - _menhir_action_800 _1_inlined2 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 - quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1648 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1648 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1648 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1648 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1648 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1648 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1648 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1648 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1648 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1648 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1648 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1575 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1577 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1591 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1591 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( _endpos__3_, - x, - _1_inlined1, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_ ) = - (_endpos, (), _v, _endpos_6, _endpos_3, _startpos) - in - let _v = - _menhir_action_824 _1_inlined1 _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 - quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1591 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1591 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1591 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1591 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1591 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1591 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1591 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1591 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1591 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1591 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1591 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1515 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1517 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1531 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1531 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( _endpos__3_, - x, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_, - _1_inlined2 ) = - (_endpos, (), _endpos_6, _endpos_3, _startpos, _v) - in - let _v = - _menhir_action_896 _1_inlined2 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 - quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1531 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1531 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1531 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1531 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1531 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1531 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1531 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1531 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1531 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1531 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1531 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1458 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1460 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1474 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1474 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( _endpos__3_, - x, - _1_inlined1, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_ ) = - (_endpos, (), _v, _endpos_6, _endpos_3, _startpos) - in - let _v = - _menhir_action_920 _1_inlined1 _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 - quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1474 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1474 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1474 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1474 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1474 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1474 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1474 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1474 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1474 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - MenhirState1474 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_3) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1474 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1340 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_LPAREN -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_499 _1_inlined1 in - _menhir_goto_option_parameters_ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0914 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0915 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_471 () in - _menhir_run_0916 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0915 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0916 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0917 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0917 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, _startpos__1_inlined3_, ty_opt = - (_endpos_2, _startpos, _v) - in - let _v = - _menhir_action_587 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined3_ - ty_opt - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0917 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0917 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0917 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0917 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0917 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0917 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0917 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0917 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0917 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0917 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0917 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0838 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0033 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0839 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_471 () in - _menhir_run_0840 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0839 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0840 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0841 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0841 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, ty_opt, _startpos__1_inlined4_ = - (_endpos_2, _v, _startpos) - in - let _v = - _menhir_action_581 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined2_ _startpos__1_inlined4_ - ty_opt - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0841 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0841 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0841 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0841 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0841 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0841 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0841 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0841 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0841 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0841 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_15_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0841 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0739 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0576 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0740 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_485 () in - _menhir_run_0741 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0740 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0741 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0742 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0742 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined3)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined2_, _)) - = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, ty_opt, _startpos__1_inlined4_ = - (_endpos_2, _v, _startpos) - in - let _v = - _menhir_action_671 _1_inlined3 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined2_ - _startpos__1_inlined4_ _startpos_name_ name ty_opt - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0742 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0742 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0742 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0742 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0742 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0742 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0742 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0742 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0742 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0742 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0742 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0644 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_parameter_ (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_0576 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0645 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_485 () in - _menhir_run_0646 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0645 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0646 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0647 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0647 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _startpos__1_inlined1_, _)) - = - _menhir_stack - in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_inlined1_, _startpos__1_inlined3_, ty_opt = - (_endpos_2, _startpos, _v) - in - let _v = - _menhir_action_677 _1_inlined2 _endpos__3_ _endpos__3_inlined1_ - _endpos_name_ _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined3_ _startpos_name_ name ty_opt - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0647 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0647 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0647 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0647 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0647 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0647 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0647 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0647 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0647 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0647 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option___anonymous_6_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0647 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0630 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_246 x in - _menhir_goto_non_empty_list_commas_rev_parameter_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0459 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos_label_, _startpos_label_, label = (_endpos, _startpos, _v) in - let _v = _menhir_action_018 _endpos_label_ _startpos_label_ label in - _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - - and _menhir_run_0165 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _endpos_label_, _startpos_label_, label - = - (_endpos_1, _startpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_004 _endpos__1_ _endpos_label_ _startpos__1_ - _startpos_label_ label - in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos_label_, _startpos_label_, label = - (_endpos, _startpos, _v) - in - let _v = _menhir_action_005 _endpos_label_ _startpos_label_ label in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0456 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> - let _tok = _menhir_lexer _menhir_lexbuf in - let x = () in - let _v = _menhir_action_024 x in - _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RPAREN -> - let _v = _menhir_action_023 () in - _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_constr_pat_arguments : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0463 -> - _menhir_run_0464 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0251 -> - _menhir_run_0460 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0464 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_constr_pat_argument - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, arg)) = - _menhir_stack - in - let rest = _v in - let _v = _menhir_action_025 arg rest in - _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - - and _menhir_run_0460 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LPAREN -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _, _)) = - _menhir_stack - in - let _endpos__3_, t = (_endpos, _v) in - let _v = _menhir_action_474 t in - _menhir_goto_option___anonymous_17_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option___anonymous_17_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0250 -> - _menhir_run_0465 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0277 -> - _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0256 -> - _menhir_run_0257 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0465 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_UIDENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_UIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_ps_, ps = (_endpos, _v) in - let _v = - _menhir_action_652 _endpos_name_ _endpos_ps_ _startpos_name_ name ps - in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ps_ _startpos_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0278 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty - _menhir_cell0_COLONCOLON - _menhir_cell0_UIDENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_UIDENT - ( _menhir_stack, - constr_name, - _startpos_constr_name_, - _endpos_constr_name_ )) = - _menhir_stack - in - let (MenhirCell0_COLONCOLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - type_name, - _startpos_type_name_, - _endpos_type_name_ )) = - _menhir_stack - in - let _endpos_ps_, ps = (_endpos, _v) in - let _v = - _menhir_action_654 _endpos_constr_name_ _endpos_ps_ _endpos_type_name_ - _startpos_constr_name_ _startpos_type_name_ constr_name ps type_name - in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_ps_ _startpos_type_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_or_pattern : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1224 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1228 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1216 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1220 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1208 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1212 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1171 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1131 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0482 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0532 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0487 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0248 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0454 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0261 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0441 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0263 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0432 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0415 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0413 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0409 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0407 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0403 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0401 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0397 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0395 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0391 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0389 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0385 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0383 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0379 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0377 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0373 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0371 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0366 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0364 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0360 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0358 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0347 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0345 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0341 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0339 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0335 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0333 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0329 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0327 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0323 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0321 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0317 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0315 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0311 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0308 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0306 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0302 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0300 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0294 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0292 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0288 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0267 -> - _menhir_run_0287 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0282 -> - _menhir_run_0283 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0287 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_528 _1 in - _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_pattern : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState1171 -> - _menhir_run_1172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1131 -> - _menhir_run_1133 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0532 -> - _menhir_run_0533 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1224 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1228 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1216 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1220 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1208 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1212 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0487 -> - _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0482 -> - _menhir_run_0483 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0248 -> - _menhir_run_0474 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0463 -> - _menhir_run_0458 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0251 -> - _menhir_run_0458 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0454 -> - _menhir_run_0455 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0261 -> - _menhir_run_0445 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0441 -> - _menhir_run_0433 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0432 -> - _menhir_run_0433 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0263 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0430 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0415 -> - _menhir_run_0416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0413 -> - _menhir_run_0414 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0409 -> - _menhir_run_0410 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0407 -> - _menhir_run_0408 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0403 -> - _menhir_run_0404 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0401 -> - _menhir_run_0402 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0397 -> - _menhir_run_0398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0395 -> - _menhir_run_0396 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0391 -> - _menhir_run_0392 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0389 -> - _menhir_run_0390 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0385 -> - _menhir_run_0386 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0383 -> - _menhir_run_0384 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0379 -> - _menhir_run_0380 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0377 -> - _menhir_run_0378 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0373 -> - _menhir_run_0374 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0371 -> - _menhir_run_0372 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0366 -> - _menhir_run_0367 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0364 -> - _menhir_run_0365 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0360 -> - _menhir_run_0361 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0358 -> - _menhir_run_0359 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0347 -> - _menhir_run_0348 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0345 -> - _menhir_run_0346 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0341 -> - _menhir_run_0342 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0339 -> - _menhir_run_0340 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0335 -> - _menhir_run_0336 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0333 -> - _menhir_run_0334 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0329 -> - _menhir_run_0330 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0327 -> - _menhir_run_0328 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0323 -> - _menhir_run_0324 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0321 -> - _menhir_run_0322 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0317 -> - _menhir_run_0318 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0315 -> - _menhir_run_0316 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0311 -> - _menhir_run_0312 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0308 -> - _menhir_run_0309 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0306 -> - _menhir_run_0307 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0302 -> - _menhir_run_0303 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0300 -> - _menhir_run_0301 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0294 -> - _menhir_run_0295 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0292 -> - _menhir_run_0293 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0288 -> - _menhir_run_0289 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0267 -> - _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1172 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1173 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1173 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState1173, _startpos_3, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.UIDENT _v_5 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1174 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.STRING _v_6 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1174 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1174 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1174 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1174 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState1174 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState1174 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState1174 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState1174 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1174 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState1174 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState1174 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState1174 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_491 () in - _menhir_run_1175 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_s = MenhirState1173 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1176 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_32 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState1173 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_33 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState1173 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_34 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState1173 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.LIDENT _v_35 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState1173 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.INTERP _v_36 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState1173 _menhir_initp - | Lex_menhir_token.INT _v_37 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState1173 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.FLOAT _v_38 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_38 - MenhirState1173 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1173 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_40, _startpos_39) - in - let _v = - _menhir_action_420 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ - xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_41 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_42 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.UIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState1179 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.STRING _v_44 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState1179 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_45 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState1179 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_46 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState1179 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_47 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState1179 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.LIDENT _v_48 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState1179 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.INTERP _v_49 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState1179 _menhir_initp - | Lex_menhir_token.INT _v_50 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState1179 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.FLOAT _v_51 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState1179 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1179 _menhir_initp - | Lex_menhir_token.CHAR _v_52 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState1179 _menhir_initp - | Lex_menhir_token.BYTES _v_53 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState1179 _menhir_initp - | Lex_menhir_token.BYTE _v_54 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1173, _startpos_41, _endpos_42) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState1179 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_42, _startpos_41) - in - let _v = - _menhir_action_416 _1 _endpos__1_inlined1_ - _startpos__1_inlined1_ xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_55 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState1173 _menhir_initp - | Lex_menhir_token.BYTES _v_56 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState1173 _menhir_initp - | Lex_menhir_token.BYTE _v_57 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_57 - MenhirState1173 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_58 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_59 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.UIDENT _v_60 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState1181 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.STRING _v_61 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState1181 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_62 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState1181 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_63 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState1181 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_64 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState1181 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.LIDENT _v_65 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState1181 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.INTERP _v_66 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState1181 _menhir_initp - | Lex_menhir_token.INT _v_67 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState1181 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.FLOAT _v_68 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState1181 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1181 _menhir_initp - | Lex_menhir_token.CHAR _v_69 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState1181 _menhir_initp - | Lex_menhir_token.BYTES _v_70 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState1181 _menhir_initp - | Lex_menhir_token.BYTE _v_71 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1173, _startpos_58, _endpos_59) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_71 MenhirState1181 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_59, _startpos_58) - in - let _v = - _menhir_action_414 _1 _endpos__1_inlined1_ - _startpos__1_inlined1_ xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1175 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_418 _1 _endpos_expr_ _startpos__1_inlined1_ expr xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0285 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_pattern -> _ -> _ -> _ -> ttv_result - = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, p, _startpos_p_, _)) - = - _menhir_stack - in - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = - _menhir_action_527 _endpos_name_ _startpos_name_ _startpos_p_ name p - in - _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_p_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1133 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1134 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1134 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState1134, _startpos_3, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.UIDENT _v_5 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1135 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.STRING _v_6 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1135 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1135 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1135 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1135 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState1135 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState1135 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState1135 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState1135 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1135 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState1135 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState1135 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState1135 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_491 () in - _menhir_run_1136 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_s = MenhirState1134 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1137 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_32 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState1134 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_33 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState1134 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_34 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState1134 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.LIDENT _v_35 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState1134 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.INTERP _v_36 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState1134 _menhir_initp - | Lex_menhir_token.INT _v_37 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState1134 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.FLOAT _v_38 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_38 - MenhirState1134 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1134 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_40, _startpos_39) - in - let _v = - _menhir_action_404 _1 _endpos__1_inlined1_ _startpos__1_inlined1_ - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_41 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_42 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.UIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState1140 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.STRING _v_44 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState1140 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_45 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState1140 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_46 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState1140 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_47 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState1140 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.LIDENT _v_48 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState1140 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.INTERP _v_49 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState1140 _menhir_initp - | Lex_menhir_token.INT _v_50 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState1140 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.FLOAT _v_51 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState1140 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1140 _menhir_initp - | Lex_menhir_token.CHAR _v_52 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState1140 _menhir_initp - | Lex_menhir_token.BYTES _v_53 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState1140 _menhir_initp - | Lex_menhir_token.BYTE _v_54 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1134, _startpos_41, _endpos_42) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState1140 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_42, _startpos_41) - in - let _v = - _menhir_action_400 _1 _endpos__1_inlined1_ - _startpos__1_inlined1_ - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_55 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState1134 _menhir_initp - | Lex_menhir_token.BYTES _v_56 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState1134 _menhir_initp - | Lex_menhir_token.BYTE _v_57 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_57 - MenhirState1134 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_58 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_59 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.UIDENT _v_60 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState1142 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.STRING _v_61 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState1142 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_62 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState1142 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_63 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState1142 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_64 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState1142 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.LIDENT _v_65 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState1142 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.INTERP _v_66 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState1142 _menhir_initp - | Lex_menhir_token.INT _v_67 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState1142 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.FLOAT _v_68 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState1142 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1142 _menhir_initp - | Lex_menhir_token.CHAR _v_69 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState1142 _menhir_initp - | Lex_menhir_token.BYTES _v_70 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState1142 _menhir_initp - | Lex_menhir_token.BYTE _v_71 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1134, _startpos_58, _endpos_59) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_71 MenhirState1142 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _1, _endpos__1_inlined1_, _startpos__1_inlined1_ = - (_v, _endpos_59, _startpos_58) - in - let _v = - _menhir_action_398 _1 _endpos__1_inlined1_ - _startpos__1_inlined1_ - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1136 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_402 _1 _endpos_expr_ _startpos__1_inlined1_ expr in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0533 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0534 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0534 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0534, _startpos_3, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.UIDENT _v_5 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0535 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.STRING _v_6 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0535 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0535 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0535 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0535 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0535 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0535 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0535 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0535 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0535 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0535 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0535 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState0535 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_491 () in - _menhir_run_0536 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_s = MenhirState0534 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0537 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_32 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0534 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_33 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0534 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_34 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0534 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.LIDENT _v_35 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0534 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.INTERP _v_36 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0534 _menhir_initp - | Lex_menhir_token.INT _v_37 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0534 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.FLOAT _v_38 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_38 - MenhirState0534 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0534 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pat = - (_endpos_40, _startpos_39, _v) - in - let _v = _menhir_action_388 _endpos__1_ _startpos__1_ pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_41 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_42 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.UIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0540 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.STRING _v_44 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0540 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_45 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0540 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_46 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0540 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_47 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0540 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.LIDENT _v_48 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0540 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.INTERP _v_49 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0540 _menhir_initp - | Lex_menhir_token.INT _v_50 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0540 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.FLOAT _v_51 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0540 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0540 _menhir_initp - | Lex_menhir_token.CHAR _v_52 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0540 _menhir_initp - | Lex_menhir_token.BYTES _v_53 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0540 _menhir_initp - | Lex_menhir_token.BYTE _v_54 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0534, _startpos_41, _endpos_42) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState0540 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pat = - (_endpos_42, _startpos_41, _v) - in - let _v = _menhir_action_384 _endpos__1_ _startpos__1_ pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_55 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0534 _menhir_initp - | Lex_menhir_token.BYTES _v_56 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0534 _menhir_initp - | Lex_menhir_token.BYTE _v_57 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_57 - MenhirState0534 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_58 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_59 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.UIDENT _v_60 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0542 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.STRING _v_61 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0542 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_62 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0542 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_63 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0542 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_64 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0542 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.LIDENT _v_65 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0542 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.INTERP _v_66 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0542 _menhir_initp - | Lex_menhir_token.INT _v_67 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0542 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.FLOAT _v_68 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0542 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0542 _menhir_initp - | Lex_menhir_token.CHAR _v_69 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0542 _menhir_initp - | Lex_menhir_token.BYTES _v_70 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0542 _menhir_initp - | Lex_menhir_token.BYTE _v_71 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0534, _startpos_58, _endpos_59) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_71 MenhirState0542 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pat = - (_endpos_59, _startpos_58, _v) - in - let _v = _menhir_action_382 _endpos__1_ _startpos__1_ pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0536 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_386 _endpos_expr_ _startpos__1_ expr pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0532 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0532 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0532 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0532 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.INT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0532 _menhir_initp - | Lex_menhir_token.FLOAT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0532 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0532 _menhir_initp - | Lex_menhir_token.CHAR _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0532 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_449 x xs in - _menhir_goto_non_empty_list_semis___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_448 xs in - _menhir_goto_non_empty_list_semis___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis___anonymous_8_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _1 = _v in - let _v = _menhir_action_663 _1 in - _menhir_goto_single_pattern_cases _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - - and _menhir_goto_single_pattern_cases : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState1228 -> - _menhir_run_1229 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState1224 -> - _menhir_run_1225 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1220 -> - _menhir_run_1221 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState1216 -> - _menhir_run_1217 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1212 -> - _menhir_run_1213 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState1208 -> - _menhir_run_1209 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState0487 -> - _menhir_run_0488 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1229 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _startpos__1_inlined2_)) = - _menhir_stack - in - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_single_pattern_cases (_menhir_stack, _, catch)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_CATCH (_menhir_stack, _startpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let _endpos__8_, try_else = (_endpos, _v) in - let _v = - _menhir_action_944 _endpos__1_ _endpos__2_inlined1_ _endpos__3_ - _endpos__8_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - body catch try_else - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_try_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_043 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1225 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _menhir_stack = - MenhirCell1_single_pattern_cases (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ELSE (_menhir_stack, _startpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1228 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1228 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1228 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1228 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1228 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1228 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1228 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1228 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_9 = _menhir_action_662 () in - _menhir_run_1229 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_CATCH (_menhir_stack, _startpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos__5_, catch = (_endpos, _v) in - let _v = - _menhir_action_941 _endpos__1_ _endpos__3_ _endpos__5_ _startpos__1_ - _startpos__1_inlined1_ body catch - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1221 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_ELSE (_menhir_stack, _startpos__1_inlined2_)) = - _menhir_stack - in - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_single_pattern_cases (_menhir_stack, _, catch)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_)) = _menhir_stack in - let (MenhirCell0_CATCH (_menhir_stack, _startpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let _endpos__8_, try_else = (_endpos, _v) in - let _v = - _menhir_action_942 _endpos__1_ _endpos__2_ _endpos__2_inlined1_ - _endpos__8_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - body catch try_else - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1217 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_CATCH - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _menhir_stack = - MenhirCell1_single_pattern_cases (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ELSE (_menhir_stack, _startpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1220 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1220 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1220 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1220 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1220 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1220 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1220 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1220 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_9 = _menhir_action_662 () in - _menhir_run_1221 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_)) = - _menhir_stack - in - let (MenhirCell0_CATCH (_menhir_stack, _startpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos__5_, catch = (_endpos, _v) in - let _v = - _menhir_action_939 _endpos__1_ _endpos__2_ _endpos__5_ _startpos__1_ - _startpos__1_inlined1_ body catch - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1213 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_single_pattern_cases - _menhir_cell0_RBRACE - _menhir_cell0_ELSE - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__2_)) = _menhir_stack in - let (MenhirCell0_ELSE (_menhir_stack, _startpos__1_inlined2_)) = - _menhir_stack - in - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_single_pattern_cases (_menhir_stack, _, catch)) = - _menhir_stack - in - let (MenhirCell0_LBRACE - (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let _endpos__8_, try_else = (_endpos, _v) in - let _v = - _menhir_action_943 _endpos__1_ _endpos__1_inlined1_ _endpos__2_ - _endpos__8_ _startpos__1_ _startpos__1_inlined1_ _startpos__1_inlined2_ - body catch try_else - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1209 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_TRY, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _menhir_stack = - MenhirCell1_single_pattern_cases (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ELSE (_menhir_stack, _startpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1212 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1212 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1212 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1212 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1212 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1212 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1212 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1212 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_9 = _menhir_action_662 () in - _menhir_run_1213 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACE - (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, body, _, _)) = _menhir_stack in - let (MenhirCell1_TRY - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos__5_, catch = (_endpos, _v) in - let _v = - _menhir_action_940 _endpos__1_ _endpos__1_inlined1_ _endpos__5_ - _startpos__1_ _startpos__1_inlined1_ body catch - in - _menhir_goto_try_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0488 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_GUARD, - ttv_result ) - _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_EQUAL, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_ELSE - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_ELSE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_infix_expr (_menhir_stack, _, expr, _, _)) = - _menhir_stack - in - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell1_LET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__9_, cases = (_endpos, _v) in - let _v = _menhir_action_082 _endpos__9_ _startpos__1_ cases expr pat in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__9_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0490 : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0491 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0491 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0491, _startpos_3, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.UIDENT _v_5 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0492 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.STRING _v_6 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0492 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_7 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0492 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_8 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0492 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_9 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0492 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0492 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.INTERP _v_11 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0492 _menhir_initp - | Lex_menhir_token.INT _v_12 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0492 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.FLOAT _v_13 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0492 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0492 _menhir_initp - | Lex_menhir_token.CHAR _v_14 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0492 _menhir_initp - | Lex_menhir_token.BYTES _v_15 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0492 _menhir_initp - | Lex_menhir_token.BYTE _v_16 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState0492 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_17 = _menhir_action_491 () in - _menhir_run_0493 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_17 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_s = MenhirState0491 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0495 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_32 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0491 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_33 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0491 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_34 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0491 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.LIDENT _v_35 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0491 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.INTERP _v_36 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0491 _menhir_initp - | Lex_menhir_token.INT _v_37 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0491 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.FLOAT _v_38 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_38 - MenhirState0491 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0491 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, pat = - (_endpos_40, _startpos_39, _v) - in - let _v = _menhir_action_372 _endpos__1_ _startpos__1_ pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_41 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_42 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.UIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0498 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.STRING _v_44 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0498 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_45 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0498 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_46 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0498 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_47 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0498 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.LIDENT _v_48 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0498 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.INTERP _v_49 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0498 _menhir_initp - | Lex_menhir_token.INT _v_50 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0498 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.FLOAT _v_51 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0498 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0498 _menhir_initp - | Lex_menhir_token.CHAR _v_52 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0498 _menhir_initp - | Lex_menhir_token.BYTES _v_53 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0498 _menhir_initp - | Lex_menhir_token.BYTE _v_54 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0491, _startpos_41, _endpos_42) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState0498 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, pat = - (_endpos_42, _startpos_41, _v) - in - let _v = _menhir_action_368 _endpos__1_ _startpos__1_ pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_55 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0491 _menhir_initp - | Lex_menhir_token.BYTES _v_56 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0491 _menhir_initp - | Lex_menhir_token.BYTE _v_57 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_57 - MenhirState0491 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_58 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_59 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.UIDENT _v_60 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0504 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.STRING _v_61 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0504 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_62 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0504 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_63 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0504 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_64 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0504 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.LIDENT _v_65 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0504 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.INTERP _v_66 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0504 _menhir_initp - | Lex_menhir_token.INT _v_67 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0504 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.FLOAT _v_68 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0504 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0504 _menhir_initp - | Lex_menhir_token.CHAR _v_69 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0504 _menhir_initp - | Lex_menhir_token.BYTES _v_70 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0504 _menhir_initp - | Lex_menhir_token.BYTE _v_71 -> - let _menhir_stack = - MenhirCell1_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0491, _startpos_58, _endpos_59) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_71 MenhirState0504 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, pat = - (_endpos_59, _startpos_58, _v) - in - let _v = _menhir_action_366 _endpos__1_ _startpos__1_ pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0493 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_370 _endpos_expr_ _startpos__1_ expr pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0483 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_GUARD, - ttv_result ) - _menhir_cell1_LET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0484 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0474 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LET as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0475 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0477 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0458 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let pat = _v in - let _v = _menhir_action_020 pat in - _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0455 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_EQUAL - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) - = - _menhir_stack - in - let pat = _v in - let _v = _menhir_action_017 _endpos_name_ _startpos_name_ name pat in - _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0445 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _2, _endpos__3_ = (_v, _endpos_0) in - let _v = _menhir_action_655 _2 in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.COMMA -> ( - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0447 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0450 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0433 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_pattern_ - _menhir_cell0_COMMA - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.FAT_ARROW - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_249 x xs in - _menhir_goto_non_empty_list_commas_rev_pattern_ _menhir_stack - _menhir_lexbuf _menhir_lexer _startpos_xs_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_rev_pattern_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0263 -> - _menhir_run_0440 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState1052 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0438 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0429 -> - _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0440 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0441 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0441 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0441 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0441 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.INT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0441 _menhir_initp - | Lex_menhir_token.FLOAT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0441 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0441 _menhir_initp - | Lex_menhir_token.CHAR _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0441 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let x, _startpos_xs_, xs = ((), _startpos, _v) in - let _v = _menhir_action_150 x xs in - _menhir_goto_non_empty_list_commas_pattern_ _menhir_stack - _menhir_lexbuf _menhir_lexer _startpos_xs_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let xs = _v in - let _v = _menhir_action_261 xs in - let _menhir_stack = - MenhirCell1_non_empty_list_commas_with_tail_pattern_ - (_menhir_stack, _menhir_s, _v) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - _menhir_run_0426 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0436 _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> - let _v_0 = _menhir_action_475 () in - _menhir_run_0437 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0436 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let _startpos_xs_, xs = (_startpos, _v) in - let _v = _menhir_action_149 xs in - _menhir_goto_non_empty_list_commas_pattern_ _menhir_stack _menhir_lexbuf - _menhir_lexer _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_pattern_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1052 -> - _menhir_run_1093 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState1057 -> - _menhir_run_1058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0847 -> - _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0752 -> - _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0757 -> - _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0748 -> - _menhir_run_0694 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0653 -> - _menhir_run_0694 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0658 -> - _menhir_run_0659 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v - _menhir_s _tok _menhir_initp - | MenhirState0447 -> - _menhir_run_0448 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0263 -> - _menhir_run_0442 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0438 -> - _menhir_run_0439 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0429 -> - _menhir_run_0434 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1093 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1094 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1094 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState1094, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1095 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1095 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1095 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1095 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1095 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1095 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState1095 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState1095 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState1095 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1095 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState1095 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState1095 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState1095 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_1096 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1094 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1097 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState1094 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState1094 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState1094 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState1094 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState1094 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState1094 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState1094 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1094 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, pats = - (_endpos_39, _startpos_38, _v) - in - let _v = _menhir_action_276 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState1100 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState1100 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState1100 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState1100 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState1100 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState1100 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState1100 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState1100 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState1100 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1100 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState1100 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState1100 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1094, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState1100 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, pats = - (_endpos_41, _startpos_40, _v) - in - let _v = _menhir_action_272 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState1094 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState1094 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState1094 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState1102 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState1102 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState1102 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState1102 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState1102 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState1102 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState1102 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState1102 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState1102 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1102 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState1102 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState1102 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1094, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState1102 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, pats = - (_endpos_58, _startpos_57, _v) - in - let _v = _menhir_action_270 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1096 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_274 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1057 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1057 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1057 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1057 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.INT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1057 _menhir_initp - | Lex_menhir_token.FLOAT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1057 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1057 _menhir_initp - | Lex_menhir_token.CHAR _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1057 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_443 x xs in - _menhir_goto_non_empty_list_semis___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_442 xs in - _menhir_goto_non_empty_list_semis___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis___anonymous_10_ : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _, args, _)) = - _menhir_stack - in - let (MenhirCell1_LOOP (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_117 _1_inlined1 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ args - in - _menhir_goto_loop_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_loop_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_039 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1058 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1059 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1059 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState1059, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1060 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1060 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1060 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1060 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1060 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1060 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState1060 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState1060 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState1060 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1060 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState1060 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState1060 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState1060 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_1061 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1059 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1062 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState1059 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState1059 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState1059 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState1059 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState1059 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState1059 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState1059 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1059 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_39, _startpos_38, _v) - in - let _v = _menhir_action_292 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState1065 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState1065 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState1065 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState1065 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState1065 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState1065 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState1065 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState1065 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState1065 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1065 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState1065 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState1065 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState1059, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState1065 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_41, _startpos_40, _v) - in - let _v = _menhir_action_288 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState1059 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState1059 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState1059 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState1067 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState1067 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState1067 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState1067 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState1067 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState1067 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState1067 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState1067 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState1067 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1067 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState1067 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState1067 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState1059, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState1067 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_58, _startpos_57, _v) - in - let _v = _menhir_action_286 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1061 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_290 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0793 : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0794 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0794 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0794, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0795 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0795 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0795 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0795 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0795 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0795 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0795 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0795 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0795 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0795 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0795 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0795 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0795 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_0796 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0794 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0797 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState0794 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0794 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0794 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0794 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0794 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0794 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0794 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0794 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_39, _startpos_38, _startpos, _v) - in - let _v = _menhir_action_308 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0800 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0800 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0800 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0800 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0800 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0800 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0800 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0800 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0800 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0800 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0800 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0800 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0794, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0800 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_41, _startpos_40, _startpos, _v) - in - let _v = _menhir_action_304 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState0794 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0794 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0794 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState0802 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0802 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0802 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0802 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0802 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0802 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0802 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0802 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0802 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0802 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0802 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0802 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0794, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0802 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_58, _startpos_57, _startpos, _v) - in - let _v = _menhir_action_302 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0796 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_306 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_pats_ _v _menhir_s - _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0757 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0757 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0757 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0757 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0757 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0757 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0757 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0757 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_x_, x, _startpos_xs_, xs = - (_endpos_1, _v_0, _startpos, _v) - in - let _v = _menhir_action_445 x xs in - _menhir_goto_non_empty_list_semis___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_xs_, _startpos_xs_, xs = (_endpos, _startpos, _v) in - let _v = _menhir_action_444 xs in - _menhir_goto_non_empty_list_semis___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis___anonymous_16_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _menhir_initp -> - match _menhir_s with - | MenhirState0847 -> - _menhir_run_0849 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_initp - | MenhirState0752 -> - _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0849 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v - _menhir_initp -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2 = - (_endpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_591 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ - _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined2_ - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0754 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v - _menhir_initp -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1 = - (_endpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_593 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ - _endpos__3_inlined1_ _startpos__1_ _startpos__1_inlined1_ - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0758 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0759 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0759 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0759, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0760 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0760 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0760 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0760 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0760 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0760 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0760 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0760 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0760 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0760 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0760 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0760 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0760 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_0761 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0759 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0762 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState0759 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0759 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0759 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0759 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0759 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0759 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0759 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0759 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_39, _startpos_38, _v) - in - let _v = _menhir_action_324 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0765 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0765 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0765 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0765 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0765 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0765 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0765 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0765 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0765 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0765 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0765 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0765 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0759, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0765 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_41, _startpos_40, _v) - in - let _v = _menhir_action_320 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState0759 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0759 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0759 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState0767 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0767 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0767 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0767 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0767 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0767 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0767 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0767 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0767 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0767 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0767 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0767 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0759, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0767 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_58, _startpos_57, _v) - in - let _v = _menhir_action_318 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0761 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_322 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0694 : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0695 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0695 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0695, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0696 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0696 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0696 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0696 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0696 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0696 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0696 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0696 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0696 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0696 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0696 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0696 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0696 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_0697 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0695 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0698 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState0695 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0695 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0695 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0695 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0695 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0695 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0695 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0695 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_39, _startpos_38, _startpos, _v) - in - let _v = _menhir_action_340 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0701 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0701 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0701 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0701 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0701 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0701 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0701 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0701 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0701 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0701 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0701 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0701 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0695, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0701 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_41, _startpos_40, _startpos, _v) - in - let _v = _menhir_action_336 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState0695 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0695 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0695 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState0703 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0703 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0703 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0703 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0703 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0703 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0703 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0703 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0703 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0703 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0703 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0703 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0695, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0703 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _startpos_pats_, pats = - (_endpos_58, _startpos_57, _startpos, _v) - in - let _v = _menhir_action_334 _endpos__1_ _startpos__1_ pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_pats_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0697 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_338 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_pats_ _v _menhir_s - _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0658 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0658 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0658 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0658 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0658 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0658 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0658 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0658 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_x_, x, _startpos_xs_, xs = - (_endpos_1, _v_0, _startpos, _v) - in - let _v = _menhir_action_447 x xs in - _menhir_goto_non_empty_list_semis___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _endpos_xs_, _startpos_xs_, xs = (_endpos, _startpos, _v) in - let _v = _menhir_action_446 xs in - _menhir_goto_non_empty_list_semis___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis___anonymous_7_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _menhir_initp -> - match _menhir_s with - | MenhirState0748 -> - _menhir_run_0750 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_initp - | MenhirState0653 -> - _menhir_run_0655 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0750 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v - _menhir_initp -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__4_)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2 = - (_endpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_681 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _startpos__1_ _startpos__1_inlined2_ - _startpos_name_ name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0655 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_FN _menhir_cell0_LIDENT - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v - _menhir_initp -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__4_)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__3_, _endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1 = - (_endpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_683 _1_inlined1 _endpos__1_inlined1_ _endpos__3_ - _endpos__4_ _endpos_name_ _startpos__1_ _startpos__1_inlined1_ - _startpos_name_ name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0659 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FAT_ARROW -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0660 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0660 _menhir_initp - | Lex_menhir_token.RETURN -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RETURN - (_menhir_stack, MenhirState0660, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0661 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.STRING _v_5 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0661 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0661 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0661 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0661 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0661 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0661 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0661 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0661 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0661 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0661 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0661 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0661 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_16 = _menhir_action_491 () in - _menhir_run_0662 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_16 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0660 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0663 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_31 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - MenhirState0660 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_32 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - MenhirState0660 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_33 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - MenhirState0660 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.LIDENT _v_34 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - MenhirState0660 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.INTERP _v_35 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_35 - MenhirState0660 _menhir_initp - | Lex_menhir_token.INT _v_36 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_36 - MenhirState0660 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.FLOAT _v_37 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_37 - MenhirState0660 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0660 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_39, _startpos_38, _v) - in - let _v = _menhir_action_356 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.CONTINUE -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0666 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0666 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_44 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_44 MenhirState0666 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_45 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0666 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_46 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0666 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.LIDENT _v_47 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0666 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.INTERP _v_48 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0666 _menhir_initp - | Lex_menhir_token.INT _v_49 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0666 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.FLOAT _v_50 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0666 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0666 _menhir_initp - | Lex_menhir_token.CHAR _v_51 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0666 _menhir_initp - | Lex_menhir_token.BYTES _v_52 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0666 _menhir_initp - | Lex_menhir_token.BYTE _v_53 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_CONTINUE - (_menhir_stack, MenhirState0660, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0666 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_41, _startpos_40, _v) - in - let _v = _menhir_action_352 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_54 - MenhirState0660 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_55 - MenhirState0660 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_56 - MenhirState0660 _menhir_initp - | Lex_menhir_token.BREAK -> ( - let _startpos_57 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_58 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.UIDENT _v_59 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_59 MenhirState0668 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.STRING _v_60 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_60 MenhirState0668 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_61 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_61 MenhirState0668 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_62 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_62 MenhirState0668 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_63 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_63 MenhirState0668 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.LIDENT _v_64 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_64 MenhirState0668 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.INTERP _v_65 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_65 MenhirState0668 _menhir_initp - | Lex_menhir_token.INT _v_66 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_66 MenhirState0668 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.FLOAT _v_67 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_67 MenhirState0668 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0668 _menhir_initp - | Lex_menhir_token.CHAR _v_68 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_68 MenhirState0668 _menhir_initp - | Lex_menhir_token.BYTES _v_69 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_69 MenhirState0668 _menhir_initp - | Lex_menhir_token.BYTE _v_70 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_FAT_ARROW (_menhir_stack, _endpos) - in - let _menhir_stack = - MenhirCell1_BREAK - (_menhir_stack, MenhirState0660, _startpos_57, _endpos_58) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_70 MenhirState0668 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _startpos__1_, pats = - (_endpos_58, _startpos_57, _v) - in - let _v = _menhir_action_350 _endpos__1_ _startpos__1_ pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0662 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_354 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0448 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, p, _, _)) = _menhir_stack in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let ps, _endpos__5_ = (_v, _endpos) in - let _v = _menhir_action_656 _endpos__5_ _startpos__1_ p ps in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0442 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let ps = _v in - let _v = _menhir_action_012 ps in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf _menhir_lexer - _v _tok _menhir_initp - - and _menhir_run_0439 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_non_empty_list_commas_with_tail_pattern_ - _menhir_cell0_DOTDOT, - ttv_result ) - _menhir_cell1_option___anonymous_18_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_option___anonymous_18_ (_menhir_stack, _, b)) = - _menhir_stack - in - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_with_tail_pattern_ - (_menhir_stack, _, ps1)) = - _menhir_stack - in - let ps2 = _v in - let _v = _menhir_action_016 b ps1 ps2 in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf _menhir_lexer - _v _tok _menhir_initp - - and _menhir_run_0434 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_DOTDOT, - ttv_result ) - _menhir_cell1_option___anonymous_18_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_option___anonymous_18_ (_menhir_stack, _, b)) = - _menhir_stack - in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let ps = _v in - let _v = _menhir_action_013 b ps in - _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf _menhir_lexer - _v _tok _menhir_initp - - and _menhir_run_0431 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0432 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0432 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0432 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0432 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.INT _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0432 _menhir_initp - | Lex_menhir_token.FLOAT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0432 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0432 _menhir_initp - | Lex_menhir_token.CHAR _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_pattern_ - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0432 _menhir_initp - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN -> - let x, _startpos_xs_, xs = ((), _startpos, _v) in - let _v = _menhir_action_150 x xs in - _menhir_goto_non_empty_list_commas_pattern_ _menhir_stack - _menhir_lexbuf _menhir_lexer _startpos_xs_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN -> - let _startpos_xs_, xs = (_startpos, _v) in - let _v = _menhir_action_149 xs in - _menhir_goto_non_empty_list_commas_pattern_ _menhir_stack _menhir_lexbuf - _menhir_lexer _startpos_xs_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0430 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.FAT_ARROW - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _startpos_x_, x = (_startpos, _v) in - let _v = _menhir_action_248 x in - _menhir_goto_non_empty_list_commas_rev_pattern_ _menhir_stack - _menhir_lexbuf _menhir_lexer _startpos_x_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0416 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_BYTE (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_210 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TRUE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_TRUE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0358 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0360 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.STRING _v_19 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_19 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0364 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0366 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.MINUS -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_MINUS (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0371 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0373 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FLOAT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0377 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0379 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.INT _v_82 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_82 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0383 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0385 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v_102 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_102 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FLOAT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0389 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0391 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FALSE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FALSE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0395 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0397 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_141 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_141 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_CHAR (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0401 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0403 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTES _v_161 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_161 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BYTES (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0407 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0409 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTE _v_181 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_181 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BYTE (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0413 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0415 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let x, xs = ((), _v) in - let _v = _menhir_action_144 x xs in - _menhir_goto_non_empty_list_commas_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_143 xs in - _menhir_goto_non_empty_list_commas_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _menhir_fail () - - and _menhir_goto_non_empty_list_commas_map_elem_pat_ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _1 = _v in - let _v = _menhir_action_462 _1 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, elems = (_endpos, _v) in - let _v = _menhir_action_661 _endpos__3_ _startpos__1_ elems in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0414 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_BYTE (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_211 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0410 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_BYTES (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_212 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0408 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_BYTES (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_213 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0404 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_CHAR (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_214 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0402 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_CHAR (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_215 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0398 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FALSE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_208 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0396 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_FALSE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_209 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0392 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FLOAT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_218 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0390 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_FLOAT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_219 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0386 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_INT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_216 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0384 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_217 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0380 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FLOAT - (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_224 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0378 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_FLOAT - (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_225 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0374 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_INT - (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_222 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0372 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_INT - (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_223 _2_inlined1 _endpos__2_inlined1_ _endpos_pat_ - _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0367 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_STRING - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_220 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0365 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_STRING - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_221 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0361 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_TRUE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_206 _endpos__1_ _endpos_pat_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0359 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_TRUE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_207 _endpos__1_ _endpos_pat_ _startpos__1_ pat x xs - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0348 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_BYTE - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_190 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0346 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_BYTE - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_191 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0342 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTES - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_BYTES - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_192 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0340 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTES - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_BYTES - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_193 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0336 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_CHAR - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_CHAR - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_194 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0334 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_CHAR - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_CHAR - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_195 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0330 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FALSE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_FALSE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_188 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0328 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FALSE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_FALSE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_189 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0324 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FLOAT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_FLOAT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_198 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0322 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_FLOAT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_199 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0318 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_INT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_INT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_196 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0316 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_INT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_197 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0312 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) - = - _menhir_stack - in - let _endpos_p_, p = (_endpos, _v) in - let _v = - _menhir_action_052 _endpos_name_ _endpos_p_ _startpos_name_ name p - in - _menhir_goto_fields_pat_single _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0309 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FLOAT (_menhir_stack, _2, _, _endpos__2_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_204 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0307 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_FLOAT (_menhir_stack, _2, _, _endpos__2_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_205 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0303 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS - _menhir_cell0_INT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _2, _, _endpos__2_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_202 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0301 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS - _menhir_cell0_INT - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _2, _, _endpos__2_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_203 _2 _endpos__2_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0295 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_STRING - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_STRING - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_200 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0293 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_STRING - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_STRING - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_201 _1 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0289 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_TRUE - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_TRUE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_pat_, pat = (_endpos, _v) in - let _v = - _menhir_action_186 _endpos__1_ _endpos_pat_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0284 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_TRUE - _menhir_cell0_QUESTION - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> - let _menhir_stack = - MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0285 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_TRUE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let x, _endpos_pat_, pat = ((), _endpos, _v) in - let _v = - _menhir_action_187 _endpos__1_ _endpos_pat_ _startpos__1_ pat x - in - _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0283 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_range_pattern _menhir_cell0_BAR -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_BAR (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_range_pattern - (_menhir_stack, _menhir_s, pat1, _startpos_pat1_, _)) = - _menhir_stack - in - let _endpos_pat2_, pat2 = (_endpos, _v) in - let _v = _menhir_action_511 _endpos_pat2_ _startpos_pat1_ pat1 pat2 in - _menhir_goto_or_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_pat2_ _startpos_pat1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0274 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_pattern - _menhir_cell0_RANGE_INCLUSIVE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_pattern - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = _menhir_action_547 _endpos_rhs_ _startpos_lhs_ lhs rhs in - _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0272 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> ( - let _menhir_stack = - MenhirCell1_simple_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0273 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RANGE_EXCLUSIVE -> ( - let _menhir_stack = - MenhirCell1_simple_pattern - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0279 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EQUAL - | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_548 _1 in - _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis___anonymous_9_ : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, e, _, _)) = _menhir_stack in - let (MenhirCell1_MATCH (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, mat = (_endpos, _v) in - let _v = - _menhir_action_120 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ e mat - in - _menhir_goto_match_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_match_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_045 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1141 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos__1_inlined2_, _1_inlined2 = (_endpos, _v) in - let _v = - _menhir_action_401 _1 _1_inlined2 _endpos__1_inlined2_ - _startpos__1_inlined1_ - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1101 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_273 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1066 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_289 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1051 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LOOP as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1052 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1052 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LOOP (_menhir_stack, _menhir_s, _startpos__1_, _)) - = - _menhir_stack - in - let _endpos__3_, _endpos__3_inlined1_, args = - (_endpos_3, _endpos_0, _v) - in - let _v = - _menhir_action_116 _endpos__3_ _endpos__3_inlined1_ _startpos__1_ - args - in - _menhir_goto_loop_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1052 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1052 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1052 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1052 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1052 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_no_trailing_expr_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1052 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0801 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_305 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_inlined1_ _startpos_pats_ _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0766 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_321 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_inlined1_ _startpos_xs_ _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0702 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_337 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_inlined1_ _startpos_pats_ _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0667 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_353 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_inlined1_ _startpos_xs_ _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0583 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_688 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_inlined1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0541 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_385 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pat xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0502 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_CONTINUE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_CONTINUE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_369 _1_inlined1 _endpos__1_inlined1_ _startpos__1_ pat - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1207 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_TRY as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1208 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1208 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1208 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1208 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.INT _v_6 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1208 _menhir_initp - | Lex_menhir_token.FLOAT _v_7 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1208 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1208 _menhir_initp - | Lex_menhir_token.CHAR _v_8 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1208 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_9 = _menhir_action_662 () in - _menhir_run_1209 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1208 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CATCH -> ( - let _startpos_10 = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_CATCH (_menhir_stack, _startpos_10) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_11 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_12 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_11, _endpos_12) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.UIDENT _v_13 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState1216 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.STRING _v_14 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState1216 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_15 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState1216 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.LIDENT _v_16 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState1216 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.INT _v_17 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_17 MenhirState1216 _menhir_initp - | Lex_menhir_token.FLOAT _v_18 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_18 MenhirState1216 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1216 _menhir_initp - | Lex_menhir_token.CHAR _v_19 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_19 MenhirState1216 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_20 = _menhir_action_662 () in - _menhir_run_1217 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_20 MenhirState1216 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos_21, _endpos_22) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_23 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_24 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_23, _endpos_24) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.UIDENT _v_25 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState1224 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.STRING _v_26 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState1224 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_27 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_27 MenhirState1224 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.LIDENT _v_28 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_28 MenhirState1224 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.INT _v_29 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_29 MenhirState1224 _menhir_initp - | Lex_menhir_token.FLOAT _v_30 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_30 MenhirState1224 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1224 _menhir_initp - | Lex_menhir_token.CHAR _v_31 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_31 MenhirState1224 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_32 = _menhir_action_662 () in - _menhir_run_1225 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_32 MenhirState1224 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1206 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1_inlined1 = _v in - let _v = _menhir_action_429 _1 _1_inlined1 xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1205 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_421 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ e name xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1203 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_425 _1 _endpos_e_ _endpos_name_ _startpos_name_ e name xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1200 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_423 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_index_ _startpos__1_inlined1_ _startpos_index_ _startpos_record_ - e index record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1198 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_427 _1 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1195 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_422 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ _startpos_record_ e - name record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1193 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_426 _1 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1190 : - type ttv_stack ttv_result. - ( ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_424 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _startpos__1_inlined1_ _startpos_obj_ e ind obj xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1188 : - type ttv_stack ttv_result. - ( ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_428 _1 _endpos_e_ _startpos_obj_ e ind obj xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1185 : - type ttv_stack ttv_result. - (( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1187 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1189 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0183 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_expr (_menhir_stack, _, x, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let _endpos__6_ = _endpos_0 in - let _v = - _menhir_action_620 _endpos__6_ _startpos__2_ _startpos_array_ array x - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0183 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0183 _menhir_initp - | _ -> _eRR () - - and _menhir_run_1182 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_415 _1 _endpos_x_ _startpos__1_inlined1_ x xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1177 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_9_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, _1, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_9_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_419 _1 _endpos_expr_ _startpos__1_inlined1_ expr xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1167 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _1_inlined1 = _v in - let _v = _menhir_action_413 _1 _1_inlined1 in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1166 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_405 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ e name - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1164 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_409 _1 _endpos_e_ _endpos_name_ _startpos_name_ e name - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1161 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_407 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_index_ _startpos__1_inlined1_ _startpos_index_ _startpos_record_ - e index record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1159 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_411 _1 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1156 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_406 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _endpos_name_ _startpos__1_inlined1_ _startpos_name_ _startpos_record_ e - name record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1154 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_410 _1 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1151 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - ( _menhir_stack, - _1_inlined1, - _startpos__1_inlined1_, - _endpos__1_inlined1_ )) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_408 _1 _1_inlined1 _endpos__1_inlined1_ _endpos_e_ - _startpos__1_inlined1_ _startpos_obj_ e ind obj - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1149 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_412 _1 _endpos_e_ _startpos_obj_ e ind obj in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1146 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1148 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1150 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1143 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_399 _1 _endpos_x_ _startpos__1_inlined1_ x in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1138 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, _1, _, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_403 _1 _endpos_expr_ _startpos__1_inlined1_ expr in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_9_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1127 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _1 = _v in - let _v = _menhir_action_285 _1 pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1126 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_277 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1124 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_281 _endpos_e_ _endpos_name_ _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1121 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_279 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1119 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_283 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1116 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_278 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1114 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_282 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1111 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_280 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1109 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_284 _endpos_e_ _startpos_obj_ e ind obj pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1106 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1108 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1110 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1103 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_271 _endpos_x_ _startpos__1_ pats x in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1098 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_275 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1092 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1 = _v in - let _v = _menhir_action_301 _1 pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1091 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_293 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1089 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_297 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1086 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_295 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1084 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_299 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1081 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_294 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1079 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_298 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1076 : - type ttv_stack ttv_result. - ( ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_296 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1074 : - type ttv_stack ttv_result. - ( ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_300 _endpos_e_ _startpos_obj_ e ind obj pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1071 : - type ttv_stack ttv_result. - (( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1073 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1075 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1068 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_287 _endpos_x_ _startpos__1_ pats x xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1063 : - type ttv_stack ttv_result. - ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_10_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_291 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_10_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1050 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let expr = _v in - let _v = _menhir_action_252 expr in - _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1044 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1044 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1044 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1044 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1044 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1044 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1044 _menhir_initp - | Lex_menhir_token.INT _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1044 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.FLOAT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1044 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1044 _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1044 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1045 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_22 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_22 - MenhirState1044 _menhir_initp - | Lex_menhir_token.BYTES _v_23 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_23 - MenhirState1044 _menhir_initp - | Lex_menhir_token.BYTE _v_24 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_24 - MenhirState1044 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let x, xs = ((), _v) in - let _v = _menhir_action_154 x xs in - _menhir_goto_non_empty_list_commas_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let xs = _v in - let _v = _menhir_action_153 xs in - _menhir_goto_non_empty_list_commas_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_spreadable_elem_ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_641 _1_inlined1 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1047 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let expr = _v in - let _v = _menhir_action_254 expr xs in - _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1046 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_spreadable_elem_ - _menhir_cell0_COMMA, - ttv_result ) - _menhir_cell1_DOTDOT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_DOTDOT (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_spreadable_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_255 _endpos_expr_ _startpos__1_ expr xs in - _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1042 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACKET, - ttv_result ) - _menhir_cell1_DOTDOT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_253 _endpos_expr_ _startpos__1_ expr in - _menhir_goto_non_empty_list_commas_rev_spreadable_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1038 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_BYTE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_BYTE (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_238 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TRUE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_TRUE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1009 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.STRING _v_14 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1012 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.MINUS -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_MINUS (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1016 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FLOAT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1019 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.INT _v_62 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_62 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1022 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FLOAT _v_77 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_77 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FLOAT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1025 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FALSE -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_FALSE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1028 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CHAR _v_106 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_106 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_CHAR (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1031 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTES _v_121 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_121 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BYTES (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1034 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.BYTE _v_136 -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v = _v_136 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BYTE (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1037 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let x, xs = ((), _v) in - let _v = _menhir_action_146 x xs in - _menhir_goto_non_empty_list_commas_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_145 xs in - _menhir_goto_non_empty_list_commas_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_map_expr_elem_ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_577 _1_inlined1 _endpos__3_ _startpos__1_ in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1035 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_BYTES - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_BYTES (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_239 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1032 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_CHAR - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_CHAR (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_240 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1029 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_FALSE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FALSE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_237 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1026 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_FLOAT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FLOAT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_242 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1023 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_INT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_241 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1020 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_FLOAT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_FLOAT - (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = _menhir_stack in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_245 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1017 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_MINUS - _menhir_cell0_INT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_INT (_menhir_stack, _2_inlined1, _, _endpos__2_inlined1_)) - = - _menhir_stack - in - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _)) = _menhir_stack in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_244 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1013 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_STRING - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_243 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1010 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_map_expr_elem_ - _menhir_cell0_COMMA - _menhir_cell0_TRUE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_TRUE (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_map_expr_elem_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_236 _endpos__1_ _endpos_expr_ _startpos__1_ expr xs - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0999 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_BYTE - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_228 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0996 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_BYTES - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_BYTES - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_229 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0993 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_CHAR - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_CHAR - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_230 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0985 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_DOTDOT - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__2_, _)) = - _menhir_stack - in - _menhir_act_goto_568 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _startpos__2_ _endpos_0 _v - | Lex_menhir_token.COMMA -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LBRACE - (_menhir_stack, _menhir_s, _startpos__2_, _)) = - _menhir_stack - in - _menhir_act_goto_570 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _startpos__2_ _endpos_2 _v - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_1) in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0987 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_568 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _startpos__2_ _endpos__5_ oe -> - match _menhir_s with - | MenhirState1173 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_1183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_1144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_1104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_1069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0769 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0705 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0670 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0544 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0506 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - let _endpos__0_ = _menhir_initp in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - let (MenhirCell1_WHILE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - let (MenhirCell1_LOOP (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - let (MenhirCell1_COLON (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - let (MenhirCell0_AMPERAMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - let (MenhirCell0_BARBAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - let (MenhirCell0_BAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - let (MenhirCell0_AMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - let (MenhirCell0_CARET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - let (MenhirCell0_INFIX1 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - let (MenhirCell0_INFIX2 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - let (MenhirCell0_MINUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - let (MenhirCell0_INFIX3 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - let (MenhirCell0_INFIX4 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - let (MenhirCell0_PLUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_568 _endpos__0_ _endpos__5_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1144 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_MATCH, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1145 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1153 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1155 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1158 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1160 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0172 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _endpos__5_ = _endpos_0 in - let _v = _menhir_action_611 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0172 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0172 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0088 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0018 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0090 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let _endpos__2_, _startpos__2_, _endpos_id_, _startpos_id_, id = - (_endpos_1, _startpos_0, _endpos, _startpos, _v) - in - let _v = - _menhir_action_008 _endpos__2_ _endpos_id_ _startpos__2_ - _startpos_id_ id - in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0160 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.COMMA | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RPAREN -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_541 i in - _menhir_goto_qual_ident_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0177 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACKET (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let _endpos__6_ = _endpos_0 in - let _v = - _menhir_action_618 _endpos__6_ _startpos__2_ _startpos_array_ array - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0177 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0177 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0187 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _endpos__5_ = _endpos_2 in - let _v = _menhir_action_613 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0188 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0188 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0193 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _endpos__6_ = _endpos_2 in - let _v = - _menhir_action_626 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0194 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0194 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0198 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _endpos__6_ = _endpos_0 in - let _v = - _menhir_action_622 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0198 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0198 _menhir_initp - | _ -> _eRR () - - and _menhir_run_0202 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.UIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.STRING _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _endpos__6_ = _endpos_2 in - let _v = - _menhir_action_624 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.LIDENT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.LABEL _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.INTERP _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.INT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.FLOAT _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0203 _menhir_initp - | Lex_menhir_token.CHAR _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.BYTES _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | Lex_menhir_token.BYTE _v -> - let _menhir_stack = - MenhirCell0_EXCLAMATION (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - MenhirState0203 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0208 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.UIDENT _v_6 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_6 MenhirState0211 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.STRING _v_7 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_7 MenhirState0211 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) - = - _menhir_stack - in - let _endpos_meth_, _startpos_meth_, meth, _endpos__7_ = - (_endpos_1, _startpos_0, _v, _endpos_8) - in - let _v = - _menhir_action_632 _endpos__7_ _endpos_meth_ - _startpos_meth_ _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__7_ _startpos_self_ _v _menhir_s - _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v_9 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_9 MenhirState0211 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_10 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0211 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_11 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0211 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_12 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0211 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.LIDENT _v_13 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0211 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.LABEL _v_14 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0211 _menhir_initp - | Lex_menhir_token.INTERP _v_15 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0211 _menhir_initp - | Lex_menhir_token.INT _v_16 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState0211 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.FLOAT _v_17 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_17 MenhirState0211 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0211 _menhir_initp - | Lex_menhir_token.CHAR _v_18 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_18 MenhirState0211 _menhir_initp - | Lex_menhir_token.BYTES _v_19 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_19 MenhirState0211 _menhir_initp - | Lex_menhir_token.BYTE _v_20 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_QUESTION - (_menhir_stack, _startpos_2, _endpos_3) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_4, _endpos_5) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_20 MenhirState0211 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LPAREN -> ( - let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.UIDENT _v_23 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_23 MenhirState0215 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.STRING _v_24 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState0215 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_25 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _endpos_meth_, _startpos_meth_, meth, _endpos__7_ = - (_endpos_1, _startpos_0, _v, _endpos_25) - in - let _v = - _menhir_action_628 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__7_ _startpos_self_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.POST_LABEL _v_26 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState0215 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_27 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_27 MenhirState0215 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_28 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_28 MenhirState0215 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_29 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_29 MenhirState0215 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.LIDENT _v_30 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_30 MenhirState0215 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.LABEL _v_31 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_31 MenhirState0215 _menhir_initp - | Lex_menhir_token.INTERP _v_32 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_32 MenhirState0215 _menhir_initp - | Lex_menhir_token.INT _v_33 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_33 MenhirState0215 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.FLOAT _v_34 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_34 MenhirState0215 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0215 _menhir_initp - | Lex_menhir_token.CHAR _v_35 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_35 MenhirState0215 _menhir_initp - | Lex_menhir_token.BYTES _v_36 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_36 MenhirState0215 _menhir_initp - | Lex_menhir_token.BYTE _v_37 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_21, _endpos_22) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_37 MenhirState0215 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_38 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_39 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_40 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_41 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.UIDENT _v_42 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_42 MenhirState0220 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.STRING _v_43 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_43 MenhirState0220 _menhir_initp - | Lex_menhir_token.RPAREN -> - let _endpos_44 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) - = - _menhir_stack - in - let _endpos_meth_, _startpos_meth_, meth, _endpos__7_ = - (_endpos_1, _startpos_0, _v, _endpos_44) - in - let _v = - _menhir_action_630 _endpos__7_ _endpos_meth_ - _startpos_meth_ _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__7_ _startpos_self_ _v _menhir_s - _tok _menhir_initp - | Lex_menhir_token.POST_LABEL _v_45 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_45 MenhirState0220 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_46 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_46 MenhirState0220 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_47 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_47 MenhirState0220 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_48 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_48 MenhirState0220 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.LIDENT _v_49 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0088 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_49 MenhirState0220 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.LABEL _v_50 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_50 MenhirState0220 _menhir_initp - | Lex_menhir_token.INTERP _v_51 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_51 MenhirState0220 _menhir_initp - | Lex_menhir_token.INT _v_52 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_52 MenhirState0220 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.FLOAT _v_53 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_53 MenhirState0220 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0220 _menhir_initp - | Lex_menhir_token.CHAR _v_54 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_54 MenhirState0220 _menhir_initp - | Lex_menhir_token.BYTES _v_55 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_55 MenhirState0220 _menhir_initp - | Lex_menhir_token.BYTE _v_56 -> - let _menhir_stack = - MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_38, _endpos_39) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_40, _endpos_41) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_56 MenhirState0220 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_prefix_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState0006 -> - _menhir_run_1240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0012 -> - _menhir_run_0966 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0959 -> - _menhir_run_0966 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1240 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_PLUS -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_PLUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_533 _endpos_e_ _startpos__1_ e in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_e_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0966 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_MINUS -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_534 _endpos_e_ _startpos__1_ e in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_e_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0100 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.AS -> ( - let _menhir_stack = - MenhirCell1_prefix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0101 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_532 _1 in - _menhir_goto_postfix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_goto_postfix_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_111 _1 in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_infix_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match _menhir_s with - | MenhirState0001 -> - _menhir_run_1241 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - _menhir_run_1130 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - _menhir_run_0923 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - _menhir_run_0898 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - _menhir_run_0568 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - _menhir_run_0485 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1173 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - _menhir_run_0134 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - _menhir_run_0128 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - _menhir_run_0126 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - _menhir_run_0124 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - _menhir_run_0122 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - _menhir_run_0120 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - _menhir_run_0118 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - _menhir_run_0116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0113 -> - _menhir_run_0114 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1241 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_WHILE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_infix_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1242 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1242 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState1242, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1243 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_1244 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1242 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1242 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1242 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1242 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1242 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1242 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1242 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1242 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1242 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState1242 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1242 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.INFIX4 _v_16 -> - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_17 -> - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_17 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_18 -> - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_18 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_19 -> - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_19 - _menhir_initp - | Lex_menhir_token.CARET -> - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0111 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0111 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0131 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0131 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0113 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_PLUS (_menhir_stack, _startpos, _endpos) in - let _menhir_s = MenhirState0113 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0119 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_MINUS (_menhir_stack, _startpos, _endpos) in - let _menhir_s = MenhirState0119 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1244 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_WHILE, - ttv_result ) - _menhir_cell1_infix_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_infix_expr (_menhir_stack, _, cond, _, _)) = - _menhir_stack - in - let (MenhirCell1_WHILE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_while_else_, while_else = (_endpos, _v) in - let _v = - _menhir_action_970 _endpos__3_ _endpos_while_else_ _startpos__1_ - _startpos__1_inlined1_ cond while_else - in - _menhir_goto_while_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_while_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0115 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INFIX4 (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0115 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0117 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INFIX3 (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0117 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0121 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INFIX2 (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0121 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0123 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_INFIX1 (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0123 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0125 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_CARET (_menhir_stack, _startpos, _endpos) in - let _menhir_s = MenhirState0125 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0133 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_BARBAR (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0133 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0129 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos, _endpos) in - let _menhir_s = MenhirState0129 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0135 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AMPERAMPER (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0135 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0127 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_AMPER (_menhir_stack, _startpos, _endpos) in - let _menhir_s = MenhirState0127 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1130 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_MATCH as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1131 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1131 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_MATCH (_menhir_stack, _menhir_s, _startpos__1_, _)) - = - _menhir_stack - in - let _endpos__2_, _endpos__3_, e = (_endpos_4, _endpos_1, _v) in - let _v = - _menhir_action_121 _endpos__2_ _endpos__3_ _startpos__1_ e - in - _menhir_goto_match_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__2_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1131 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1131 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.INT _v_7 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1131 _menhir_initp - | Lex_menhir_token.FLOAT _v_8 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1131 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1131 _menhir_initp - | Lex_menhir_token.CHAR _v_9 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1131 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.INFIX4 _v_10 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_11 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_12 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_13 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0923 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_IF as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0924 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0924 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> ( - let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_7 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.UIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_8 MenhirState0927 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.STRING _v_9 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_9 MenhirState0927 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_IF - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let ( _endpos__3_, - _endpos__3_inlined1_, - _startpos__1_inlined1_, - b, - _startpos__1_inlined2_ ) = - (_endpos_4, _endpos_10, _startpos_0, _v, _startpos_6) - in - let _v = - _menhir_action_083 _endpos__3_ _endpos__3_inlined1_ - _startpos__1_ _startpos__1_inlined1_ - _startpos__1_inlined2_ b - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_inlined1_ _startpos__1_ _v - _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_11 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState0927 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_12 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState0927 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_13 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_13 MenhirState0927 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.LIDENT _v_14 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState0927 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.INTERP _v_15 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState0927 _menhir_initp - | Lex_menhir_token.INT _v_16 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState0927 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.FLOAT _v_17 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState0927 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | Lex_menhir_token.CHAR _v_18 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState0927 _menhir_initp - | Lex_menhir_token.BYTES _v_19 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState0927 _menhir_initp - | Lex_menhir_token.BYTE _v_20 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState0927 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - let _menhir_stack = - MenhirCell1_LBRACE - ( _menhir_stack, - MenhirState0926, - _startpos_6, - _endpos_7 ) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState0927 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _menhir_stack = - MenhirCell1_RBRACE - (_menhir_stack, MenhirState0924, _endpos_4) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_5) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0926 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell1_IF - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, _startpos__1_inlined1_, b = - (_endpos_4, _startpos_0, _v) - in - let _v = - _menhir_action_095 _endpos__3_ _startpos__1_ - _startpos__1_inlined1_ b - in - _menhir_goto_if_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_21 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_21 - MenhirState0924 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_22 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_22 - MenhirState0924 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_23 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_23 - MenhirState0924 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.LIDENT _v_24 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_24 - MenhirState0924 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.INTERP _v_25 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_25 - MenhirState0924 _menhir_initp - | Lex_menhir_token.INT _v_26 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_26 - MenhirState0924 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.FLOAT _v_27 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_27 - MenhirState0924 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | Lex_menhir_token.CHAR _v_28 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_28 - MenhirState0924 _menhir_initp - | Lex_menhir_token.BYTES _v_29 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_29 - MenhirState0924 _menhir_initp - | Lex_menhir_token.BYTE _v_30 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_30 - MenhirState0924 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0924 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.INFIX4 _v_31 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_32 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_32 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_33 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_34 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_34 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0898 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.SEMI _ -> - let x = _v in - let _v = _menhir_action_494 x in - _menhir_goto_option_infix_expr_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0568 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_GUARD as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.ELSE -> ( - let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.UIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0570 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.STRING _v_8 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0570 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_GUARD - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_inlined1_, _startpos__1_inlined1_, cond = - (_endpos_9, _startpos_5, _v) - in - let _v = - _menhir_action_078 _endpos__3_inlined1_ _startpos__1_ - _startpos__1_inlined1_ cond - in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_inlined1_ _startpos__1_ _v _menhir_s - _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_10 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0570 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_11 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0570 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_12 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0570 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.LIDENT _v_13 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0570 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.INTERP _v_14 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 MenhirState0570 _menhir_initp - | Lex_menhir_token.INT _v_15 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_15 MenhirState0570 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.FLOAT _v_16 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_16 MenhirState0570 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | Lex_menhir_token.CHAR _v_17 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_17 MenhirState0570 _menhir_initp - | Lex_menhir_token.BYTES _v_18 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_18 MenhirState0570 _menhir_initp - | Lex_menhir_token.BYTE _v_19 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_19 MenhirState0570 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_ELSE (_menhir_stack, _startpos_4) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0570 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_cond_, cond = (_endpos, _v) in - let _v = _menhir_action_077 _endpos_cond_ _startpos__1_ cond in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_cond_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0485 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_GUARD, - ttv_result ) - _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_EQUAL - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.ELSE -> ( - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ELSE (_menhir_stack, _startpos_4) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.UIDENT _v_7 -> - _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0487 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0252 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.STRING _v_8 -> - _menhir_run_0253 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0487 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_9 -> - _menhir_run_0255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0487 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0261 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - _menhir_run_0262 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0487 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0263 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0264 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0268 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_11 MenhirState0487 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0269 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_12 MenhirState0487 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0270 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0487 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0271 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_13 MenhirState0487 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _v_14 = _menhir_action_662 () in - _menhir_run_0488 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_14 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = - _menhir_stack - in - let (MenhirCell1_LET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_GUARD (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_081 _endpos_expr_ _startpos__1_ expr pat in - _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0139 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_530 _1 in - _menhir_goto_pipe_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_pipe_expr : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PIPE -> ( - let _menhir_stack = - MenhirCell1_pipe_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_PIPE (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0105 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_046 _1 in - _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0136 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_AMPERAMPER - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_AMPERAMPER (_menhir_stack, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_107 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0134 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_BARBAR - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE - | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_BARBAR (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_108 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0132 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr - _menhir_cell0_RANGE_EXCLUSIVE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BARBAR - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE - | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_RANGE_EXCLUSIVE - (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_109 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0130 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_BAR - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BAR - | Lex_menhir_token.BARBAR | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_BAR (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_106 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0128 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_AMPER - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE - | Lex_menhir_token.PIPE | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_AMPER (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_104 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0126 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_CARET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BAR - | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET | Lex_menhir_token.CATCH - | Lex_menhir_token.COLON | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_CARET (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_105 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0124 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_INFIX1 - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_INFIX1 (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_101 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0122 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_INFIX2 - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.PIPE | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_INFIX2 (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_100 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0120 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_MINUS - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_MINUS (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_103 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0118 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_INFIX3 - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE - | Lex_menhir_token.PLUS | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_INFIX3 (_menhir_stack, _1, _startpos__1_, _endpos__1_)) - = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_099 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0116 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_INFIX4 -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_INFIX4 (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_098 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0114 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr _menhir_cell0_PLUS - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_PLUS (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_102 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0112 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_infix_expr - _menhir_cell0_RANGE_INCLUSIVE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BARBAR - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE - | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_RANGE_INCLUSIVE - (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = - _menhir_action_110 _endpos__1_ _endpos_rhs_ _startpos__1_ - _startpos_lhs_ lhs rhs - in - _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0110 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_pipe_expr _menhir_cell0_PIPE - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RANGE_INCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0111 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RANGE_EXCLUSIVE -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0113 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0119 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.INFIX4 _v_0 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - _menhir_initp - | Lex_menhir_token.INFIX3 _v_1 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - _menhir_initp - | Lex_menhir_token.INFIX2 _v_2 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - _menhir_initp - | Lex_menhir_token.INFIX1 _v_3 -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - _menhir_initp - | Lex_menhir_token.CARET -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0125 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BARBAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.BAR -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPERAMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0135 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER -> - let _menhir_stack = - MenhirCell1_infix_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0127 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EOF | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_PIPE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pipe_expr - (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = - _menhir_stack - in - let _endpos_rhs_, rhs = (_endpos, _v) in - let _v = _menhir_action_529 _endpos_rhs_ _startpos_lhs_ lhs rhs in - _menhir_goto_pipe_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1104 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1105 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1113 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1115 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1118 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1120 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1069 : - type ttv_stack ttv_result. - (( ( ( (ttv_stack, ttv_result) _menhir_cell1_LOOP, - ttv_result ) - _menhir_cell1_non_empty_list_commas_no_trailing_expr_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_10_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1070 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1078 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1080 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1083 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1085 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0804 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0805 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0813 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0815 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0818 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0820 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0769 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0770 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0778 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0780 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0783 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0785 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0705 : - type ttv_stack ttv_result. - (( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0706 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0714 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0716 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0719 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0721 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0670 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0671 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0679 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0681 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0684 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0686 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0587 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0588 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0596 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0598 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0601 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0603 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0544 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0545 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0553 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0555 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0558 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0560 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0506 : - type ttv_stack ttv_result. - ((ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0507 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0515 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_30 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - let _v = _v_30 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0517 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_45 -> ( - let _startpos_46 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0520 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_61 -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_INT - (_menhir_stack, _v_45, _startpos_46, _endpos_47) - in - let _v = _v_61 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0522 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let ( _startpos_record_, - record, - _endpos_index_, - _startpos_index_, - index ) = - (_startpos, _v, _endpos_47, _startpos_46, _v_45) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ - _startpos_record_ index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ - | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0084 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LBRACKET -> ( - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0176 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.COLON -> - _menhir_run_0177 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0187 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DOT_LIDENT _v_14 -> ( - let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0193 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0198 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_DOT_LIDENT - (_menhir_stack, _v_14, _startpos_15, _endpos_16) - in - _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.CATCH - | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.DOTDOT | Lex_menhir_token.DOT_INT _ - | Lex_menhir_token.DOT_LIDENT _ | Lex_menhir_token.ELSE - | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.LBRACKET | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos_name_, _startpos_name_, name, _startpos_record_, record - = - (_endpos_16, _startpos_15, _v_14, _startpos, _v) - in - let _v = - _menhir_action_634 _endpos_name_ _startpos_name_ _startpos_record_ - name record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.DOT_INT _v_17 -> - let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos_record_, record, _endpos_index_, _startpos_index_, index = - (_startpos, _v, _endpos_19, _startpos_18, _v_17) - in - let _v = - _menhir_action_635 _endpos_index_ _startpos_index_ _startpos_record_ - index record - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_index_ _startpos_record_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.DOTDOT -> - let _menhir_stack = - MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0208 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.AS - | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.ELSE | Lex_menhir_token.EOF | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_535 _1 in - _menhir_goto_prefix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_act_goto_570 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _startpos__2_ _endpos__7_ oe -> - match _menhir_s with - | MenhirState1173 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_1183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_1144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_1104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_1069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0769 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0705 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0670 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0544 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0506 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - let _endpos__0_ = _menhir_initp in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - let (MenhirCell1_WHILE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - let (MenhirCell1_LOOP (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - let (MenhirCell1_COLON (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - let (MenhirCell0_AMPERAMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - let (MenhirCell0_BARBAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - let (MenhirCell0_BAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - let (MenhirCell0_AMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - let (MenhirCell0_CARET (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - let (MenhirCell0_INFIX1 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - let (MenhirCell0_INFIX2 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - let (MenhirCell0_MINUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - let (MenhirCell0_INFIX3 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - let (MenhirCell0_INFIX4 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - let (MenhirCell0_PLUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = _menhir_action_570 _endpos__0_ _endpos__7_ _startpos__2_ oe in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0097 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0098 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_557 _endpos_name_ _startpos_name_ name in - _menhir_goto_record_defn_single _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_record_defn_single : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0158 -> - _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0151 -> - _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0987 -> - _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0972 -> - _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0968 -> - _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0095 -> - _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0147 -> - _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0152 : - type ttv_stack ttv_result. - ( ttv_stack, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_record_defn_single_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_record_defn_single_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_251 x xs in - _menhir_goto_non_empty_list_commas_rev_record_defn_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_record_defn_single_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0972 -> - _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0968 -> - _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0095 -> - _menhir_run_0157 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0987 -> - _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0147 -> - _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0157 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_record_defn_single_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0158 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = ((), _v) in - let _v = _menhir_action_263 x xs in - _menhir_goto_non_empty_list_commas_with_trailing_info_record_defn_single_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_262 xs in - _menhir_goto_non_empty_list_commas_with_trailing_info_record_defn_single_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_with_trailing_info_record_defn_single_ : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState0972 -> - _menhir_run_0973 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0968 -> - _menhir_run_0969 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0095 -> - _menhir_run_0155 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0973 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_LIDENT - _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, e, _, _endpos_e_)) = - _menhir_stack - in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let x = _v in - let _v = - _menhir_action_555 _endpos_e_ _endpos_name_ _startpos_name_ e name x - in - _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - - and _menhir_goto_record_defn : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__3_, x = (_endpos, _v) in - let _v = _menhir_action_565 _endpos__3_ _startpos__1_ x in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0969 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_LIDENT - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _1 = _v in - let _v = _menhir_action_553 _1 _endpos_name_ _startpos_name_ name in - _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - - and _menhir_run_0155 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty - _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_COLONCOLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _1, _endpos__5_ = (_v, _endpos) in - let _v = - _menhir_action_567 _1 _endpos__5_ _endpos_name_ _startpos_name_ name - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0150 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_DOTDOT, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COMMA - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_record_defn_single_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0151 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = ((), _v) in - let _v = _menhir_action_152 x xs in - _menhir_goto_non_empty_list_commas_record_defn_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_151 xs in - _menhir_goto_non_empty_list_commas_record_defn_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_record_defn_single_ : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_DOTDOT, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COMMA - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState0987 -> - _menhir_run_0989 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0147 -> - _menhir_run_0153 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0989 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_DOTDOT, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, oe, _, _)) = _menhir_stack in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__2_, _)) = - _menhir_stack - in - _menhir_act_goto_571 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _tok _menhir_initp _v _startpos__2_ _endpos oe - - and _menhir_act_goto_571 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _1 _startpos__2_ _endpos__7_ oe -> - match _menhir_s with - | MenhirState1173 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_1183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1134 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_1144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1094 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_1104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1059 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_1069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0794 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0759 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0769 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0695 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0705 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0660 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0670 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2062 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2058 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2055 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2053 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1972 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1968 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1965 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1963 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1960 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1956 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1953 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1951 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1944 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1940 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1937 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1935 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1932 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1928 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1925 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1923 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1915 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1908 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1906 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1899 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1896 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1894 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1887 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1883 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1880 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1878 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1875 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1871 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1868 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1866 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1855 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1851 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1848 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1846 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1843 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1839 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1836 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1834 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1827 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1823 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1820 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1818 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1815 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1811 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1808 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1806 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1798 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1794 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1791 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1789 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1786 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1782 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1779 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1777 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1770 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1766 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1763 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1761 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1758 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1754 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1751 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1749 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1657 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1653 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1650 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1648 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1645 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1641 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1638 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1636 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1629 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1625 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1622 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1620 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1617 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1613 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1610 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1608 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1600 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1596 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1593 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1591 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1588 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1584 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1581 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1572 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1568 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1565 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1563 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1560 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1556 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1553 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1551 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1540 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1536 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1533 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1531 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1528 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1524 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1521 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1519 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1512 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1508 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1505 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1503 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1500 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1496 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1493 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1491 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1483 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1479 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1476 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1474 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1471 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1467 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1464 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1462 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1455 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1451 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1448 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1446 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1443 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1439 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1436 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1434 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1410 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1406 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1403 -> - let (MenhirCell1_non_empty_list_semis_local_type_decl_ - (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1343 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1246 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1242 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1003 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0024 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0950 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0947 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0935 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0941 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0938 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0924 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0930 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0927 -> - let (MenhirCell1_LBRACE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0920 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0917 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0911 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0071 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0903 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0899 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0893 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0889 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0878 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0874 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0861 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0238 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0856 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0241 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0852 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0570 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0844 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0841 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0835 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0832 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0745 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0742 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0736 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0733 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0650 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0647 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0611 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0579 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0587 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0534 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0544 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0491 -> - let (MenhirCell0_FAT_ARROW (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0506 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2013 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState2004 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0000 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0001 -> - let (MenhirCell1_WHILE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0006 -> - let (MenhirCell1_PLUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0012 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1233 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0013 -> - let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0014 -> - let (MenhirCell1_TRY (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1204 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1202 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1199 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1197 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1194 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1192 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1189 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1187 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1184 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1181 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1179 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1176 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1174 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1165 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1163 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1160 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1158 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1155 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1153 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1150 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1148 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1145 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1142 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1140 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1137 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1135 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0015 -> - let (MenhirCell1_MATCH (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0018 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1125 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1123 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1120 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1118 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1115 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1113 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1110 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1108 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1105 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1102 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1100 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1097 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1095 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1090 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1088 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1085 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1083 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1080 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1078 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1075 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1073 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1070 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1067 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1065 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1062 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1060 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0021 -> - let (MenhirCell1_LOOP (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1044 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1045 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0022 -> - let (MenhirCell1_LBRACKET (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1041 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1037 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1034 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1031 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1028 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1025 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1022 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1019 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1016 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1012 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState1009 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0998 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0995 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0992 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0984 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0982 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0979 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0976 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0970 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0959 -> - let (MenhirCell1_MINUS (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0964 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0961 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0956 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0026 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0029 -> - let (MenhirCell1_IF (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0072 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0886 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0872 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0868 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0825 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0823 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0820 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0818 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0815 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0813 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0810 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0808 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0805 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0802 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0800 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0797 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0795 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0790 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0788 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0785 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0783 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0780 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0778 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0775 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0773 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0770 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0767 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0765 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0762 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0760 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0726 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0724 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0721 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0719 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0716 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0714 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0711 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0709 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0706 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0703 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0701 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0698 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0696 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0691 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0689 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0686 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0684 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0681 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0679 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0676 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0674 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0671 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0668 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0666 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0663 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0661 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0642 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0638 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0622 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0618 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0608 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0606 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0603 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0601 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0598 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0596 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0593 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0591 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0588 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0584 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0582 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0481 -> - let (MenhirCell1_GUARD (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0565 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0563 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0560 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0558 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0555 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0553 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0550 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0548 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0545 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0542 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0540 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0537 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0535 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0527 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0525 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0522 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0520 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0517 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0515 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0512 -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT (_, _, _, _endpos__0_)) = - _menhir_stack - in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0510 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0507 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0504 -> - let (MenhirCell1_BREAK (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0500 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0498 -> - let (MenhirCell1_CONTINUE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0495 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0492 -> - let (MenhirCell1_RETURN (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0484 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0479 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0475 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0472 -> - let (MenhirCell1_EQUAL (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0468 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0243 -> - let (MenhirCell1_RAISE (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0236 -> - let (MenhirCell0_IN (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0232 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0220 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0215 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0211 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0203 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0198 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0194 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0188 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0183 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0176 -> - let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0177 -> - let (MenhirCell1_COLON (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0172 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0164 -> - let (MenhirCell0_COMMA (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0086 -> - let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0160 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0144 -> - let (MenhirCell1_DOTDOT (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0135 -> - let (MenhirCell0_AMPERAMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0133 -> - let (MenhirCell0_BARBAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0131 -> - let (MenhirCell0_RANGE_EXCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0129 -> - let (MenhirCell0_BAR (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0127 -> - let (MenhirCell0_AMPER (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0125 -> - let (MenhirCell0_CARET (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0123 -> - let (MenhirCell0_INFIX1 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0121 -> - let (MenhirCell0_INFIX2 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0119 -> - let (MenhirCell0_MINUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0117 -> - let (MenhirCell0_INFIX3 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0115 -> - let (MenhirCell0_INFIX4 (_, _, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0113 -> - let (MenhirCell0_PLUS (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0111 -> - let (MenhirCell0_RANGE_INCLUSIVE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0105 -> - let (MenhirCell0_PIPE (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0098 -> - let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0090 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | MenhirState0076 -> - let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_571 _1 _endpos__0_ _endpos__7_ _startpos__2_ oe - in - _menhir_run_0084 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ - _startpos__2_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0153 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty - _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_DOTDOT, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, oe, _, _)) = _menhir_stack in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell0_COLONCOLON (_menhir_stack, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_573 _1 _endpos__2_inlined1_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__7_ _startpos_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0149 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_250 x in - _menhir_goto_non_empty_list_commas_rev_record_defn_single_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0983 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FALSE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_FALSE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_227 _endpos__1_ _endpos_expr_ _startpos__1_ expr in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0980 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_FLOAT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_FLOAT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_232 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0977 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_INT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_INT - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_231 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0971 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_LIDENT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_0) in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0972 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x = () in - let _v = _menhir_action_464 x in - _menhir_goto_option_COMMA_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let _v = _menhir_action_463 () in - _menhir_goto_option_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option_COMMA_ : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_LIDENT - _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_expr -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let (MenhirCell1_expr (_menhir_stack, _, e, _, _endpos_e_)) = - _menhir_stack - in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let comma = _v in - let _v = - _menhir_action_554 _endpos_e_ _endpos_name_ _startpos_name_ comma e name - in - _menhir_goto_record_defn _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - - and _menhir_run_0965 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS, - ttv_result ) - _menhir_cell1_FLOAT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_FLOAT - (_menhir_stack, _, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_235 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0962 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_MINUS, - ttv_result ) - _menhir_cell1_INT - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_INT - (_menhir_stack, _, _2_inlined1, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_234 _2_inlined1 _endpos__2_inlined1_ _endpos_expr_ - _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0957 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_STRING - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_STRING - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_233 _1 _endpos__1_ _endpos_expr_ _startpos__1_ expr - in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0954 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, - ttv_result ) - _menhir_cell1_TRUE - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_TRUE - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_226 _endpos__1_ _endpos_expr_ _startpos__1_ expr in - _menhir_goto_non_empty_list_commas_rev_map_expr_elem_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0887 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_rev___anonymous_12_ - _menhir_cell0_COMMA - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_non_empty_list_commas_rev___anonymous_12_ - (_menhir_stack, xs)) = - _menhir_stack - in - let e = _v in - let _v = _menhir_action_165 _endpos_name_ _startpos_name_ e name xs in - _menhir_goto_non_empty_list_commas_rev___anonymous_12_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev___anonymous_12_ : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _menhir_stack = - MenhirCell0_non_empty_list_commas_rev___anonymous_12_ - (_menhir_stack, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_EQUAL (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0886 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let xs = _v in - let _v = _menhir_action_160 xs in - let _menhir_stack = - MenhirCell0_non_empty_list_commas_no_trailing___anonymous_12_ - (_menhir_stack, _v) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0889 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0889 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0889, _endpos_2) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0890 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_3 = _menhir_action_507 () in - _menhir_run_0891 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_2 _v_3 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0889 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState0889 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0889 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0889 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0889 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0889 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0889 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0889 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0889 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0889 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0889 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0891 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_non_empty_list_commas_no_trailing___anonymous_12_ - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_non_empty_list_commas_no_trailing___anonymous_12_ - (_menhir_stack, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_060 _1_inlined1 _endpos__3_inlined1_ _endpos_for_else_ - _startpos__1_ _startpos__1_inlined2_ binders condition for_else - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0873 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let e = _v in - let _v = _menhir_action_164 _endpos_name_ _startpos_name_ e name in - _menhir_goto_non_empty_list_commas_rev___anonymous_12_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp - - and _menhir_run_0827 : - type ttv_stack ttv_result. - ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos__1_, _1 = (_endpos, _v) in - let _v = _menhir_action_317 _1 pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0826 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_309 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0824 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_313 _endpos_e_ _endpos_name_ _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0821 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_311 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0819 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_315 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0816 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_310 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0814 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_314 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0811 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_312 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0809 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_316 _endpos_e_ _startpos_obj_ e ind obj pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0806 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0808 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0810 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0803 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_303 _endpos_x_ _startpos__1_ pats x in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0798 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_307 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_pats_ _v _menhir_s - _tok _menhir_initp - - and _menhir_run_0792 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _1 = (_endpos, _v) in - let _v = _menhir_action_333 _1 pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0791 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_325 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0789 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_329 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0786 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_327 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0784 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_331 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0781 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_326 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0779 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_330 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0776 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_328 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0774 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_332 _endpos_e_ _startpos_obj_ e ind obj pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0771 : - type ttv_stack ttv_result. - (( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0773 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0775 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0768 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_319 _endpos_x_ _startpos__1_ pats x xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0763 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_16_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_16_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_323 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_16_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0728 : - type ttv_stack ttv_result. - ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos__1_, _1 = (_endpos, _v) in - let _v = _menhir_action_349 _1 pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0727 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_341 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0725 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_345 _endpos_e_ _endpos_name_ _startpos_name_ e name pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0722 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_343 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0720 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_347 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0717 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_342 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0715 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_346 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0712 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_344 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0710 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_348 _endpos_e_ _startpos_obj_ e ind obj pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0707 : - type ttv_stack ttv_result. - (( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0709 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0711 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0704 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_335 _endpos_x_ _startpos__1_ pats x in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_pats_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0699 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ - (_menhir_stack, _menhir_s, pats, _startpos_pats_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_339 _endpos_expr_ _startpos__1_ expr pats in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_pats_ _v _menhir_s - _tok _menhir_initp - - and _menhir_run_0693 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos__1_, _1 = (_endpos, _v) in - let _v = _menhir_action_365 _1 pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0692 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_357 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0690 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_361 _endpos_e_ _endpos_name_ _startpos_name_ e name pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0687 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_359 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0685 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_363 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0682 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_358 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0680 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_362 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pats record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0677 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_360 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pats xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0675 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_364 _endpos_e_ _startpos_obj_ e ind obj pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_e_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0672 : - type ttv_stack ttv_result. - (( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0674 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0676 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0669 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_351 _endpos_x_ _startpos__1_ pats x xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0664 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_7_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_non_empty_list_commas_pattern_ - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_pattern_ (_menhir_stack, _, pats, _)) - = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_7_ - (_menhir_stack, _menhir_s, xs, _startpos_xs_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_355 _endpos_expr_ _startpos__1_ expr pats xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_7_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_expr_ _startpos_xs_ _v _menhir_s _tok - _menhir_initp - - and _menhir_run_0643 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_fn_label _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_fn_label (_menhir_stack, _menhir_s, label, _, _)) = - _menhir_stack - in - let default = _v in - let _v = _menhir_action_518 default label t in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0639 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_fn_label _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_fn_label (_menhir_stack, _menhir_s, label, _, _)) = - _menhir_stack - in - let default = _v in - let _v = _menhir_action_517 default label in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0623 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_POST_LABEL - ( _menhir_stack, - _menhir_s, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let default = _v in - let _v = - _menhir_action_524 _endpos_binder_name_ _startpos_binder_name_ binder_name - default t - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0619 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_POST_LABEL - ( _menhir_stack, - _menhir_s, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let default = _v in - let _v = - _menhir_action_523 _endpos_binder_name_ _startpos_binder_name_ binder_name - default - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0615 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_700 _1 in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0609 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_692 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0607 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_696 _endpos_e_ _endpos_name_ _startpos_name_ e name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_name_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0604 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, record, _startpos_record_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_694 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index record - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_record_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0602 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, record, _startpos_record_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_698 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index record - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_record_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0599 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, record, _startpos_record_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_693 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name record - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_record_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0597 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, record, _startpos_record_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_697 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name record - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_record_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0594 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, obj, _startpos_obj_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_695 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_obj_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0592 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, obj, _startpos_obj_, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_699 _endpos_e_ _startpos_obj_ e ind obj in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ - _startpos_obj_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0589 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0591 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0593 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0585 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_686 _endpos_x_ _startpos__1_ x in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0567 : - type ttv_stack ttv_result. - ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _1 = _v in - let _v = _menhir_action_397 _1 pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0566 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_389 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pat xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0564 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_393 _endpos_e_ _endpos_name_ _startpos_name_ e name pat xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0561 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_391 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pat record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0559 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_395 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pat record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0556 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_390 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pat record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0554 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_394 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pat record xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0551 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_392 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pat xs - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0549 : - type ttv_stack ttv_result. - ( ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_396 _endpos_e_ _startpos_obj_ e ind obj pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0546 : - type ttv_stack ttv_result. - (( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0548 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0550 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0543 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_383 _endpos_x_ _startpos__1_ pat x xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0538 : - type ttv_stack ttv_result. - ( ( ( ttv_stack _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_non_empty_list_semi_rev_aux___anonymous_8_ - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux___anonymous_8_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_387 _endpos_expr_ _startpos__1_ expr pat xs in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0529 : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _1 = _v in - let _v = _menhir_action_381 _1 pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0528 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_373 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ e name pat - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0526 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_qual_ident - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_377 _endpos_e_ _endpos_name_ _startpos_name_ e name pat - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0523 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_375 _1 _endpos__1_ _endpos_e_ _endpos_index_ _startpos__1_ - _startpos_index_ _startpos_record_ e index pat record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0521 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_INT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_INT - (_menhir_stack, index, _startpos_index_, _endpos_index_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_379 _endpos_e_ _endpos_index_ _startpos_index_ - _startpos_record_ e index pat record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0518 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_374 _1 _endpos__1_ _endpos_e_ _endpos_name_ _startpos__1_ - _startpos_name_ _startpos_record_ e name pat record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0516 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_DOT_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _, record, _startpos_record_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_378 _endpos_e_ _endpos_name_ _startpos_name_ - _startpos_record_ e name pat record - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0513 : - type ttv_stack ttv_result. - ( ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_AUGMENTED_ASSIGNMENT -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_376 _1 _endpos__1_ _endpos_e_ _startpos__1_ _startpos_obj_ - e ind obj pat - in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0511 : - type ttv_stack ttv_result. - ( ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_RBRACKET - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_RBRACKET (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, ind, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr (_menhir_stack, _, obj, _startpos_obj_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = _menhir_action_380 _endpos_e_ _startpos_obj_ e ind obj pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0508 : - type ttv_stack ttv_result. - (( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_simple_expr - _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0510 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AUGMENTED_ASSIGNMENT _v_14 -> ( - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_RBRACKET (_menhir_stack, _endpos_0) - in - let _v = _v_14 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_AUGMENTED_ASSIGNMENT - (_menhir_stack, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0512 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER - | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR - | Lex_menhir_token.CARET | Lex_menhir_token.DOTDOT - | Lex_menhir_token.DOT_INT _ | Lex_menhir_token.DOT_LIDENT _ - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.INFIX1 _ - | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ - | Lex_menhir_token.INFIX4 _ | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.MINUS - | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS - | Lex_menhir_token.QUESTION | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = - _menhir_action_617 _endpos__4_ _startpos_array_ array index - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0505 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_BREAK -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_BREAK (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_367 _endpos_x_ _startpos__1_ pat x in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0503 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_172 x in - _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0501 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_expr_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_expr_ - (_menhir_stack, _menhir_s, xs, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_173 x xs in - _menhir_goto_non_empty_list_commas_rev_expr_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0496 : - type ttv_stack ttv_result. - ( (ttv_stack _menhir_cell0_LBRACE, ttv_result) _menhir_cell1_pattern - _menhir_cell0_FAT_ARROW, - ttv_result ) - _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell0_FAT_ARROW (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _menhir_s, pat, _, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_371 _endpos_expr_ _startpos__1_ expr pat in - _menhir_goto_non_empty_list_semi_rev_aux___anonymous_8_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0494 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_RETURN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_492 x in - _menhir_goto_option_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option_expr_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_RETURN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1174 -> - _menhir_run_1175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1135 -> - _menhir_run_1136 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1095 -> - _menhir_run_1096 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1060 -> - _menhir_run_1061 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0072 -> - _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0795 -> - _menhir_run_0796 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0760 -> - _menhir_run_0761 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0696 -> - _menhir_run_0697 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0661 -> - _menhir_run_0662 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0535 -> - _menhir_run_0536 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0492 -> - _menhir_run_0493 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0908 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_RETURN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RETURN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_689 _endpos_expr_ _startpos__1_ expr in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0480 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_665 _endpos_expr_ _startpos__1_ expr pat t in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0476 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = _menhir_stack in - let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_664 _endpos_expr_ _startpos__1_ expr pat in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0473 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_COLON, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_MUTABLE (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_667 _endpos_expr_ _endpos_name_ _startpos__1_ - _startpos_name_ expr name t - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0469 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_MUTABLE (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = - _menhir_action_666 _endpos_expr_ _endpos_name_ _startpos__1_ - _startpos_name_ expr name - in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0244 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_RAISE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RAISE (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_expr_, expr = (_endpos, _v) in - let _v = _menhir_action_690 _endpos_expr_ _startpos__1_ expr in - _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_expr_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0237 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0238 _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0238 _menhir_initp - | Lex_menhir_token.RETURN -> - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState0238, _endpos_4) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.ELSE -> - _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0239 _menhir_initp - | Lex_menhir_token.CATCH | Lex_menhir_token.COLON - | Lex_menhir_token.COMMA | Lex_menhir_token.EOF - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ -> - let _v_5 = _menhir_action_507 () in - _menhir_run_0859 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_4 _v_5 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RAISE -> - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_6 -> - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState0238 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_7 -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState0238 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_8 -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState0238 _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.LIDENT _v_9 -> - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState0238 _menhir_initp - | Lex_menhir_token.LET -> - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.INTERP _v_10 -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState0238 _menhir_initp - | Lex_menhir_token.INT _v_11 -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState0238 _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.GUARD -> - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.FLOAT _v_12 -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState0238 _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.CONTINUE -> - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | Lex_menhir_token.CHAR _v_13 -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState0238 _menhir_initp - | Lex_menhir_token.BYTES _v_14 -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState0238 _menhir_initp - | Lex_menhir_token.BYTE _v_15 -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 - MenhirState0238 _menhir_initp - | Lex_menhir_token.BREAK -> - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0238 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0859 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_foreach_binder_ - _menhir_cell0_IN, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = _menhir_stack in - let (MenhirCell0_IN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_foreach_binder_ - (_menhir_stack, _, binders)) = - _menhir_stack - in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_else_block_, else_block = (_endpos, _v) in - let _v = - _menhir_action_068 _endpos__3_inlined1_ _endpos_else_block_ _startpos__1_ - _startpos__1_inlined1_ binders else_block expr - in - _menhir_goto_foreach_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_else_block_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0233 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev___anonymous_11_ - _menhir_cell0_COMMA - _menhir_cell0_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev___anonymous_11_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let e = _v in - let _v = _menhir_action_163 _endpos_name_ _startpos_name_ e name xs in - _menhir_goto_non_empty_list_commas_rev___anonymous_11_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev___anonymous_11_ : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_FOR as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev___anonymous_11_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_EQUAL (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState0232 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE | Lex_menhir_token.SEMI _ -> - let xs = _v in - let _v = _menhir_action_159 xs in - let _1 = _v in - let _v = _menhir_action_056 _1 in - _menhir_goto_for_binders _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0224 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_LIDENT - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let e = _v in - let _v = _menhir_action_162 _endpos_name_ _startpos_name_ e name in - _menhir_goto_non_empty_list_commas_rev___anonymous_11_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0185 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, x, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let _endpos__6_, x_inlined1 = (_endpos_0, _v) in - let _v = - _menhir_action_621 _endpos__6_ _startpos__2_ _startpos_array_ array x - x_inlined1 - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0181 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let index, _endpos__4_ = (_v, _endpos_0) in - let _v = _menhir_action_617 _endpos__4_ _startpos_array_ array index in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.COLON -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0179 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LBRACKET, - ttv_result ) - _menhir_cell1_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_COLON (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACKET (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, array, _startpos_array_, _)) = - _menhir_stack - in - let x, _endpos__6_ = (_v, _endpos_0) in - let _v = - _menhir_action_619 _endpos__6_ _startpos__2_ _startpos_array_ array x - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_array_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0167 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let arg_value = _v in - let _v = _menhir_action_006 arg_value in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0161 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let arg_value = _v in - let _v = _menhir_action_003 _endpos_name_ _startpos_name_ arg_value name in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0159 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let arg_value = _v in - let _v = - _menhir_action_002 _endpos__1_ _endpos_name_ _startpos__1_ _startpos_name_ - arg_value name - in - _menhir_goto_argument _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_0145 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty - _menhir_cell0_COLONCOLON - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_DOTDOT - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell0_COLONCOLON (_menhir_stack, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) - = - _menhir_stack - in - let _endpos__5_, oe = (_endpos_0, _v) in - let _v = - _menhir_action_569 _endpos__2_inlined1_ _endpos__5_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_name_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.COMMA -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__2_, _)) = - _menhir_stack - in - let (MenhirCell0_COLONCOLON (_menhir_stack, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - name, - _startpos_name_, - _endpos_name_ )) = - _menhir_stack - in - let _endpos__7_, oe = (_endpos_2, _v) in - let _v = - _menhir_action_572 _endpos__2_inlined1_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name oe - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__7_ _startpos_name_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos_1) in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0147 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0143 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_e_, e = (_endpos, _v) in - let _v = - _menhir_action_556 _endpos_e_ _endpos_name_ _startpos_name_ e name - in - _menhir_goto_record_defn_single _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - - and _menhir_run_0901 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_063 _endpos__3_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders for_else - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0876 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FOR, - ttv_result ) - _menhir_cell1_for_binders - _menhir_cell0_SEMI, - ttv_result ) - _menhir_cell1_option_infix_expr_ - _menhir_cell0_SEMI - _menhir_cell0_LBRACE, - ttv_result ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _endpos__3_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option_infix_expr_ (_menhir_stack, _, condition)) = - _menhir_stack - in - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_for_binders (_menhir_stack, _, binders)) = _menhir_stack in - let (MenhirCell1_FOR (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos_for_else_, for_else = (_endpos, _v) in - let _v = - _menhir_action_057 _endpos__3_inlined1_ _endpos_for_else_ _startpos__1_ - _startpos__1_inlined1_ binders condition for_else - in - _menhir_goto_for_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_for_else_ _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0053 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_543 i in - _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_argument_ : - type ttv_stack ttv_result. - (ttv_stack _menhir_cell0_LPAREN as 'stack) -> - _ -> - _ -> - _ -> - ('stack, ttv_result) _menhir_state -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState2013 -> - _menhir_run_2015 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0018 -> - _menhir_run_1128 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0220 -> - _menhir_run_0222 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0215 -> - _menhir_run_0217 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0211 -> - _menhir_run_0213 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0203 -> - _menhir_run_0205 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0198 -> - _menhir_run_0200 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0194 -> - _menhir_run_0196 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0188 -> - _menhir_run_0190 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0172 -> - _menhir_run_0174 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState0086 -> - _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2015 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_qual_ident_ty - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _1, _endpos__4_ = (_v, _endpos) in - let _v = - _menhir_action_031 _1 _endpos__4_ _endpos_name_ _startpos_name_ name - in - _menhir_goto_deriving_directive _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - - and _menhir_goto_deriving_directive : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2010 -> - _menhir_run_2022 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState2018 -> - _menhir_run_2019 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2022 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_170 x in - _menhir_goto_non_empty_list_commas_rev_deriving_directive_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_deriving_directive_ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_deriving_directive_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState2018 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_deriving_directive_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2018 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_deriving_directive_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2018 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_132 x xs in - _menhir_goto_non_empty_list_commas_deriving_directive_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_131 xs in - _menhir_goto_non_empty_list_commas_deriving_directive_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_deriving_directive_ : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_DERIVE (_menhir_stack, _menhir_s)) = _menhir_stack in - let _1_inlined1, _endpos__4_ = (_v, _endpos) in - let _v = _menhir_action_034 _1_inlined1 in - _menhir_goto_deriving_directive_list _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__4_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_2019 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_deriving_directive_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_deriving_directive_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_171 x xs in - _menhir_goto_non_empty_list_commas_rev_deriving_directive_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1128 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, func, _startpos_func_, _endpos_func_)) = - _menhir_stack - in - let _1, _endpos__5_ = (_v, _endpos) in - let _v = - _menhir_action_610 _1 _endpos__5_ _endpos_func_ _startpos_func_ func - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0222 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1_inlined1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_631 _1_inlined1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0217 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_629 _1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0213 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOTDOT - _menhir_cell0_LIDENT - _menhir_cell0_QUESTION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1_inlined1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_633 _1_inlined1 _endpos__7_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__7_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0205 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1_inlined1, _endpos__6_ = (_v, _endpos) in - let _v = - _menhir_action_625 _1_inlined1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0200 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1, _endpos__6_ = (_v, _endpos) in - let _v = - _menhir_action_623 _1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0196 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_DOT_LIDENT - _menhir_cell0_QUESTION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_DOT_LIDENT - (_menhir_stack, meth, _startpos_meth_, _endpos_meth_)) = - _menhir_stack - in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, self, _startpos_self_, _)) = - _menhir_stack - in - let _1_inlined1, _endpos__6_ = (_v, _endpos) in - let _v = - _menhir_action_627 _1_inlined1 _endpos__6_ _endpos_meth_ _startpos_meth_ - _startpos_self_ meth self - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__6_ _startpos_self_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0190 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _endpos__5_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_614 _1_inlined1 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0174 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _1, _endpos__5_ = (_v, _endpos) in - let _v = _menhir_action_612 _1 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0169 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_QUESTION - _menhir_cell0_LPAREN -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_simple_expr - (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = - _menhir_stack - in - let _endpos__5_, _1_inlined1 = (_endpos, _v) in - let _v = _menhir_action_616 _1_inlined1 _endpos__5_ _startpos_func_ func in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0168 : - type ttv_stack ttv_result. - ( ttv_stack _menhir_cell0_LPAREN, - ttv_result ) - _menhir_cell1_non_empty_list_commas_rev_argument_ - _menhir_cell0_COMMA -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_argument_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_167 x xs in - _menhir_goto_non_empty_list_commas_rev_argument_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1742 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WITH -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_s = MenhirState1747 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.UIDENT _v_11 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState1761 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.STRING _v_12 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState1761 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_13 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_860 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _tok _menhir_initp _endpos - _startpos _v _startpos__2_ _endpos_5 _endpos_10 - _startpos_9 _endpos_13 _endpos_2 _startpos_1 _v_0 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_14 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState1761 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_15 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState1761 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_16 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState1761 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.LIDENT _v_17 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState1761 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.INTERP _v_18 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState1761 _menhir_initp - | Lex_menhir_token.INT _v_19 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState1761 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.FLOAT _v_20 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState1761 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | Lex_menhir_token.CHAR _v_21 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_21 MenhirState1761 _menhir_initp - | Lex_menhir_token.BYTES _v_22 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_22 MenhirState1761 _menhir_initp - | Lex_menhir_token.BYTE _v_23 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_23 MenhirState1761 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1745, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1761 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_24 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState1745 _menhir_initp - | Lex_menhir_token.LIDENT _v_25 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState1745 _menhir_initp - | Lex_menhir_token.LABEL _v_26 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState1745 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_29 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_30 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_s = MenhirState1804 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_35 = - _menhir_lexbuf.Lexing.lex_start_p - in - let _endpos_36 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.UIDENT _v_37 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_37 MenhirState1818 - _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.STRING _v_38 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_38 MenhirState1818 - _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_39 = - _menhir_lexbuf.Lexing.lex_curr_p - in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _menhir_s, _startpos__2_)) - = - _menhir_stack - in - _menhir_act_goto_836 _menhir_stack - _menhir_lexbuf _menhir_lexer _menhir_s _tok - _menhir_initp _endpos _startpos _v - _startpos__2_ _endpos_31 _endpos_39 _endpos_36 - _startpos_35 _endpos_2 _startpos_1 _v_0 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_40 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_40 MenhirState1818 - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_41 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_41 MenhirState1818 - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_42 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_42 MenhirState1818 - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.LIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_43 MenhirState1818 - _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.INTERP _v_44 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_44 MenhirState1818 - _menhir_initp - | Lex_menhir_token.INT _v_45 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_45 MenhirState1818 - _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.FLOAT _v_46 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_46 MenhirState1818 - _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | Lex_menhir_token.CHAR _v_47 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_47 MenhirState1818 - _menhir_initp - | Lex_menhir_token.BYTES _v_48 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_48 MenhirState1818 - _menhir_initp - | Lex_menhir_token.BYTE _v_49 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_49 MenhirState1818 - _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1802, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1818 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_50 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_50 MenhirState1802 _menhir_initp - | Lex_menhir_token.LIDENT _v_51 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_51 MenhirState1802 _menhir_initp - | Lex_menhir_token.LABEL _v_52 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_52 MenhirState1802 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FOR -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_FOR (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1858 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_860 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ - _endpos__1_inlined1_ _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_860 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_860 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_836 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined2_ _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_836 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_836 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1662 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_1 -> - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let ( _endpos, - _endpos_name_, - _startpos_name_, - name, - _endpos_func_name_, - _startpos_func_name_, - func_name ) = - (_endpos_3, _endpos, _startpos, _v, _endpos_3, _startpos_2, _v_1) - in - let _v = - _menhir_action_071 _endpos_func_name_ _endpos_name_ - _startpos_func_name_ _startpos_name_ func_name name - in - _menhir_goto_fun_binder _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_fun_binder : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1986 -> - _menhir_run_1987 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1975 -> - _menhir_run_1976 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1677 -> - _menhir_run_1678 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1660 -> - _menhir_run_1665 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1987 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1987 _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _menhir_s = MenhirState1987 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1988 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - let _menhir_s = MenhirState1987 in - let _v = _menhir_action_502 () in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1288 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1288 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_reduce_502 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok - _menhir_initp -> - let _v = _menhir_action_502 () in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option_type_parameters_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let params = _v in - let _v = _menhir_action_509 params in - _menhir_goto_optional_type_parameters _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - - and _menhir_goto_optional_type_parameters : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1987 -> - _menhir_run_1992 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1988 -> - _menhir_run_1989 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1976 -> - _menhir_run_1981 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1977 -> - _menhir_run_1978 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1740 -> - _menhir_run_1741 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1678 -> - _menhir_run_1685 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1679 -> - _menhir_run_1680 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1665 -> - _menhir_run_1672 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1666 -> - _menhir_run_1667 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1425 -> - _menhir_run_1426 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1287 -> - _menhir_run_1322 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1299 -> - _menhir_run_1301 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1992 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1992 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1993 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1992 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1989 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1989 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1990 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1989 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1990 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1682 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1990 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _v_0 = _menhir_action_469 () in - _menhir_run_1991 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1991 : - type ttv_stack. - ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = _menhir_stack in - let (MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let ts = _v in - let _v = - _menhir_action_048 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts - in - _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_extern_fun_header : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v_0 -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos_t_, t, _endpos_s_, s = - (_startpos, _v, _endpos_2, _v_0) - in - let _v = _menhir_action_720 _endpos_s_ _startpos_t_ s t in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_3 -> - let _menhir_stack = - MenhirCell1_extern_fun_header - (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - _menhir_run_2068 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState2073 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_2068 : - type ttv_stack. - (ttv_stack _menhir_cell0_EQUAL as 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_264 x in - _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ : - type ttv_stack. - (ttv_stack _menhir_cell0_EQUAL as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MULTILINE_STRING _v_0 -> - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_x_, x, xs = (_endpos_1, _v_0, _v) in - let _v = _menhir_action_265 x xs in - _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _endpos_xs_, xs = (_endpos, _v) in - let _v = _menhir_action_125 xs in - _menhir_goto_non_empty_list_MULTILINE_STRING_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_xs_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_MULTILINE_STRING_ : - type ttv_stack. - (ttv_stack _menhir_cell0_EQUAL as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2073 -> - _menhir_run_2075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState2065 -> - _menhir_run_2071 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2075 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_extern_fun_header - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_extern_fun_header - (_menhir_stack, _menhir_s, t, _startpos_t_)) = - _menhir_stack - in - let _endpos_xs_, xs = (_endpos, _v) in - let _v = _menhir_action_721 _endpos_xs_ _startpos_t_ t xs in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2071 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_EQUAL -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) = - _menhir_stack - in - let _endpos_xs_, xs = (_endpos, _v) in - let _v = _menhir_action_719 _endpos_xs_ _startpos_t_ t xs in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1981 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1981 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1982 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1981 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1982 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1669 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1982 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_467 () in - _menhir_run_1983 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1669 : - type ttv_stack. - (( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - as - 'stack) -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _menhir_stack = MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s) in - let _menhir_s = MenhirState1669 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1983 : - type ttv_stack. - ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let ts = _v in - let _v = - _menhir_action_074 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts - in - _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_fun_header : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2053 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2053 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__1_, _startpos__1_, _endpos__4_, _startpos_t_, t = - (_endpos, _startpos_0, _endpos_3, _startpos, _v) - in - let _v = - _menhir_action_722 _endpos__1_ _endpos__4_ _startpos__1_ - _startpos_t_ t - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState2053 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState2053 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState2053 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState2053 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState2053 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState2053 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState2053 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState2053 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState2053 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState2053 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2053 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v_14 -> ( - let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v_17 -> - let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _startpos_t_, t, _endpos_fname_, fname, mname = - (_startpos, _v, _endpos_19, _v_17, _v_14) - in - let _v = - _menhir_action_717 _endpos_fname_ _startpos_t_ fname mname t - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _startpos_t_, t, _endpos_s_, s = - (_startpos, _v, _endpos_16, _v_14) - in - let _v = _menhir_action_718 _endpos_s_ _startpos_t_ s t in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.MULTILINE_STRING _v_20 -> - let _menhir_stack = - MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - _menhir_run_2068 _menhir_stack _menhir_lexbuf _menhir_lexer _v_20 - MenhirState2065 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1978 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1978 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1979 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1978 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1979 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1669 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1979 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_467 () in - _menhir_run_1980 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1980 : - type ttv_stack. - ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let ts = _v in - let _v = - _menhir_action_073 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts - in - _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1741 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL as 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1741 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1741 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1741 _menhir_initp - | _ -> _eRR () - - and _menhir_run_1685 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1685 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1686 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1685 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1686 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1682 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1686 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _v_0 = _menhir_action_469 () in - _menhir_run_1687 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1687 : - type ttv_stack. - ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = _menhir_stack in - let (MenhirCell1_EXTERN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, ts = ((), _v) in - let _v = - _menhir_action_051 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts x - in - _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1680 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1680 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1681 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1680 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1681 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1682 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1681 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _v_0 = _menhir_action_469 () in - _menhir_run_1684 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1684 : - type ttv_stack. - ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = _menhir_stack in - let (MenhirCell1_EXTERN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, ts = ((), _v) in - let _v = - _menhir_action_050 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts x - in - _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1672 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1672 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1673 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1672 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1673 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1669 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1673 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_467 () in - _menhir_run_1674 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1674 : - type ttv_stack. - ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, ts = ((), _v) in - let _v = - _menhir_action_076 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts x - in - _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1667 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1667 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.THIN_ARROW -> - let _v_0 = _menhir_action_497 () in - _menhir_run_1668 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1667 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1668 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1669 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1668 _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_467 () in - _menhir_run_1671 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1671 : - type ttv_stack. - ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell1_FN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, ts = ((), _v) in - let _v = - _menhir_action_075 _endpos_ps_ _startpos_ps_ fun_binder ps quants ts x - in - _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1426 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1426 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1426 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1426 _menhir_initp - | _ -> _eRR () - - and _menhir_run_1322 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT as 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1323 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1323 _menhir_initp - | Lex_menhir_token.RPAREN -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, MenhirState1323, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1324 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_2 = _menhir_action_483 () in - _menhir_run_1325 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _v_2 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_3 -> - _menhir_run_1307 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1323 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1323 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1323 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1323 _menhir_initp - | Lex_menhir_token.LABEL _v_6 -> - _menhir_run_1310 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1323 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1304 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _menhir_stack = MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s) in - let _menhir_s = MenhirState1304 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1325 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_return_type_, return_type = (_endpos, _v) in - let _v = - _menhir_action_934 _endpos_name_ _endpos_return_type_ _startpos_name_ name - quantifiers return_type - in - _menhir_goto_trait_method_decl _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_goto_trait_method_decl : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1333 -> - _menhir_run_1334 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1726 -> - _menhir_run_1329 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1704 -> - _menhir_run_1329 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1285 -> - _menhir_run_1329 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1334 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_ - _menhir_cell0_SEMI -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_441 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1287 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1333 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_461 x xs in - _menhir_goto_non_empty_list_semis_trait_method_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_460 xs in - _menhir_goto_non_empty_list_semis_trait_method_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_1287 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState1287 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1299 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LPAREN -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis_trait_method_decl_ : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState1726 -> - _menhir_run_1728 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState1704 -> - _menhir_run_1706 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | MenhirState1285 -> - _menhir_run_1330 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1728 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = - _menhir_stack - in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_TRAIT (_menhir_stack, _startpos__2_)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _1_inlined1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_731 _1_inlined1 _endpos__1_ _endpos__7_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ name supers - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1706 : - type ttv_stack. - ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = - _menhir_stack - in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_TRAIT (_menhir_stack, _startpos__2_)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _1_inlined1, _endpos__7_ = (_v, _endpos) in - let _v = - _menhir_action_733 _1_inlined1 _endpos__7_ _endpos_attr_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ attr name supers - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1330 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_option___anonymous_2_ (_menhir_stack, _, supers)) = - _menhir_stack - in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_TRAIT (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_729 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _tok _menhir_initp _v _endpos_name_ _startpos_name_ name _startpos__2_ - _endpos supers - - and _menhir_act_goto_729 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _1 _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__7_ supers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_729 _1 _endpos__0_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name supers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_729 _1 _endpos__0_ _endpos__7_ _endpos_name_ - _startpos__2_ _startpos_name_ name supers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1329 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_option___anonymous_2_ - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_440 x in - _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1307 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_POST_LABEL (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1308 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1310 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LABEL (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1311 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1301 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1302 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1302 _menhir_initp - | Lex_menhir_token.RPAREN -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, MenhirState1302, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1303 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_2 = _menhir_action_483 () in - _menhir_run_1306 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _v_2 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_3 -> - _menhir_run_1307 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1302 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1302 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1302 _menhir_initp - | Lex_menhir_token.LIDENT _v_5 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1302 _menhir_initp - | Lex_menhir_token.LABEL _v_6 -> - _menhir_run_1310 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1302 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1306 : - type ttv_stack. - ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_return_type_, return_type = (_endpos, _v) in - let _v = - _menhir_action_932 _endpos_name_ _endpos_return_type_ _startpos_name_ name - quantifiers return_type - in - _menhir_goto_trait_method_decl _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1976 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_FN as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1976 _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _menhir_s = MenhirState1976 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1977 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - let _menhir_s = MenhirState1976 in - let _v = _menhir_action_502 () in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1678 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1678 _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _menhir_s = MenhirState1678 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1679 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - let _menhir_s = MenhirState1678 in - let _v = _menhir_action_502 () in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1665 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_FN - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1665 _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _menhir_s = MenhirState1665 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1666 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE - | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN - | Lex_menhir_token.THIN_ARROW -> - let _menhir_s = MenhirState1665 in - let _v = _menhir_action_502 () in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1427 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WITH -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_s = MenhirState1432 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.UIDENT _v_11 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState1446 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.STRING _v_12 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState1446 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_13 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - ( _menhir_stack, - _menhir_s, - _startpos_x_, - _endpos_x_ )) = - _menhir_stack - in - let ( _endpos_name_, - _startpos_name_, - name, - _endpos__3_, - x, - _endpos__1_inlined1_, - _startpos__1_inlined1_, - _endpos__4_, - _endpos_name_inlined1_, - _startpos_name_inlined1_, - name_inlined1 ) = - ( _endpos, - _startpos, - _v, - _endpos_5, - (), - _endpos_10, - _startpos_9, - _endpos_13, - _endpos_2, - _startpos_1, - _v_0 ) - in - let _v = - _menhir_action_908 _endpos__1_inlined1_ - _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_14 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState1446 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_15 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState1446 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_16 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState1446 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.LIDENT _v_17 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState1446 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.INTERP _v_18 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState1446 _menhir_initp - | Lex_menhir_token.INT _v_19 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState1446 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.FLOAT _v_20 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState1446 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | Lex_menhir_token.CHAR _v_21 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_21 MenhirState1446 _menhir_initp - | Lex_menhir_token.BYTES _v_22 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_22 MenhirState1446 _menhir_initp - | Lex_menhir_token.BYTE _v_23 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_23 MenhirState1446 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1430, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1446 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_24 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState1430 _menhir_initp - | Lex_menhir_token.LIDENT _v_25 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState1430 _menhir_initp - | Lex_menhir_token.LABEL _v_26 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState1430 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_29 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_30 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_s = MenhirState1489 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_35 = - _menhir_lexbuf.Lexing.lex_start_p - in - let _endpos_36 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.UIDENT _v_37 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_37 MenhirState1503 - _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.STRING _v_38 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_38 MenhirState1503 - _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_39 = - _menhir_lexbuf.Lexing.lex_curr_p - in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - ( _menhir_stack, - _menhir_s, - _startpos_x_, - _endpos_x_ )) = - _menhir_stack - in - let ( _endpos_name_, - _startpos_name_, - name, - _endpos__3_, - x, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_, - _endpos_name_inlined1_, - _startpos_name_inlined1_, - name_inlined1 ) = - ( _endpos, - _startpos, - _v, - _endpos_31, - (), - _endpos_39, - _endpos_36, - _startpos_35, - _endpos_2, - _startpos_1, - _v_0 ) - in - let _v = - _menhir_action_884 _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers - x - in - _menhir_goto_structure_item _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_40 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_40 MenhirState1503 - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_41 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_41 MenhirState1503 - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_42 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_42 MenhirState1503 - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.LIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_43 MenhirState1503 - _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.INTERP _v_44 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_44 MenhirState1503 - _menhir_initp - | Lex_menhir_token.INT _v_45 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_45 MenhirState1503 - _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.FLOAT _v_46 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_46 MenhirState1503 - _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | Lex_menhir_token.CHAR _v_47 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_47 MenhirState1503 - _menhir_initp - | Lex_menhir_token.BYTES _v_48 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_48 MenhirState1503 - _menhir_initp - | Lex_menhir_token.BYTE _v_49 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_49 MenhirState1503 - _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1487, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1503 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_50 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_50 MenhirState1487 _menhir_initp - | Lex_menhir_token.LIDENT _v_51 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_51 MenhirState1487 _menhir_initp - | Lex_menhir_token.LABEL _v_52 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_52 MenhirState1487 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.FOR -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_FOR (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1543 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1280 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_PLUS (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1281 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.LBRACE - | Lex_menhir_token.RBRACKET -> - let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in - let _v = _menhir_action_561 _1 _endpos__1_ _startpos__1_ in - _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1276 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PLUS -> ( - let _menhir_stack = - MenhirCell1_UIDENT - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) - in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_PLUS (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState1278 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.LBRACE - | Lex_menhir_token.RBRACKET -> - let _endpos__2_, _startpos_id_, id = (_endpos_1, _startpos, _v) in - let _v = _menhir_action_562 _endpos__2_ _startpos_id_ id in - _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ - _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.LBRACE | Lex_menhir_token.PLUS - | Lex_menhir_token.RBRACKET -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_119 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1297 -> - _menhir_run_1298 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1292 -> - _menhir_run_1293 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1275 -> - _menhir_run_1283 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1281 -> - _menhir_run_1282 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1278 -> - _menhir_run_1279 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1298 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET, - _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_luident - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let constraints = _v in - let _v = - _menhir_action_179 _endpos_name_ _startpos_name_ constraints name - in - _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET as 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1290 _menhir_initp - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1290 _menhir_initp - | Lex_menhir_token.RBRACKET -> - let x, xs = ((), _v) in - let _v = _menhir_action_140 x xs in - _menhir_goto_non_empty_list_commas_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET -> - let xs = _v in - let _v = _menhir_action_139 xs in - _menhir_goto_non_empty_list_commas_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_id_tvar_binder__ : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _, _)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_961 x in - let x = _v in - let _v = _menhir_action_503 x in - _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp - - and _menhir_run_1293 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__ - _menhir_cell0_COMMA, - _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let constraints = _v in - let _v = - _menhir_action_181 _endpos_name_ _startpos_name_ constraints name xs - in - _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1283 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_COLON -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_COLON (_menhir_stack, _menhir_s, _)) = _menhir_stack in - let _2 = _v in - let _v = _menhir_action_480 _2 in - _menhir_goto_option___anonymous_2_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_2_ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1724 -> - _menhir_run_1725 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1702 -> - _menhir_run_1703 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1274 -> - _menhir_run_1284 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1725 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_TRAIT (_menhir_stack, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos__7_, supers = (_endpos_0, _v) in - let _v = - _menhir_action_730 _endpos__1_ _endpos__7_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ name supers - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_1287 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1726 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1703 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell0_TRAIT (_menhir_stack, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__7_, supers = (_endpos_0, _v) in - let _v = - _menhir_action_732 _endpos__7_ _endpos_attr_ _endpos_name_ - _startpos__1_ _startpos__2_ _startpos_name_ attr name supers - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_1287 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1704 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1284 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT, - _menhir_box_structure ) - _menhir_cell1_luident - as - 'stack) -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_luident - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_TRAIT (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_728 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos_0 _v - | Lex_menhir_token.LIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) - in - _menhir_run_1287 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1285 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_728 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__7_ supers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_728 _endpos__0_ _endpos__7_ _endpos_name_ _startpos__2_ - _startpos_name_ name supers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_728 _endpos__0_ _endpos__7_ _endpos_name_ _startpos__2_ - _startpos_name_ name supers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1282 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_qual_ident_ty - _menhir_cell0_PLUS -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_PLUS (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let xs = _v in - let _v = _menhir_action_563 _1 _endpos__1_ _startpos__1_ xs in - _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1279 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT - _menhir_cell0_QUESTION - _menhir_cell0_PLUS -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_PLUS (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_UIDENT (_menhir_stack, _menhir_s, id, _startpos_id_, _)) = - _menhir_stack - in - let xs = _v in - let _v = _menhir_action_564 _endpos__2_inlined1_ _startpos_id_ id xs in - _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_0275 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLONCOLON (_menhir_stack, _endpos_0) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_1 -> ( - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_UIDENT (_menhir_stack, _v_1, _startpos_2, _endpos_3) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_0251 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0277 _menhir_initp - | Lex_menhir_token.AS | Lex_menhir_token.BAR - | Lex_menhir_token.COLON | Lex_menhir_token.COMMA - | Lex_menhir_token.EQUAL | Lex_menhir_token.FAT_ARROW - | Lex_menhir_token.RANGE_EXCLUSIVE - | Lex_menhir_token.RANGE_INCLUSIVE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let _v_4 = _menhir_action_473 () in - _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_3 _v_4 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0102 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_prefix_expr -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok - _menhir_initp -> - let (MenhirCell1_prefix_expr - (_menhir_stack, _menhir_s, expr, _startpos_expr_, _)) = - _menhir_stack - in - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = - _menhir_action_531 _endpos_name_ _startpos_expr_ _startpos_name_ expr name - in - _menhir_goto_postfix_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_name_ _startpos_expr_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0091 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLONCOLON -> ( - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_1 -> - let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let ( _endpos_constr_name_, - _startpos_constr_name_, - constr_name, - _endpos_type_name_, - _startpos_type_name_, - type_name ) = - (_endpos_3, _startpos_2, _v_1, _endpos, _startpos, _v) - in - let _v = - _menhir_action_608 _endpos_constr_name_ _endpos_type_name_ - _startpos_constr_name_ _startpos_type_name_ constr_name - type_name - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_constr_name_ _startpos_type_name_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let ( _endpos_type_name_, - _startpos_type_name_, - type_name, - _endpos_meth_, - _startpos_meth_, - meth ) = - (_endpos, _startpos, _v, _endpos_6, _startpos_5, _v_4) - in - let _v = - _menhir_action_636 _endpos_meth_ _endpos_type_name_ - _startpos_meth_ _startpos_type_name_ meth type_name - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_meth_ _startpos_type_name_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.LBRACE -> ( - let _startpos_7 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos_name_, _startpos_name_, name, _endpos__5_ = - (_endpos, _startpos, _v, _endpos_9) - in - let _v = - _menhir_action_566 _endpos__5_ _endpos_name_ _startpos_name_ - name - in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__5_ _startpos_name_ _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.LIDENT _v_10 -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_COLONCOLON (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_7, _endpos_8) - in - _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_10 MenhirState0095 _menhir_initp - | Lex_menhir_token.DOTDOT -> ( - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_COLONCOLON (_menhir_stack, _endpos_0) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_7, _endpos_8) - in - let _menhir_s = MenhirState0095 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_DOTDOT - (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState0144 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0047 : - type ttv_stack ttv_result. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) - in - let _menhir_s = MenhirState0048 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF - | Lex_menhir_token.EQUAL | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.LBRACE | Lex_menhir_token.QUESTION - | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH - -> - let _v = _menhir_action_489 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let _endpos_params_, params = (_endpos, _v) in - let _v = _menhir_action_508 params in - let _endpos = _endpos_params_ in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_)) = - _menhir_stack - in - let _endpos_params_, params = (_endpos, _v) in - let _v = - _menhir_action_950 _endpos_id_ _endpos_params_ _startpos_id_ id params - in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_params_ _startpos_id_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1994 : - type ttv_stack. - ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN - _menhir_cell0_STRING - _menhir_cell0_FN, - _menhir_box_structure ) - _menhir_cell1_fun_binder, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_option_parameters_ - (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = - _menhir_stack - in - let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = - _menhir_stack - in - let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = _menhir_stack in - let (MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let ts = _v in - let _v = - _menhir_action_049 _endpos_ps_ _startpos_ps_ fun_binder language ps quants - ts - in - _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1342 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_ - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1343 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.STRING _v_3 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1343 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let ( _endpos__1_inlined1_, - _startpos__1_inlined1_, - params, - _endpos__4_ ) = - (_endpos_1, _startpos_0, _v, _endpos_4) - in - let _v = - _menhir_action_734 _endpos__1_inlined1_ _endpos__4_ _startpos__1_ - _startpos__1_inlined1_ name params - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_5 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1343 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_6 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1343 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1343 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.LIDENT _v_8 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1343 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.INTERP _v_9 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1343 _menhir_initp - | Lex_menhir_token.INT _v_10 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1343 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.FLOAT _v_11 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1343 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | Lex_menhir_token.CHAR _v_12 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1343 _menhir_initp - | Lex_menhir_token.BYTES _v_13 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1343 _menhir_initp - | Lex_menhir_token.BYTE _v_14 -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 - MenhirState1343 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_option_parameters_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1343 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1417 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1417 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1420 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - _menhir_run_1349 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1420 _menhir_initp - | Lex_menhir_token.LET -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_LET (_menhir_stack, MenhirState1420, _startpos_0) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_1, _endpos_2) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1423 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> - let _endpos_name_, _startpos_name_, name, _startpos_x_, x = - (_endpos_2, _startpos_1, _v, _startpos, ()) - in - let _v = - _menhir_action_964 _endpos_name_ _startpos_name_ name x - in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf - _menhir_lexer _startpos_x_ _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.IMPL -> ( - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1420 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1425 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _ | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.UIDENT _ -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.FN -> ( - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1420 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1660 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_1661 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXTERN -> ( - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1420 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FN -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1677 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_1661 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.CONST -> ( - let _startpos_17 = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> ( - let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_CONST - (_menhir_stack, MenhirState1420, _startpos_17) - in - let _menhir_stack = - MenhirCell0_UIDENT - (_menhir_stack, _v, _startpos_18, _endpos_19) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_COLON (_menhir_stack, _endpos) - in - let _menhir_s = MenhirState1690 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> - let ( _endpos_binder_name_, - _startpos_binder_name_, - binder_name, - _startpos_x_, - x ) = - (_endpos_19, _startpos_18, _v, _startpos, ()) - in - let _v = - _menhir_action_968 _endpos_binder_name_ _startpos_binder_name_ - binder_name x - in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf - _menhir_lexer _startpos_x_ _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.ENUM | Lex_menhir_token.STRUCT | Lex_menhir_token.TRAIT - | Lex_menhir_token.TYPE | Lex_menhir_token.TYPEALIAS -> - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _v = _menhir_action_536 () in - _menhir_run_1692 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - MenhirState1420 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1349 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.READONLY -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__3_ = _endpos_0 in - let _v = _menhir_action_537 () in - _menhir_goto_pub_attr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LIDENT _v -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let _endpos__3_, attr = (_endpos_3, _v) in - let _v = _menhir_action_538 attr in - _menhir_goto_pub_attr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__3_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_pub_attr : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1420 -> - _menhir_run_1692 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1348 -> - _menhir_run_1354 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1692 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TYPEALIAS -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1693 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.TYPE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TYPE (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1696 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1697 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.TRAIT -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TRAIT (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1701 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.STRUCT -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_STRUCT (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1708 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.ENUM -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ENUM (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1711 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1354 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MUTABLE -> - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1354 _menhir_initp - | Lex_menhir_token.LIDENT _ -> - let _v_0 = _menhir_action_465 () in - _menhir_run_1356 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1354 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1356 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_MUTABLE_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _v = _v_0 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1358 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_val_header : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s - _menhir_initp -> - let _menhir_stack = - MenhirCell1_val_header (_menhir_stack, _menhir_s, _v, _startpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState2004 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1661 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET - | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_072 _endpos_name_ _startpos_name_ name in - _menhir_goto_fun_binder _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.COLONCOLON -> - let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in - let _v = _menhir_action_118 i in - _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1714 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TYPEALIAS -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1715 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.TYPE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TYPE (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1718 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _menhir_s = MenhirState1719 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.TRAIT -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_TRAIT (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1723 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.STRUCT -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_STRUCT (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1730 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.ENUM -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_ENUM (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1733 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1736 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1738 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> - let _endpos_name_, _startpos_name_, name, _startpos__2_ = - (_endpos, _startpos_0, _v, _startpos) - in - let _v = _menhir_action_962 _endpos_name_ _startpos_name_ name in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1740 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1740 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _ | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.UIDENT _ -> - _menhir_reduce_502 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1975 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) in - let _menhir_s = MenhirState1975 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_1661 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1984 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRING _v -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.FN -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in - let _menhir_s = MenhirState1986 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_1661 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1996 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _menhir_stack = - MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_s = MenhirState1996 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1999 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_CONST (_menhir_stack, _menhir_s, _startpos) - in - let _menhir_stack = - MenhirCell0_UIDENT (_menhir_stack, _v, _startpos_0, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState2001 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EQUAL -> - let ( _startpos__2_, - _endpos_binder_name_, - _startpos_binder_name_, - binder_name ) = - (_startpos, _endpos, _startpos_0, _v) - in - let _v = - _menhir_action_966 _endpos_binder_name_ _startpos_binder_name_ - binder_name - in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_2079 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_enum_header - (_menhir_stack, _menhir_s, enum_header, _startpos_enum_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_714 _endpos_deriving__ _startpos_enum_header_ deriving_ - enum_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2046 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_record_decl_field_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semis_record_decl_field_ - (_menhir_stack, _, _1)) = - _menhir_stack - in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_struct_header - (_menhir_stack, _menhir_s, struct_header, _startpos_struct_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_713 _1 _endpos_deriving__ _startpos_struct_header_ - deriving_ struct_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2043 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_struct_header - (_menhir_stack, _menhir_s, struct_header, _startpos_struct_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_712 _endpos_deriving__ _startpos_struct_header_ deriving_ - struct_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2037 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_alias_header - _menhir_cell0_EQUAL, - _menhir_box_structure ) - _menhir_cell1_type_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_type_ (_menhir_stack, _, ty, _, _)) = _menhir_stack in - let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_alias_header - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_711 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2033 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_type_header - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_706 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2032 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header, - _menhir_box_structure ) - _menhir_cell1_type_ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_type_ (_menhir_stack, _, ty, _, _)) = _menhir_stack in - let (MenhirCell1_type_header - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_707 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2029 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_option_type__ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_option_type__ (_menhir_stack, _, ty)) = _menhir_stack in - let (MenhirCell1_type_header_bang - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_708 _endpos_deriving__ _startpos_type_header_ deriving_ ty - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2026 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_LBRACE, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_semis_enum_constructor_ - _menhir_cell0_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semis_enum_constructor_ - (_menhir_stack, _, _1)) = - _menhir_stack - in - let (MenhirCell1_LBRACE (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_type_header_bang - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_710 _1 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2023 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, - _menhir_box_structure ) - _menhir_cell1_LBRACE, - _menhir_box_structure ) - _menhir_cell1_RBRACE -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_LBRACE (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_type_header_bang - (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) = - _menhir_stack - in - let _endpos_deriving__, deriving_ = (_endpos, _v) in - let _v = - _menhir_action_709 _endpos_deriving__ _startpos_type_header_ deriving_ - type_header - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_2031 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2031 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2032 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_2027 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ - -> - let x = _v in - let _v = _menhir_action_501 x in - _menhir_goto_option_type__ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_option_type__ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_type__ (_menhir_stack, _menhir_s, _v) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2028 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2029 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2002 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_CONST - _menhir_cell0_UIDENT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_UIDENT - ( _menhir_stack, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let (MenhirCell1_CONST (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let t = _v in - let _v = - _menhir_action_967 _endpos_binder_name_ _startpos_binder_name_ - binder_name t - in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_1859 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WITH -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_s = MenhirState1864 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.UIDENT _v_11 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState1878 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.STRING _v_12 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState1878 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_13 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_FOR (_menhir_stack, _)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _, - name, - _startpos_name_, - _endpos_name_ )) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_764 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ - _endpos_5 _endpos_10 _startpos_9 _endpos_13 - _endpos_2 _startpos_1 _v_0 _v quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_14 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState1878 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_15 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState1878 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_16 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState1878 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.LIDENT _v_17 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState1878 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.INTERP _v_18 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState1878 _menhir_initp - | Lex_menhir_token.INT _v_19 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState1878 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.FLOAT _v_20 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState1878 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | Lex_menhir_token.CHAR _v_21 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_21 MenhirState1878 _menhir_initp - | Lex_menhir_token.BYTES _v_22 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_22 MenhirState1878 _menhir_initp - | Lex_menhir_token.BYTE _v_23 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_23 MenhirState1878 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1862, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1878 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_24 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState1862 _menhir_initp - | Lex_menhir_token.LIDENT _v_25 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState1862 _menhir_initp - | Lex_menhir_token.LABEL _v_26 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState1862 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_29 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_30 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_s = MenhirState1921 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_35 = - _menhir_lexbuf.Lexing.lex_start_p - in - let _endpos_36 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.UIDENT _v_37 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_37 MenhirState1935 - _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.STRING _v_38 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_38 MenhirState1935 - _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_39 = - _menhir_lexbuf.Lexing.lex_curr_p - in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_FOR (_menhir_stack, _)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _, - name, - _startpos_name_, - _endpos_name_ )) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _menhir_s, _startpos__2_)) - = - _menhir_stack - in - _menhir_act_goto_740 _menhir_stack - _menhir_lexbuf _menhir_lexer _menhir_s _tok - _menhir_initp _endpos_name_ _startpos_name_ - name _startpos__2_ _endpos_31 _endpos_39 - _endpos_36 _startpos_35 _endpos_2 _startpos_1 - _v_0 _v quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_40 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_40 MenhirState1935 - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_41 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_41 MenhirState1935 - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_42 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_42 MenhirState1935 - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.LIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_43 MenhirState1935 - _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.INTERP _v_44 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_44 MenhirState1935 - _menhir_initp - | Lex_menhir_token.INT _v_45 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_45 MenhirState1935 - _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.FLOAT _v_46 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_46 MenhirState1935 - _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | Lex_menhir_token.CHAR _v_47 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_47 MenhirState1935 - _menhir_initp - | Lex_menhir_token.BYTES _v_48 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_48 MenhirState1935 - _menhir_initp - | Lex_menhir_token.BYTE _v_49 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_49 MenhirState1935 - _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1919, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1935 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_50 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_50 MenhirState1919 _menhir_initp - | Lex_menhir_token.LIDENT _v_51 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_51 MenhirState1919 _menhir_initp - | Lex_menhir_token.LABEL _v_52 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1859) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_52 MenhirState1919 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_act_goto_764 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ - _endpos__1_inlined1_ _startpos__1_inlined1_ _endpos__4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_764 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_764 _endpos__0_ _endpos__1_inlined1_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_740 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined2_ _startpos__1_inlined2_ _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_740 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_740 _endpos__0_ _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1739 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let t = _v in - let _v = _menhir_action_963 _endpos_name_ _startpos_name_ name t in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_1691 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_CONST - _menhir_cell0_UIDENT - _menhir_cell0_COLON - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_UIDENT - ( _menhir_stack, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let (MenhirCell1_CONST (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, t = ((), _v) in - let _v = - _menhir_action_969 _endpos_binder_name_ _startpos_binder_name_ - binder_name t x - in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_1544 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WITH -> ( - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_s = MenhirState1549 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.UIDENT _v_11 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_11 MenhirState1563 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.STRING _v_12 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_12 MenhirState1563 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_13 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_FOR (_menhir_stack, _)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _, - name, - _startpos_name_, - _endpos_name_ )) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - ( _menhir_stack, - _menhir_s, - _startpos_x_, - _endpos_x_ )) = - _menhir_stack - in - let ( _endpos__3_, - x, - _endpos__1_inlined1_, - _startpos__1_inlined1_, - _endpos__4_, - _endpos_name_inlined1_, - _startpos_name_inlined1_, - name_inlined1, - self_ty ) = - ( _endpos_5, - (), - _endpos_10, - _startpos_9, - _endpos_13, - _endpos_2, - _startpos_1, - _v_0, - _v ) - in - let _v = - _menhir_action_812 _endpos__1_inlined1_ - _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_14 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_14 MenhirState1563 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_15 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_15 MenhirState1563 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_16 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_16 MenhirState1563 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.LIDENT _v_17 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_17 MenhirState1563 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.INTERP _v_18 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_18 MenhirState1563 _menhir_initp - | Lex_menhir_token.INT _v_19 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_19 MenhirState1563 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.FLOAT _v_20 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_20 MenhirState1563 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | Lex_menhir_token.CHAR _v_21 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_21 MenhirState1563 _menhir_initp - | Lex_menhir_token.BYTES _v_22 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_22 MenhirState1563 _menhir_initp - | Lex_menhir_token.BYTE _v_23 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_23 MenhirState1563 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_3, _endpos_4) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1547, _endpos_5) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_9, _endpos_10) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1563 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_24 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0617 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_24 MenhirState1547 _menhir_initp - | Lex_menhir_token.LIDENT _v_25 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0624 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_25 MenhirState1547 _menhir_initp - | Lex_menhir_token.LABEL _v_26 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_LPAREN (_menhir_stack, _startpos_3, _endpos_4) - in - _menhir_run_0162 _menhir_stack _menhir_lexbuf _menhir_lexer - _v_26 MenhirState1547 _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> ( - let _startpos_29 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_30 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_s = MenhirState1606 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf - _menhir_lexer _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.LBRACE -> ( - let _startpos_35 = - _menhir_lexbuf.Lexing.lex_start_p - in - let _endpos_36 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.UIDENT _v_37 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_37 MenhirState1620 - _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.STRING _v_38 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_38 MenhirState1620 - _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_39 = - _menhir_lexbuf.Lexing.lex_curr_p - in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_FOR (_menhir_stack, _)) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - ( _menhir_stack, - _, - name, - _startpos_name_, - _endpos_name_ )) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL - (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - ( _menhir_stack, - _menhir_s, - _startpos_x_, - _endpos_x_ )) = - _menhir_stack - in - let ( _endpos__3_, - x, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_, - _endpos_name_inlined1_, - _startpos_name_inlined1_, - name_inlined1, - self_ty ) = - ( _endpos_31, - (), - _endpos_39, - _endpos_36, - _startpos_35, - _endpos_2, - _startpos_1, - _v_0, - _v ) - in - let _v = - _menhir_action_788 _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_40 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_40 MenhirState1620 - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_41 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_41 MenhirState1620 - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_42 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_42 MenhirState1620 - _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.LIDENT _v_43 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_43 MenhirState1620 - _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.INTERP _v_44 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_44 MenhirState1620 - _menhir_initp - | Lex_menhir_token.INT _v_45 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_45 MenhirState1620 - _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.FLOAT _v_46 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_46 MenhirState1620 - _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.CONTINUE -> + and _menhir_goto_pub_attr : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1127 -> + _menhir_run_1128 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0848 -> + _menhir_run_0849 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0776 -> + _menhir_run_0782 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1128 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1129 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TYPE -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1132 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState1133 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.TRAITALIAS -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAITALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1137 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TRAIT -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAIT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1141 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRUCT -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_STRUCT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1147 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LET -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_14 -> ( + let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_pub_attr + (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_stack = + MenhirCell0_LET (_menhir_stack, _startpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_14, _startpos_15, _endpos_16) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1152 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_PUB + (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) + = + _menhir_stack + in + let ( _endpos_name_, + _startpos_name_, + name, + _endpos_attr_, + attr ) = + (_endpos_16, _startpos_15, _v_14, _endpos, _v) + in + let _v = + _menhir_action_586 _1 _endpos_attr_ _endpos_name_ + _startpos__1_inlined1_ _startpos_name_ attr name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.IMPL -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IMPL (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1154 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1171 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXTERN -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_EXTERN (_menhir_stack, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1178 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1183 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ENUM -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_ENUM (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1189 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONST -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_38 -> ( + let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_pub_attr + (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_stack = + MenhirCell0_CONST (_menhir_stack, _startpos) + in + let _menhir_stack = + MenhirCell0_UIDENT + (_menhir_stack, _v_38, _startpos_39, _endpos_40) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1194 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_PUB + (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) + = + _menhir_stack + in + let ( _endpos_binder_name_, + _startpos_binder_name_, + binder_name, + _endpos_attr_, + attr ) = + (_endpos_40, _startpos_39, _v_38, _endpos, _v) + in + let _v = + _menhir_action_598 _1 _endpos_attr_ + _endpos_binder_name_ _startpos__1_inlined1_ + _startpos_binder_name_ attr binder_name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_ASYNC (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1197 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_reduce_334 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + + and _menhir_run_0900 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL | Lex_menhir_token.EXCLAMATION + | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_088 _endpos_name_ _startpos_name_ name in + _menhir_goto_fun_binder _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_fun_binder : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1325 -> + _menhir_run_1326 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1311 -> + _menhir_run_1312 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1299 -> + _menhir_run_1300 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1272 -> + _menhir_run_1273 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1258 -> + _menhir_run_1259 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1246 -> + _menhir_run_1247 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1197 -> + _menhir_run_1198 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1183 -> + _menhir_run_1184 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1171 -> + _menhir_run_1172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1062 -> + _menhir_run_1063 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1047 -> + _menhir_run_1048 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1035 -> + _menhir_run_1036 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1008 -> + _menhir_run_1009 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0994 -> + _menhir_run_0995 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0982 -> + _menhir_run_0983 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0933 -> + _menhir_run_0934 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0917 -> + _menhir_run_0918 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0899 -> + _menhir_run_0904 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1326 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1326 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1327 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1326 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1312 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1312 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1313 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1312 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1313 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1313 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1313 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1300 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1300 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1301 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1300 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1301 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1301 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1301 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1273 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1273 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1274 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1273 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1274 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1274 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1274 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1259 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1259 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1260 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1259 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1260 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1260 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1260 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1247 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1247 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1248 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1247 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1248 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1248 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1248 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1198 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1198 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1199 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1198 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1199 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1199 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1199 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1184 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1184 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1185 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1184 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1185 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1185 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1185 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1172 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1172 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1173 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1172 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1173 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1173 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1173 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1063 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1063 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1064 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1063 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1064 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_ASYNC _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1064 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1064 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1048 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1048 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1049 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1048 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1049 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1049 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1049 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1036 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_FN as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1036 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1037 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1036 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1037 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1037 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1037 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1009 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ASYNC + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1009 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_1010 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1009 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1010 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1010 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState1010 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0995 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0995 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0996 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0995 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0996 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0996 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState0996 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0983 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0983 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0984 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0983 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0984 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0984 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState0984 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0934 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0934 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0935 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0934 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0935 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0935 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState0935 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0918 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0918 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACKET + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0919 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0918 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0919 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0919 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState0919 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0904 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fun_binder (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0904 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0905 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0904 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0905 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0905 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.LPAREN | Lex_menhir_token.THIN_ARROW -> + let _menhir_s = MenhirState0905 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0849 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0850 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TYPE -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0853 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0854 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.TRAITALIAS -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAITALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0858 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TRAIT -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAIT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0862 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRUCT -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_STRUCT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0868 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LET -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_14 -> ( + let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_pub_attr + (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_stack = + MenhirCell0_LET (_menhir_stack, _startpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_14, _startpos_15, _endpos_16) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0873 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let (MenhirCell1_PUB + (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let ( _endpos_name_, + _startpos_name_, + name, + _endpos_attr_, + attr ) = + (_endpos_16, _startpos_15, _v_14, _endpos, _v) + in + let _v = + _menhir_action_580 _endpos_attr_ _endpos_name_ + _startpos__1_ _startpos_name_ attr name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.IMPL -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IMPL (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0875 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0899 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXTERN -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_EXTERN (_menhir_stack, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0912 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0917 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ENUM -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_ENUM (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0925 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONST -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_38 -> ( + let _startpos_39 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_40 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_pub_attr + (_menhir_stack, _menhir_s, _v, _endpos) + in + let _menhir_stack = + MenhirCell0_CONST (_menhir_stack, _startpos) + in + let _menhir_stack = + MenhirCell0_UIDENT + (_menhir_stack, _v_38, _startpos_39, _endpos_40) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0930 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let (MenhirCell1_PUB + (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let ( _endpos_binder_name_, + _startpos_binder_name_, + binder_name, + _endpos_attr_, + attr ) = + (_endpos_40, _startpos_39, _v_38, _endpos, _v) + in + let _v = + _menhir_action_592 _endpos_attr_ _endpos_binder_name_ + _startpos__1_ _startpos_binder_name_ attr binder_name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> ( + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_ASYNC (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0933 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0782 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PUB as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_pub_attr (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MUTABLE -> + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0782 _menhir_initp + | Lex_menhir_token.LIDENT _ -> + let _v_0 = _menhir_action_288 () in + _menhir_run_0784 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0782 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0784 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _v = _v_0 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0786 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0939 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0940 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TYPE -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_TYPE (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0943 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0944 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.TRAITALIAS -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAITALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0948 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TRAIT -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_TRAIT (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0952 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRUCT -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_STRUCT (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0958 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LET -> ( + let _startpos_7 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_8 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LET (_menhir_stack, _startpos_7) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_8, _endpos_9) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0963 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _endpos__1_, + _startpos__1_, + _endpos_name_, + _startpos_name_, + name ) = + (_endpos, _startpos, _endpos_9, _startpos_8, _v) + in + let _v = + _menhir_action_578 _endpos__1_ _endpos_name_ _startpos__1_ + _startpos_name_ name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.IMPL -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_IMPL (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0965 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState0982 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXTERN -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_EXTERN (_menhir_stack, _startpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0989 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState0994 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ENUM -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_ENUM (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1000 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONST -> ( + let _startpos_26 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> ( + let _startpos_27 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_CONST (_menhir_stack, _startpos_26) + in + let _menhir_stack = + MenhirCell0_UIDENT + (_menhir_stack, _v, _startpos_27, _endpos_28) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1005 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _endpos__1_, + _startpos__1_, + _endpos_binder_name_, + _startpos_binder_name_, + binder_name ) = + (_endpos, _startpos, _endpos_28, _startpos_27, _v) + in + let _v = + _menhir_action_590 _endpos__1_ _endpos_binder_name_ + _startpos__1_ _startpos_binder_name_ binder_name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> ( + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_ASYNC (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1008 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1014 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos_0, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1016 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let _endpos_name_, _startpos_name_, name, _startpos__3_ = + (_endpos, _startpos_0, _v, _startpos) + in + let _v = + _menhir_action_576 _endpos_name_ _startpos_name_ name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1018 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState1018 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1035 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState1035 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1041 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_TYPE (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1042 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1047 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1053 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState1053 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1056 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_CONST (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_stack = + MenhirCell0_UIDENT (_menhir_stack, _v, _startpos_0, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1058 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _startpos__3_, + _endpos_binder_name_, + _startpos_binder_name_, + binder_name ) = + (_startpos, _endpos, _startpos_0, _v) + in + let _v = + _menhir_action_588 _endpos_binder_name_ _startpos_binder_name_ + binder_name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1060 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_252 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_non_empty_list_rev___anonymous_5_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s + _tok _menhir_initp + + and _menhir_goto_non_empty_list_rev___anonymous_5_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.ATTRIBUTE _v_0 -> + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos__1_, _startpos__1_, _1, _startpos_xs_, xs = + (_endpos_2, _startpos_1, _v_0, _startpos, _v) + in + let _v = _menhir_action_253 _1 _endpos__1_ _startpos__1_ xs in + _menhir_goto_non_empty_list_rev___anonymous_5_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos_xs_ _v + _menhir_s _tok _menhir_initp + | Lex_menhir_token.ASYNC | Lex_menhir_token.CONST + | Lex_menhir_token.ENUM | Lex_menhir_token.EXTERN + | Lex_menhir_token.FN | Lex_menhir_token.IMPL | Lex_menhir_token.LET + | Lex_menhir_token.PRIV | Lex_menhir_token.PUB + | Lex_menhir_token.STRUCT | Lex_menhir_token.TEST + | Lex_menhir_token.TRAIT | Lex_menhir_token.TRAITALIAS + | Lex_menhir_token.TYPE | Lex_menhir_token.TYPEALIAS -> ( + let _endpos_xs_, _startpos_xs_, xs = (_endpos, _startpos, _v) in + let _v = _menhir_action_187 xs in + let _endpos, _startpos = (_endpos_xs_, _startpos_xs_) in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1102 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TYPE -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1105 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState1106 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.TRAITALIAS -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAITALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1110 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TRAIT -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAIT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1114 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TEST -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos_16 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_17 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_TEST (_menhir_stack, _startpos_16) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v_18 -> + _menhir_run_0750 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_18 MenhirState1120 _menhir_initp + | Lex_menhir_token.LBRACE | Lex_menhir_token.LPAREN -> + let _v_19 = _menhir_action_328 () in + _menhir_run_1121 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_17 _v_19 MenhirState1120 _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRUCT -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_STRUCT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1124 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.PUB -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos_23 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_24 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_PUB (_menhir_stack, _startpos_23) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0777 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1127 _menhir_initp + | Lex_menhir_token.ASYNC | Lex_menhir_token.CONST + | Lex_menhir_token.ENUM | Lex_menhir_token.EXTERN + | Lex_menhir_token.FN | Lex_menhir_token.IMPL + | Lex_menhir_token.LET | Lex_menhir_token.STRUCT + | Lex_menhir_token.TRAIT | Lex_menhir_token.TRAITALIAS + | Lex_menhir_token.TYPE | Lex_menhir_token.TYPEALIAS -> + let _v_25 = _menhir_action_368 () in + _menhir_run_1128 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_24 _v_25 MenhirState1127 _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.PRIV -> ( + let _startpos_26 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_27 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPEALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1204 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TYPE -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1207 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState1208 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.TRAITALIAS -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAITALIAS (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1212 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.TRAIT -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TRAIT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1216 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRUCT -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_STRUCT (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1222 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.LET -> ( + let _startpos_47 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_48 -> ( + let _startpos_49 = + _menhir_lexbuf.Lexing.lex_start_p + in + let _endpos_50 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( let _menhir_stack = - MenhirCell1_type_ + MenhirCell1_non_empty_list___anonymous_5_ ( _menhir_stack, _menhir_s, _v, @@ -189322,106 +46387,243 @@ include struct _endpos ) in let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) in let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp - | Lex_menhir_token.CHAR _v_47 -> - let _menhir_stack = - MenhirCell1_type_ - ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) + MenhirCell0_LET (_menhir_stack, _startpos_47) in let _menhir_stack = MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) - in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_47 MenhirState1620 - _menhir_initp - | Lex_menhir_token.BYTES _v_48 -> - let _menhir_stack = - MenhirCell1_type_ ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) + _v_48, + _startpos_49, + _endpos_50 ) in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) + let _endpos = + _menhir_lexbuf.Lexing.lex_curr_p in let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) + MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) + let _menhir_s = MenhirState1227 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _startpos__1_, + _1, + _endpos_name_, + _startpos_name_, + name, + _endpos__1_inlined1_, + _startpos__1_inlined1_ ) = + ( _startpos, + _v, + _endpos_50, + _startpos_49, + _v_48, + _endpos_27, + _startpos_26 ) in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + let _v = + _menhir_action_584 _1 _endpos__1_inlined1_ + _endpos_name_ _startpos__1_inlined1_ + _startpos_name_ name in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) + _menhir_goto_val_header _menhir_stack + _menhir_lexbuf _menhir_lexer _startpos__1_ _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.IMPL -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IMPL (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1229 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ + | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1246 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXTERN -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_EXTERN (_menhir_stack, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1253 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING + (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = + _menhir_lexbuf.Lexing.lex_start_p in let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) + MenhirCell0_FN (_menhir_stack, _startpos) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_48 MenhirState1620 - _menhir_initp - | Lex_menhir_token.BYTE _v_49 -> + let _menhir_s = MenhirState1258 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ENUM -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_ENUM (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1264 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONST -> ( + let _startpos_76 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_77 -> ( + let _startpos_78 = + _menhir_lexbuf.Lexing.lex_start_p + in + let _endpos_79 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( let _menhir_stack = - MenhirCell1_type_ + MenhirCell1_non_empty_list___anonymous_5_ ( _menhir_stack, _menhir_s, _v, @@ -189429,271 +46631,9377 @@ include struct _endpos ) in let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) - in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) - in - let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) - in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) in let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) + MenhirCell0_CONST (_menhir_stack, _startpos_76) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_49 MenhirState1620 - _menhir_initp - | Lex_menhir_token.BREAK -> let _menhir_stack = - MenhirCell1_type_ + MenhirCell0_UIDENT ( _menhir_stack, - _menhir_s, - _v, - _startpos, - _endpos ) - in - let _menhir_stack = - MenhirCell1_WITH - (_menhir_stack, MenhirState1544) - in - let _menhir_stack = - MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) + _v_77, + _startpos_78, + _endpos_79 ) in - let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) + let _endpos = + _menhir_lexbuf.Lexing.lex_curr_p in let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_stack = - MenhirCell1_RPAREN - (_menhir_stack, MenhirState1604, _endpos_31) + let _menhir_s = MenhirState1269 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s + _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack + _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _startpos__1_, + _1, + _endpos_binder_name_, + _startpos_binder_name_, + binder_name, + _endpos__1_inlined1_, + _startpos__1_inlined1_ ) = + ( _startpos, + _v, + _endpos_79, + _startpos_78, + _v_77, + _endpos_27, + _startpos_26 ) in - let _menhir_stack = - MenhirCell0_LBRACE - (_menhir_stack, _startpos_35, _endpos_36) + let _v = + _menhir_action_596 _1 _endpos__1_inlined1_ + _endpos_binder_name_ _startpos__1_inlined1_ + _startpos_binder_name_ binder_name in - _menhir_run_0584 _menhir_stack _menhir_lexbuf - _menhir_lexer MenhirState1620 _menhir_initp + _menhir_goto_val_header _menhir_stack + _menhir_lexbuf _menhir_lexer _startpos__1_ _v + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_PRIV + (_menhir_stack, _startpos_26, _endpos_27) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_ASYNC (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1272 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.LET -> ( + let _startpos_90 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_91 -> ( + let _startpos_92 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_93 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + ( _menhir_stack, + _menhir_s, + _v, + _startpos, + _endpos ) + in + let _menhir_stack = + MenhirCell0_LET (_menhir_stack, _startpos_90) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_91, _startpos_92, _endpos_93) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1280 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _startpos__1_, + _1, + _endpos_name_, + _startpos_name_, + name ) = + (_startpos, _v, _endpos_93, _startpos_92, _v_91) + in + let _v = + _menhir_action_582 _1 _endpos_name_ + _startpos_name_ name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.IMPL -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IMPL (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1282 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.LIDENT _ + | Lex_menhir_token.PACKAGE_NAME _ + | Lex_menhir_token.UIDENT _ -> + _menhir_reduce_334 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FN -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1299 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.EXTERN -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_EXTERN (_menhir_stack, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_TYPE (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1306 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.STRING _v -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_STRING + (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1311 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ENUM -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_ENUM (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1317 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CONST -> ( + let _startpos_119 = _menhir_lexbuf.Lexing.lex_start_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_120 -> ( + let _startpos_121 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_122 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + ( _menhir_stack, + _menhir_s, + _v, + _startpos, + _endpos ) + in + let _menhir_stack = + MenhirCell0_CONST (_menhir_stack, _startpos_119) + in + let _menhir_stack = + MenhirCell0_UIDENT + ( _menhir_stack, + _v_120, + _startpos_121, + _endpos_122 ) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1322 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp | _ -> _eRR ()) + | Lex_menhir_token.EQUAL -> + let ( _startpos__1_, + _1, + _endpos_binder_name_, + _startpos_binder_name_, + binder_name ) = + (_startpos, _v, _endpos_122, _startpos_121, _v_120) + in + let _v = + _menhir_action_594 _1 _endpos_binder_name_ + _startpos_binder_name_ binder_name + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> ( + let _menhir_stack = + MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_ASYNC (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell0_FN (_menhir_stack, _startpos) + in + let _menhir_s = MenhirState1325 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp | _ -> _eRR ()) - | Lex_menhir_token.POST_LABEL _v_50 -> + | _ -> _eRR ()) + | _ -> _menhir_fail ()) + | _ -> _eRR () + + and _menhir_run_1061 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_ASYNC (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.FN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = MenhirCell0_FN (_menhir_stack, _startpos) in + let _menhir_s = MenhirState1062 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0900 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1309 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_EXTERN (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_488 _1 _endpos__1_ _endpos_deriving__ _endpos_tycon_ + _startpos__1_ _startpos__3_ _startpos_tycon_ deriving_ params + tycon + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1256 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_EXTERN (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_489 _1 _endpos__1_ _endpos__1_inlined1_ + _endpos_deriving__ _endpos_tycon_ _startpos__1_ + _startpos__1_inlined1_ _startpos__3_ _startpos_tycon_ deriving_ + params tycon + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1181 : type ttv_stack. + ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_EXTERN (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_490 _1 _endpos__1_ _endpos_attr_ _endpos_deriving__ + _endpos_tycon_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_tycon_ attr deriving_ params tycon + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1086 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_alias_header + _menhir_cell0_EQUAL, + _menhir_box_structure ) + _menhir_cell1_type_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_type_ (_menhir_stack, _, ty, _, _)) = + _menhir_stack + in + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_alias_header + (_menhir_stack, _menhir_s, type_header, _startpos_type_header_)) + = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_494 _endpos_deriving__ _startpos_type_header_ + deriving_ ty type_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1082 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_type_header + ( _menhir_stack, + _menhir_s, + type_header, + _startpos_type_header_, + _ )) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_484 _endpos_deriving__ _startpos_type_header_ + deriving_ type_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1081 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header, + _menhir_box_structure ) + _menhir_cell1_type_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_type_ (_menhir_stack, _, ty, _, _)) = + _menhir_stack + in + let (MenhirCell1_type_header + ( _menhir_stack, + _menhir_s, + type_header, + _startpos_type_header_, + _ )) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_491 _endpos_deriving__ _startpos_type_header_ + deriving_ ty type_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1078 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_option_type__ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_type__ (_menhir_stack, _, ty)) = + _menhir_stack + in + let (MenhirCell1_type_header_bang + ( _menhir_stack, + _menhir_s, + type_header, + _startpos_type_header_, + _ )) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_492 _endpos_deriving__ _startpos_type_header_ + deriving_ ty type_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1075 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_semis_enum_constructor_ (_menhir_stack, _, cs)) + = + _menhir_stack + in + let (MenhirCell1_LBRACE (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_type_header_bang + ( _menhir_stack, + _menhir_s, + type_header, + _startpos_type_header_, + _ )) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_493 _endpos_deriving__ _startpos_type_header_ cs + deriving_ type_header + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1045 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + _menhir_act_goto_485 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__3_ _endpos_tycon_ + _startpos_tycon_ tycon params _endpos _v + + and _menhir_act_goto_485 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__3_ -> + fun _endpos_tycon_ -> + fun _startpos_tycon_ -> + fun tycon -> + fun params -> + fun _endpos_deriving__ -> + fun deriving_ -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_485 _endpos__0_ _endpos_deriving__ + _endpos_tycon_ _startpos__3_ _startpos_tycon_ deriving_ + params tycon + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_485 _endpos__0_ _endpos_deriving__ + _endpos_tycon_ _startpos__3_ _startpos_tycon_ deriving_ + params tycon + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0992 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_EXTERN (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + _menhir_act_goto_486 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos__1_ _startpos__1_ _startpos__3_ + _endpos_tycon_ _startpos_tycon_ tycon params _endpos _v + + and _menhir_act_goto_486 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__1_ -> + fun _startpos__1_ -> + fun _startpos__3_ -> + fun _endpos_tycon_ -> + fun _startpos_tycon_ -> + fun tycon -> + fun params -> + fun _endpos_deriving__ -> + fun deriving_ -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_486 _endpos__0_ _endpos__1_ + _endpos_deriving__ _endpos_tycon_ _startpos__1_ + _startpos__3_ _startpos_tycon_ deriving_ params tycon + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_486 _endpos__0_ _endpos__1_ + _endpos_deriving__ _endpos_tycon_ _startpos__1_ + _startpos__3_ _startpos_tycon_ deriving_ params tycon + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0915 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters_no_constraints -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _, params, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_EXTERN (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + _menhir_act_goto_487 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__1_ _startpos__3_ + _endpos_tycon_ _startpos_tycon_ tycon _endpos_attr_ attr params + _endpos _v + + and _menhir_act_goto_487 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__1_ -> + fun _startpos__3_ -> + fun _endpos_tycon_ -> + fun _startpos_tycon_ -> + fun tycon -> + fun _endpos_attr_ -> + fun attr -> + fun params -> + fun _endpos_deriving__ -> + fun deriving_ -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_487 _endpos__0_ _endpos_attr_ + _endpos_deriving__ _endpos_tycon_ _startpos__1_ + _startpos__3_ _startpos_tycon_ attr deriving_ params + tycon + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_487 _endpos__0_ _endpos_attr_ + _endpos_deriving__ _endpos_tycon_ _startpos__1_ + _startpos__3_ _startpos_tycon_ attr deriving_ params + tycon + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0836 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_list_semis_enum_constructor_ + _menhir_cell0_RBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RBRACE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_semis_enum_constructor_ (_menhir_stack, _, cs)) + = + _menhir_stack + in + let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_165 _endpos_tycon_ _startpos_tycon_ cs deriving_ + tycon + in + _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_deriving__ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0772 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_type_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_type_ (_menhir_stack, _, ty, _, _)) = + _menhir_stack + in + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_deriving__, deriving_ = (_endpos, _v) in + let _v = + _menhir_action_166 _endpos_tycon_ _startpos_tycon_ deriving_ ty + tycon + in + _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_deriving__ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_1073 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, + _menhir_box_structure ) + _menhir_cell1_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_semis_enum_constructor_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1074 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0834 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_semis_enum_constructor_ + (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0835 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_0836 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0832 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_, + _menhir_box_structure ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_257 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0767 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_deriving_directive_ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_deriving_directive_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_192 xs in + let _1 = _v in + let _v = _menhir_action_129 _1 in + _menhir_goto_list_commas_deriving_directive_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp + + and _menhir_run_0732 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_trait_method_param_ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_trait_method_param_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_204 xs in + let _1 = _v in + let _v = _menhir_action_141 _1 in + _menhir_goto_list_commas_trait_method_param_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_list_commas_trait_method_param_ : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_list_commas_trait_method_param_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0736 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v = _menhir_action_312 () in + _menhir_goto_option___anonymous_6_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_goto_option___anonymous_6_ : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_list_commas_trait_method_param_ + _menhir_cell0_RPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_list_commas_trait_method_param_ + (_menhir_stack, _, params)) = + _menhir_stack + in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_optional_type_parameters + (_menhir_stack, _, quantifiers)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) + = + _menhir_stack + in + let _endpos_return_type_, return_type = (_endpos, _v) in + let _v = + _menhir_action_530 _endpos_name_ _endpos_return_type_ + _startpos_name_ has_error name params quantifiers return_type + in + _menhir_goto_trait_method_decl _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_trait_method_decl : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0744 -> + _menhir_run_0745 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1219 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1144 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1117 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0955 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0865 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0707 -> + _menhir_run_0740 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0745 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_trait_method_decl_, + _menhir_box_structure ) + _menhir_cell1_SEMI -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_269 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ : + type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_trait_method_decl_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0743, _v_0, _endpos) + in + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0744 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_0746 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0746 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0708 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LIDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0708 _menhir_initp + | Lex_menhir_token.LBRACKET | Lex_menhir_token.LPAREN -> + let _v_0 = _menhir_action_337 () in + _menhir_run_0709 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v_0 MenhirState0708 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0709 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT as 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0710 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0709 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_s = MenhirState0709 in + let _v = _menhir_action_334 () in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0740 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_option___anonymous_2_ + _menhir_cell0_LBRACE + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_268 x in + _menhir_goto_non_empty_list_semi_rev_aux_trait_method_decl_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0718 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_196 xs in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_575 x in + let x = _v in + let _v = _menhir_action_335 x in + _menhir_goto_option_type_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0577 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_parameter_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_parameter_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_200 xs in + let _1 = _v in + let _v = _menhir_action_135 _1 in + _menhir_goto_list_commas_parameter_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_goto_list_commas_parameter_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, x = (_endpos, _v) in + let _v = _menhir_action_357 x in + _menhir_goto_parameters _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__3_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_parameters : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1295 -> + _menhir_run_1296 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1287 -> + _menhir_run_1288 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1242 -> + _menhir_run_1243 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1234 -> + _menhir_run_1235 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1167 -> + _menhir_run_1168 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1159 -> + _menhir_run_1160 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1031 -> + _menhir_run_1032 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1023 -> + _menhir_run_1024 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0978 -> + _menhir_run_0979 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0970 -> + _menhir_run_0971 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0893 -> + _menhir_run_0894 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0880 -> + _menhir_run_0881 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1328 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1314 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1302 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1275 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1261 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1249 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1200 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1186 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1174 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1121 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1065 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1050 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1038 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1011 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0997 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0985 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0936 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0920 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0906 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0751 -> + _menhir_run_0752 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0033 -> + _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0538 -> + _menhir_run_0539 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0528 -> + _menhir_run_0530 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0104 -> + _menhir_run_0106 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1296 : type ttv_stack. + (( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1296 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_1297 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1296 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0895 : type ttv_stack. + (( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0895 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1297 : type ttv_stack. + (( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1297 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1297 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0885 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_code_, code = (_endpos_0, _v) in + let _v = _menhir_action_109 code in + _menhir_goto_impl_body _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_code_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1288 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1288 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_1289 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1288 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0882 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0882 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1289 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1289 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1289 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1243 : type ttv_stack. + (( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1243 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_1244 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1243 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1244 : type ttv_stack. + (( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1244 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1244 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1235 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1235 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_1236 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1235 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1236 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1236 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1236 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1168 : type ttv_stack. + (( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1168 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_1169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1168 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1169 : type ttv_stack. + (( ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1169 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1169 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1160 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1160 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_1161 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1160 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1161 : type ttv_stack. + (( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1161 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1161 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1032 : type ttv_stack. + (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1032 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_1033 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1032 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1033 : type ttv_stack. + (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1033 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1033 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1024 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1024 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_1025 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState1024 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1025 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1025 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1025 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0979 : type ttv_stack. + (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0979 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_0980 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0979 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0980 : type ttv_stack. + (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0980 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0980 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0971 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0971 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_0972 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0971 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0972 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0972 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0972 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0894 : type ttv_stack. + (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0895 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0894 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_308 () in + _menhir_run_0897 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0894 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0897 : type ttv_stack. + (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_3_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0897 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0897 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0881 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0882 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0881 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_310 () in + _menhir_run_0884 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 MenhirState0881 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0884 : type ttv_stack. + (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_4_ + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0884 _menhir_initp + | Lex_menhir_token.EQUAL -> + _menhir_run_0885 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0884 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0752 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_x_, _startpos_x_, x = (_endpos, _startpos, _v) in + let _v = _menhir_action_331 x in + _menhir_goto_option_parameters_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_option_parameters_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1328 -> + _menhir_run_1329 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1314 -> + _menhir_run_1315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1302 -> + _menhir_run_1303 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1275 -> + _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1261 -> + _menhir_run_1262 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1249 -> + _menhir_run_1250 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1200 -> + _menhir_run_1201 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1186 -> + _menhir_run_1187 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1174 -> + _menhir_run_1175 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1121 -> + _menhir_run_1122 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1065 -> + _menhir_run_1066 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1050 -> + _menhir_run_1051 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1038 -> + _menhir_run_1039 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1011 -> + _menhir_run_1012 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0997 -> + _menhir_run_0998 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0985 -> + _menhir_run_0986 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0936 -> + _menhir_run_0937 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0920 -> + _menhir_run_0921 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0906 -> + _menhir_run_0907 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0751 -> + _menhir_run_0753 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1329 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1329 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1330 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0908 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ + as + 'stack) -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0908 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1330 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_ASYNC (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_095 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error + ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_fun_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_fun_header (_menhir_stack, _menhir_s, _v, _startpos) + in + _menhir_run_0754 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1331 _menhir_initp + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v_0 -> ( + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v_3 -> + let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos_t_, t, _endpos_fname_, fname, mname = + (_startpos, _v, _endpos_5, _v_3, _v_0) + in + let _v = + _menhir_action_498 _endpos_fname_ _startpos_t_ fname + mname t + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _startpos_t_, t, _endpos_s_, s = + (_startpos, _v, _endpos_2, _v_0) + in + let _v = + _menhir_action_499 _endpos_s_ _startpos_t_ s t + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + let _menhir_stack = + MenhirCell1_fun_header + (_menhir_stack, _menhir_s, _v, _startpos) + in + let _menhir_stack = + MenhirCell1_EQUAL (_menhir_stack, MenhirState1331, _endpos) + in + _menhir_run_1335 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState1332 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1335 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_x_, x = (_endpos, _v) in + let _v = _menhir_action_250 x in + _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MULTILINE_STRING _v_0 -> + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_x_, x, xs = (_endpos_1, _v_0, _v) in + let _v = _menhir_action_251 x xs in + _menhir_goto_non_empty_list_rev_MULTILINE_STRING_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _endpos_xs_, xs = (_endpos, _v) in + let _v = _menhir_action_186 xs in + _menhir_goto_non_empty_list_MULTILINE_STRING_ _menhir_stack + _menhir_lexbuf _menhir_lexer _endpos_xs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_non_empty_list_MULTILINE_STRING_ : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1341 -> + _menhir_run_1343 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1332 -> + _menhir_run_1338 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1343 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_extern_fun_header + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_extern_fun_header + (_menhir_stack, _menhir_s, t, _startpos_t_)) = + _menhir_stack + in + let _endpos_xs_, xs = (_endpos, _v) in + let _v = _menhir_action_502 _endpos_xs_ _startpos_t_ t xs in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1338 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header, + _menhir_box_structure ) + _menhir_cell1_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EQUAL (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) + = + _menhir_stack + in + let _endpos_xs_, xs = (_endpos, _v) in + let _v = _menhir_action_500 _endpos_xs_ _startpos_t_ t xs in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1315 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1315 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_1316 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0922 : type ttv_stack. + (( ( ( ( ttv_stack _menhir_cell0_STRING _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ + as + 'stack) -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0922 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1316 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXTERN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_074 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error + language ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_extern_fun_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.STRING _v_0 -> + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _startpos_t_, t, _endpos_s_, s = + (_startpos, _v, _endpos_2, _v_0) + in + let _v = _menhir_action_501 _endpos_s_ _startpos_t_ s t in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_3 -> + let _menhir_stack = + MenhirCell1_extern_fun_header + (_menhir_stack, _menhir_s, _v, _startpos) + in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + _menhir_run_1335 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState1341 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1303 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1303 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1304 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_096 _1 _endpos_ps_ _startpos_ps_ fun_binder has_error + ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1276 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1276 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1277 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1277 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_ASYNC (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_097 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error ps quants + ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1262 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1262 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_1263 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1263 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXTERN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_075 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error language + ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1250 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1250 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1251 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1251 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_098 _1 _endpos__1_inlined1_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ fun_binder has_error ps quants + ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1201 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1201 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1202 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1202 : type ttv_stack. + ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_ASYNC (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_099 _1 _endpos_attr_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ attr fun_binder has_error ps + quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1187 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1187 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_1188 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1188 : type ttv_stack. + ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXTERN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_076 _1 _endpos_attr_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ attr fun_binder has_error + language ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1175 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1175 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1176 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1176 : type ttv_stack. + ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_100 _1 _endpos_attr_ _endpos_ps_ + _startpos__1_inlined1_ _startpos_ps_ attr fun_binder has_error ps + quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1066 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1066 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1067 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1067 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_ASYNC (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_089 _endpos_ps_ _startpos_ps_ fun_binder has_error ps + quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1051 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1051 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_1052 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1052 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell1_EXTERN (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_071 _endpos_ps_ _startpos_ps_ fun_binder has_error + language ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1039 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1039 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1040 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell1_FN (_menhir_stack, _menhir_s, _startpos__4_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_090 _endpos_ps_ _startpos_ps_ fun_binder has_error ps + quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__4_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1012 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1012 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_1013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1013 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_ASYNC (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_091 _endpos__1_ _endpos_ps_ _startpos__1_ + _startpos_ps_ fun_binder has_error ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0998 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0998 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_0999 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0999 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXTERN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_072 _endpos__1_ _endpos_ps_ _startpos__1_ + _startpos_ps_ fun_binder has_error language ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0986 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0986 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_0987 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0987 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_092 _endpos__1_ _endpos_ps_ _startpos__1_ + _startpos_ps_ fun_binder has_error ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0937 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0937 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_0938 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0938 : type ttv_stack. + ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_ASYNC (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_093 _endpos_attr_ _endpos_ps_ _startpos__1_ + _startpos_ps_ attr fun_binder has_error ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0921 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0922 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0921 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _v_0 = _menhir_action_296 () in + _menhir_run_0924 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0924 : type ttv_stack. + ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_STRING (_menhir_stack, language, _, _)) = + _menhir_stack + in + let (MenhirCell0_EXTERN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_073 _endpos_attr_ _endpos_ps_ _startpos__1_ + _startpos_ps_ attr fun_binder has_error language ps quants ts + in + _menhir_goto_extern_fun_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0907 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_parameters_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0908 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0907 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_294 () in + _menhir_run_0910 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0910 : type ttv_stack. + ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_option_parameters_ + (_menhir_stack, _, ps, _startpos_ps_, _endpos_ps_)) = + _menhir_stack + in + let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quants)) = + _menhir_stack + in + let (MenhirCell1_optional_bang (_menhir_stack, _, has_error)) = + _menhir_stack + in + let (MenhirCell1_fun_binder (_menhir_stack, _, fun_binder)) = + _menhir_stack + in + let (MenhirCell0_FN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let ts = _v in + let _v = + _menhir_action_094 _endpos_attr_ _endpos_ps_ _startpos__1_ + _startpos_ps_ attr fun_binder has_error ps quants ts + in + _menhir_goto_fun_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0581 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0107 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0581 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_298 () in + _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0581 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0107 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0107 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0582 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_14_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0582 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0539 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0531 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0539 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_314 () in + _menhir_run_0540 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0539 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0531 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0531 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0540 : type ttv_stack ttv_result. + (( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_7_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0540 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0530 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0531 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0530 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_314 () in + _menhir_run_0533 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0530 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0533 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_7_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0533 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0106 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_parameters + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> + _menhir_run_0107 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0106 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_298 () in + _menhir_run_0109 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0106 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0109 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC, + ttv_result ) + _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_14_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0109 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0390 : type ttv_stack ttv_result. + ( ttv_stack _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_argument_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_argument_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_189 xs in + let _1 = _v in + let _v = _menhir_action_127 _1 in + _menhir_goto_list_commas_argument_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_list_commas_argument_ : type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0761 -> + _menhir_run_0762 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0638 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0458 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0442 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0438 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0434 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0431 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0424 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0420 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0416 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0413 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0408 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0404 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0392 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0762 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_type_name + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_name + ( _menhir_stack, + _menhir_s, + type_name, + _startpos_type_name_, + _ )) = + _menhir_stack + in + let _endpos__4_, args = (_endpos, _v) in + let _v = + _menhir_action_042 _endpos__4_ _startpos_type_name_ args + type_name + in + _menhir_goto_deriving_directive _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_deriving_directive : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0759 -> + _menhir_run_0771 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0765 -> + _menhir_run_0766 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0771 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE + _menhir_cell0_LPAREN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_219 x in + _menhir_goto_non_empty_list_commas_rev_deriving_directive_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_non_empty_list_commas_rev_deriving_directive_ : + type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE + _menhir_cell0_LPAREN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_deriving_directive_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0764, _endpos) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0765 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0764, _endpos) + in + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0765 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0764, _endpos) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0765 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0764, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0765 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0767 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0767 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0766 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_DERIVE + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_deriving_directive_, + _menhir_box_structure ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_deriving_directive_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_220 x xs in + _menhir_goto_non_empty_list_commas_rev_deriving_directive_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0638 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + ( _menhir_stack, + _menhir_s, + func, + _startpos_func_, + _endpos_func_ )) = + _menhir_stack + in + let args, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_421 _endpos__5_ _endpos_func_ _startpos_func_ args + func + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0458 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_expr _menhir_cell0_QUESTION + _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_simple_expr + (_menhir_stack, _menhir_s, func, _startpos_func_, _)) = + _menhir_stack + in + let args, _endpos__5_ = (_v, _endpos) in + let _v = + _menhir_action_425 _endpos__5_ _startpos_func_ args func + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos_func_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0334 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_foreach_binder_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_foreach_binder_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_195 xs in + let _menhir_stack = + MenhirCell1_non_empty_list_commas_foreach_binder_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.IN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_IN (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0342 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0250 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_pattern_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_pattern_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_201 xs in + _menhir_goto_non_empty_list_commas_pattern_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_commas_pattern_ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0554 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0272 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0251 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0272 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_pattern_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.IF -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IF (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0273 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FAT_ARROW -> + let _v = _menhir_action_318 () in + _menhir_goto_option___anonymous_9_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0251 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, p, _, _)) = + _menhir_stack + in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let ps, _endpos__5_ = (_v, _endpos) in + let _v = _menhir_action_456 _endpos__5_ _startpos__1_ p ps in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0229 : type ttv_stack ttv_result. + ( ttv_stack _menhir_cell0_COMMA, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_array_sub_pattern_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_array_sub_pattern_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_190 xs in + _menhir_goto_non_empty_list_commas_array_sub_pattern_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_commas_array_sub_pattern_ : + type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_COMMA as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0236 -> + _menhir_run_0237 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0233 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0230 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0237 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT _menhir_cell0_LIDENT + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let x, rest = ((), _v) in + let _v = + _menhir_action_014 _endpos_name_ _startpos_name_ name rest x + in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_array_sub_patterns : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0241 -> + _menhir_run_0242 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0238 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0242 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_array_sub_pattern + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_array_sub_pattern (_menhir_stack, _menhir_s, p)) = + _menhir_stack + in + let rest = _v in + let _v = _menhir_action_012 p rest in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0238 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACKET + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__3_, pats = (_endpos, _v) in + let _v = _menhir_action_458 _endpos__3_ _startpos__1_ pats in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0233 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let rest = _v in + let _v = _menhir_action_015 rest in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0230 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT _menhir_cell0_LIDENT + _menhir_cell0_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let rest = _v in + let _v = _menhir_action_013 _endpos_name_ _startpos_name_ name rest in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0207 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_194 xs in + let fps = _v in + let _v = _menhir_action_184 fps in + _menhir_goto_non_empty_fields_pat _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_goto_non_empty_fields_pat : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, p = (_endpos, _v) in + let _v = _menhir_action_461 _endpos__3_ _startpos__1_ p in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0203 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _, xs)) = + _menhir_stack + in + let _v = _menhir_action_198 xs in + let _1 = _v in + let _v = _menhir_action_283 _1 in + _menhir_goto_non_empty_map_elems_pat _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_goto_non_empty_map_elems_pat : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_LBRACE -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__3_, elems = (_endpos, _v) in + let _v = _menhir_action_462 _endpos__3_ _startpos__1_ elems in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0195 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_with_tail_fields_pat_single_ + _menhir_cell0_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_with_tail_fields_pat_single_ + (_menhir_stack, _, fps)) = + _menhir_stack + in + let _v = _menhir_action_185 fps in + _menhir_goto_non_empty_fields_pat _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_run_0192 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_with_tail_map_elem_pat_ + _menhir_cell0_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_DOTDOT (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_with_tail_map_elem_pat_ + (_menhir_stack, _, _1)) = + _menhir_stack + in + let _v = _menhir_action_284 _1 in + _menhir_goto_non_empty_map_elems_pat _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + + and _menhir_run_0185 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACE -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos__4_ = _endpos in + let _v = _menhir_action_460 _endpos__4_ _startpos__1_ in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0179 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_constr_pat_argument -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _1)) = + _menhir_stack + in + let _v = _menhir_action_036 _1 in + _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_constr_pat_arguments : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0177 -> + _menhir_run_0178 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0174 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0178 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_constr_pat_argument, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, arg)) = + _menhir_stack + in + let rest = _v in + let _v = _menhir_action_038 arg rest in + _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0174 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_constr _menhir_cell0_LPAREN -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in + let _endpos__3_, t = (_endpos, _v) in + let _v = _menhir_action_301 t in + _menhir_goto_option___anonymous_15_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _v _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_option___anonymous_15_ : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_constr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_constr + (_menhir_stack, _menhir_s, constr, _startpos_constr_, _)) = + _menhir_stack + in + let _endpos_ps_, ps = (_endpos, _v) in + let _v = _menhir_action_454 _endpos_ps_ _startpos_constr_ constr ps in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_ps_ _startpos_constr_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0172 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let _v = _menhir_action_037 () in + _menhir_goto_constr_pat_arguments _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0063 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_type__ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_non_empty_list_commas_rev_type__ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _v = _menhir_action_205 xs in + _menhir_goto_non_empty_list_commas_type__ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_commas_type__ : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0086 -> + _menhir_run_0090 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0073 -> + _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0058 -> + _menhir_run_0064 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0090 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _menhir_stack = + MenhirCell1_non_empty_list_commas_type__ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell0_RPAREN (_menhir_stack, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0092 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE + | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = + _menhir_stack + in + let (MenhirCell1_LPAREN + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__5_, ts = (_endpos, _v) in + let _v = _menhir_action_540 _endpos__5_ _startpos__1_ t ts in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0077 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_type__ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0079 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0064 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty _menhir_cell0_LBRACKET -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RBRACKET -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in + let _endpos__3_, x = (_endpos, _v) in + let _v = _menhir_action_323 x in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ : + type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let _endpos_params_, params = (_endpos, _v) in + let _v = _menhir_action_342 params in + let _endpos = _endpos_params_ in + let (MenhirCell1_qual_ident_ty + (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_550 _endpos_id_ _endpos_params_ _startpos_id_ id + params + in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos_id_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0206 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_fields_pat_single_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_fields_pat_single_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_224 x xs in + _menhir_goto_non_empty_list_commas_rev_fields_pat_single_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0217 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + let _menhir_stack = + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0218 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.STRING _v -> + let _menhir_stack = + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0219 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + let _menhir_stack = + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) + in + _menhir_run_0220 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.UIDENT _v_3 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0223 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.STRING _v_4 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0223 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0223 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.LIDENT _v_6 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0223 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.INT _v_7 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0223 _menhir_initp + | Lex_menhir_token.FLOAT _v_8 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0223 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0224 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.CHAR _v_9 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0223 _menhir_initp + | Lex_menhir_token.BYTES _v_10 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0223 _menhir_initp + | Lex_menhir_token.BYTE _v_11 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0223 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_0, _endpos_1) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_2) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0223 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _endpos_name_, _startpos_name_, name, x = + (_endpos_1, _startpos_0, _v, ()) + in + let _v = + _menhir_action_017 _endpos_name_ _startpos_name_ name x + in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _endpos_name_, _startpos_name_, name = + (_endpos_1, _startpos_0, _v) + in + let _v = + _menhir_action_016 _endpos_name_ _startpos_name_ name + in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA -> ( + let _endpos_12 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.UIDENT _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.STRING _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.LIDENT _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.INT _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.FLOAT _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0224 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.CHAR _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.BYTES _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.BYTE _v -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + MenhirState0232 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_12) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0232 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let x = () in + let _v = _menhir_action_021 x in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> ( + let _startpos_13 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) in + _menhir_run_0129 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.UIDENT _v_16 -> let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) in let _menhir_stack = MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) + (_menhir_stack, _v, _startpos_13, _endpos_14) in let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) + MenhirCell0_COMMA (_menhir_stack, _endpos_15) in + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_16 MenhirState0236 _menhir_initp + | Lex_menhir_token.TRUE -> let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) in - _menhir_run_0617 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_50 MenhirState1604 _menhir_initp - | Lex_menhir_token.LIDENT _v_51 -> let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) in + _menhir_run_0130 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.STRING _v_17 -> let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) in let _menhir_stack = MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) + (_menhir_stack, _v, _startpos_13, _endpos_14) in let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) + MenhirCell0_COMMA (_menhir_stack, _endpos_15) in + _menhir_run_0131 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_17 MenhirState0236 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_18 -> let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) in - _menhir_run_0624 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_51 MenhirState1604 _menhir_initp - | Lex_menhir_token.LABEL _v_52 -> let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_18 MenhirState0236 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.LIDENT _v_19 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_19 MenhirState0236 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.INT _v_20 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_20 MenhirState0236 _menhir_initp + | Lex_menhir_token.FLOAT _v_21 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_21 MenhirState0236 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) in let _menhir_stack = - MenhirCell1_WITH (_menhir_stack, MenhirState1544) + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0224 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.CHAR _v_22 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_22 MenhirState0236 _menhir_initp + | Lex_menhir_token.BYTES _v_23 -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) in let _menhir_stack = MenhirCell0_LIDENT - (_menhir_stack, _v_0, _startpos_1, _endpos_2) + (_menhir_stack, _v, _startpos_13, _endpos_14) in let _menhir_stack = - MenhirCell0_EXCLAMATION - (_menhir_stack, _startpos_27, _endpos_28) + MenhirCell0_COMMA (_menhir_stack, _endpos_15) in + _menhir_run_0150 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_23 MenhirState0236 _menhir_initp + | Lex_menhir_token.BYTE _v_24 -> let _menhir_stack = - MenhirCell0_LPAREN - (_menhir_stack, _startpos_29, _endpos_30) + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_24 MenhirState0236 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v, _startpos_13, _endpos_14) + in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos_15) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0236 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _endpos_name_, _startpos_name_, name, x, x_inlined1 + = + (_endpos_14, _startpos_13, _v, (), ()) + in + let _v = + _menhir_action_019 _endpos_name_ _startpos_name_ name + x x_inlined1 in - _menhir_run_0162 _menhir_stack _menhir_lexbuf - _menhir_lexer _v_52 MenhirState1604 _menhir_initp + _menhir_goto_array_sub_patterns _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _endpos_name_, _startpos_name_, name, x = + (_endpos_14, _startpos_13, _v, ()) + in + let _v = + _menhir_action_018 _endpos_name_ _startpos_name_ name x + in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp | _ -> _eRR ()) | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.QUESTION -> + | Lex_menhir_token.RBRACKET -> + let _v = _menhir_action_020 () in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0218 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_b_, _startpos_b_, b = (_endpos, _startpos, _v) in + let _v = _menhir_action_008 _endpos_b_ _startpos__1_ _startpos_b_ b in + _menhir_goto_array_sub_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_array_sub_pattern : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0241 -> + _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0240 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0231 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0231 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0231 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0228 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0240 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_array_sub_pattern (_menhir_stack, _menhir_s, _v) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0241 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0241 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0241 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0241 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0241 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0241 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.DOTDOT -> + _menhir_run_0217 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0241 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0241 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0241 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0241 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _v_9 = _menhir_action_010 () in + _menhir_run_0242 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let p = _v in + let _v = _menhir_action_011 p in + _menhir_goto_array_sub_patterns _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0231 : type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_COMMA as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_215 x in + _menhir_goto_non_empty_list_commas_rev_array_sub_pattern_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_non_empty_list_commas_rev_array_sub_pattern_ : + type ttv_stack ttv_result. + (ttv_stack _menhir_cell0_COMMA as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_array_sub_pattern_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0227 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0227 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0227 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0227 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0227 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0227 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0224 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0227 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0227 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0227 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0226, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0227 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0229 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _ = _menhir_action_286 () in + _menhir_run_0229 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0224 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0218 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0219 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0220 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_initp + | _ -> _eRR () - and _menhir_run_1424 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + and _menhir_run_0219 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _, _)) = + _menhir_stack + in + let _2 = _v in + let _v = _menhir_action_007 _2 in + _menhir_goto_array_sub_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0220 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_DOTDOT -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DOT_UIDENT _v_0 -> + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let pkg, _endpos_b_, _startpos_b_, b = + (_v, _endpos, _startpos_1, _v_0) + in + let _v = + _menhir_action_009 _endpos_b_ _startpos__1_ _startpos_b_ b pkg + in + _menhir_goto_array_sub_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0228 : type ttv_stack ttv_result. + ( ( ttv_stack _menhir_cell0_COMMA, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_array_sub_pattern_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_array_sub_pattern_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_216 x xs in + _menhir_goto_non_empty_list_commas_rev_array_sub_pattern_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0267 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_fn_header_no_binder + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0267 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0267 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0267 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0267 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 + MenhirState0267 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 + MenhirState0267 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 + MenhirState0267 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 + MenhirState0267 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 + MenhirState0267 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0267 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_9 = _menhir_action_152 () in + _menhir_run_0454 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0567 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_QUESTION (_menhir_stack, _startpos_0, _endpos_1) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0569 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_binder_name_, _startpos_binder_name_, binder_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_355 _endpos_binder_name_ + _startpos_binder_name_ binder_name + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0571 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_349 _endpos_name_ _startpos_name_ name in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0573 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_235 x in + _menhir_goto_non_empty_list_commas_rev_parameter_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_1314 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_LET - _menhir_cell0_LIDENT - _menhir_cell0_COLON + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1314 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1315 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1314 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1302 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1302 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1303 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1302 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1283 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1283 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1283 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1283 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1283 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1275 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1275 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1275 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1261 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1261 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1262 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1261 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1249 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1249 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1250 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1249 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1230 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1230 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1230 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1230 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1230 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1200 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1200 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1201 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1200 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1186 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1186 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1187 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1186 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1174 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1174 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1175 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1174 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1155 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL as 'stack) -> _ -> _ -> _ -> - _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_LET (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos_x_, _)) = - _menhir_stack - in - let x, t = ((), _v) in - let _v = _menhir_action_965 _endpos_name_ _startpos_name_ name t x in - _menhir_goto_val_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos_x_ _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_run_1388 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1155 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1155 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1155 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1155 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1065 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang as 'stack) -> _ -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell1_option_MUTABLE_ (_menhir_stack, _menhir_s, mut, _, _)) - = - _menhir_stack - in - let ty = _v in - let _v = _menhir_action_026 mut ty in - _menhir_goto_constructor_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_constructor_param : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1065 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1066 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1065 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1050 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1380 -> - _menhir_run_1394 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1390 -> - _menhir_run_1391 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1394 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT - _menhir_cell0_LPAREN + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1050 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1051 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1050 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1038 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang as 'stack) -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_168 x in - _menhir_goto_non_empty_list_commas_rev_constructor_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_constructor_param_ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT - _menhir_cell0_LPAREN - as - 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1038 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1039 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1038 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1019 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL as 'stack) -> _ -> _ -> _ -> @@ -189701,225 +56009,315 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MUTABLE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_constructor_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1390 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_130 x xs in - _menhir_goto_non_empty_list_commas_constructor_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | Lex_menhir_token.LABEL _ | Lex_menhir_token.LIDENT _ - | Lex_menhir_token.LPAREN | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.POST_LABEL _ | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_constructor_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - let _v_0 = _menhir_action_465 () in - _menhir_run_1381 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_0 MenhirState1390 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_129 xs in - _menhir_goto_non_empty_list_commas_constructor_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_initp - | _ -> _menhir_fail () - - and _menhir_goto_non_empty_list_commas_constructor_param_ : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT - _menhir_cell0_LPAREN -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1019 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1019 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1019 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1019 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1011 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let _endpos__3_, ts = (_endpos, _v) in - let _v = _menhir_action_482 ts in - _menhir_goto_option___anonymous_20_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__3_ _v _tok _menhir_initp - - and _menhir_goto_option___anonymous_20_ : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1011 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_1012 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState1011 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0997 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_UIDENT - (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_)) = - _menhir_stack - in - let _endpos_opt_, opt = (_endpos, _v) in - let _v = _menhir_action_035 _endpos_id_ _endpos_opt_ _startpos_id_ id opt in - _menhir_goto_enum_constructor _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_goto_enum_constructor : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0997 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0998 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0997 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0985 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2077 -> - _menhir_run_1402 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState2007 -> - _menhir_run_1402 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1378 -> - _menhir_run_1402 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1400 -> - _menhir_run_1401 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1402 : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0985 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0986 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0985 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0966 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_430 x in - _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0966 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0966 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0966 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0966 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0936 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ASYNC + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1379 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1400 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_453 x xs in - _menhir_goto_non_empty_list_semis_enum_constructor_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_452 xs in - _menhir_goto_non_empty_list_semis_enum_constructor_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis_enum_constructor_ : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0936 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0937 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0936 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0920 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_STRING + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState2077 -> - _menhir_run_2080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState2007 -> - _menhir_run_2024 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1378 -> - _menhir_run_1397 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2080 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_enum_header - _menhir_cell0_LBRACE + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0920 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0921 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0920 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0906 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang as 'stack) -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> + _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_enum_constructor_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2081 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2082 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_2024 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0906 _menhir_initp + | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE + | Lex_menhir_token.THIN_ARROW -> + let _v_0 = _menhir_action_330 () in + _menhir_run_0907 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_0 MenhirState0906 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0876 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_LBRACE + _menhir_cell1_pub_attr + _menhir_cell0_IMPL as 'stack) -> _ -> @@ -189927,177 +56325,166 @@ include struct _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> + _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_enum_constructor_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2025 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1397 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_LBRACE -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0876 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0876 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0876 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0876 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0722 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang + as + 'stack) -> + _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_ENUM (_menhir_stack, _menhir_s, _)) = _menhir_stack in - let _endpos__5_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_115 _1_inlined1 _endpos_tycon_ _startpos_tycon_ tycon - in - _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_local_type_decl : - type ttv_stack. + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0723 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0724 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v = _menhir_action_140 () in + _menhir_goto_list_commas_trait_method_param_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0724 : type ttv_stack. ttv_stack -> _ -> _ -> _ -> - _ -> (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> - _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2053 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_1416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1414 -> - _menhir_run_1415 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1416 : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_POST_LABEL + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0725 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1295 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> @@ -190105,17 +56492,34 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_432 x in - _menhir_goto_non_empty_list_semi_rev_aux_local_type_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_local_type_decl_ : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1295 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1287 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> @@ -190123,82 +56527,40 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1414 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos_1) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1414 _menhir_initp - | Lex_menhir_token.BREAK | Lex_menhir_token.BYTE _ - | Lex_menhir_token.BYTES _ | Lex_menhir_token.CHAR _ - | Lex_menhir_token.CONTINUE | Lex_menhir_token.ELLIPSIS - | Lex_menhir_token.FALSE | Lex_menhir_token.FLOAT _ - | Lex_menhir_token.FN | Lex_menhir_token.FOR | Lex_menhir_token.GUARD - | Lex_menhir_token.IF | Lex_menhir_token.INT _ - | Lex_menhir_token.INTERP _ | Lex_menhir_token.LBRACE - | Lex_menhir_token.LBRACKET | Lex_menhir_token.LET - | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LOOP - | Lex_menhir_token.LPAREN | Lex_menhir_token.MATCH - | Lex_menhir_token.MINUS | Lex_menhir_token.MULTILINE_INTERP _ - | Lex_menhir_token.MULTILINE_STRING _ | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.PLUS | Lex_menhir_token.RAISE - | Lex_menhir_token.RBRACE | Lex_menhir_token.RETURN - | Lex_menhir_token.STRING _ | Lex_menhir_token.TRUE - | Lex_menhir_token.TRY | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE | Lex_menhir_token.WHILE -> - let _endpos_x_, x, xs = (_endpos_1, _v_0, _v) in - let _v = _menhir_action_455 x xs in - _menhir_goto_non_empty_list_semis_local_type_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.BREAK | Lex_menhir_token.BYTE _ - | Lex_menhir_token.BYTES _ | Lex_menhir_token.CHAR _ - | Lex_menhir_token.CONTINUE | Lex_menhir_token.ELLIPSIS - | Lex_menhir_token.FALSE | Lex_menhir_token.FLOAT _ | Lex_menhir_token.FN - | Lex_menhir_token.FOR | Lex_menhir_token.GUARD | Lex_menhir_token.IF - | Lex_menhir_token.INT _ | Lex_menhir_token.INTERP _ - | Lex_menhir_token.LBRACE | Lex_menhir_token.LBRACKET | Lex_menhir_token.LET - | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LOOP - | Lex_menhir_token.LPAREN | Lex_menhir_token.MATCH | Lex_menhir_token.MINUS - | Lex_menhir_token.MULTILINE_INTERP _ | Lex_menhir_token.MULTILINE_STRING _ - | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.PLUS - | Lex_menhir_token.RAISE | Lex_menhir_token.RBRACE | Lex_menhir_token.RETURN - | Lex_menhir_token.STRING _ | Lex_menhir_token.TRUE | Lex_menhir_token.TRY - | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE - | Lex_menhir_token.WHILE -> - let _endpos_xs_, xs = (_endpos, _v) in - let _v = _menhir_action_454 xs in - _menhir_goto_non_empty_list_semis_local_type_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_xs_ _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis_local_type_decl_ : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1287 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1242 : type ttv_stack. + (( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> @@ -190206,3987 +56568,1898 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState2053 -> - _menhir_run_2055 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1963 -> - _menhir_run_1965 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1951 -> - _menhir_run_1953 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1935 -> - _menhir_run_1937 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1923 -> - _menhir_run_1925 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1906 -> - _menhir_run_1908 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1894 -> - _menhir_run_1896 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1878 -> - _menhir_run_1880 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1866 -> - _menhir_run_1868 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1846 -> - _menhir_run_1848 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1834 -> - _menhir_run_1836 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1818 -> - _menhir_run_1820 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1806 -> - _menhir_run_1808 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1789 -> - _menhir_run_1791 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1777 -> - _menhir_run_1779 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1761 -> - _menhir_run_1763 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1749 -> - _menhir_run_1751 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1648 -> - _menhir_run_1650 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1636 -> - _menhir_run_1638 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1620 -> - _menhir_run_1622 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1608 -> - _menhir_run_1610 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1591 -> - _menhir_run_1593 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1579 -> - _menhir_run_1581 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1563 -> - _menhir_run_1565 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1551 -> - _menhir_run_1553 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1531 -> - _menhir_run_1533 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1519 -> - _menhir_run_1521 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1503 -> - _menhir_run_1505 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1491 -> - _menhir_run_1493 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1474 -> - _menhir_run_1476 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1462 -> - _menhir_run_1464 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1446 -> - _menhir_run_1448 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1434 -> - _menhir_run_1436 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1343 -> - _menhir_run_1403 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_2055 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_fun_header - _menhir_cell0_LBRACE + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1242 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1234 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState2055 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2055 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_, _)) = - _menhir_stack - in - let (MenhirCell1_fun_header (_menhir_stack, _menhir_s, t, _startpos_t_)) - = - _menhir_stack - in - let _endpos__1_inlined1_, _1_inlined1, _endpos__4_ = - (_endpos, _v, _endpos_2) - in - let _v = - _menhir_action_725 _1_inlined1 _endpos__1_inlined1_ _endpos__4_ - _startpos__1_ _startpos_t_ t - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState2055 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState2055 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState2055 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState2055 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState2055 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState2055 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState2055 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState2055 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState2055 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState2055 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2055 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1965 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1234 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1167 : type ttv_stack. + (( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE + _menhir_cell1_WITH + _menhir_cell0_LIDENT as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1965 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1965 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_755 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_2 _startpos__1_inlined3_ _1_inlined2 - _endpos _v _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1965 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1965 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1965 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1965 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1965 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1965 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1965 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1965 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1965 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1965 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1965 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1167 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1159 : type ttv_stack. + (( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1159 _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_755 : - type ttv_stack. - ttv_stack -> + and _menhir_run_1031 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1031 _menhir_initp + | _ -> _eRR () + + and _menhir_run_1023 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1023 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0978 : type ttv_stack. + (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0978 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0970 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT + as + 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _startpos__1_inlined3_ _1_inlined2 _endpos__1_inlined4_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_755 _1_inlined2 _1_inlined4 _endpos__0_ - _endpos__1_inlined4_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_755 _1_inlined2 _1_inlined4 _endpos__0_ - _endpos__1_inlined4_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0970 _menhir_initp + | _ -> _eRR () - and _menhir_run_1953 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + and _menhir_run_0893 : type ttv_stack. + (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_type_name + _menhir_cell0_FOR, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_type_, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_WITH + _menhir_cell0_LIDENT as 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0893 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0880 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT + as + 'stack) -> + _ -> + _ -> _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1953 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1953 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_761 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers _endpos _v - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1953 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1953 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1953 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1953 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1953 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1953 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1953 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1953 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1953 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1953 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1953 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_bang (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0880 _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_761 : - type ttv_stack. + and _menhir_run_0126 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_022 _1 _endpos__1_ _startpos__1_ in + _menhir_goto_atomic_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0052 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_375 i in + _menhir_goto_qual_ident_ty _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0389 : type ttv_stack ttv_result. + ( ( ttv_stack _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_argument_, + ttv_result ) + _menhir_cell1_COMMA -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers _endpos__1_inlined5_ _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_761 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_761 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_argument_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_214 x xs in + _menhir_goto_non_empty_list_commas_rev_argument_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - and _menhir_run_1937 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + and _menhir_run_1292 : type ttv_stack. + (( ( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE + _menhir_cell1_type_name + _menhir_cell0_FOR as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1937 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1937 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_743 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_2 _endpos _v _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1937 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1937 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1937 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1937 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1937 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1937 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1937 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1937 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1937 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1937 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1937 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState1292) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1294 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1295 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1294 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_743 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> + and _menhir_run_1281 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_LET (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_583 _1 _endpos_name_ _startpos_name_ name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1270 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined3_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_743 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_743 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell0_CONST (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + ( _menhir_stack, + _startpos__1_inlined1_, + _endpos__1_inlined1_ )) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_597 _1 _endpos__1_inlined1_ + _endpos_binder_name_ _startpos__1_inlined1_ + _startpos_binder_name_ binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1925 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + and _menhir_run_1239 : type ttv_stack. + (( ( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_type_name + _menhir_cell0_FOR as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1925 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1925 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_749 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 - _startpos__1_inlined3_ _endpos _v _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1925 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1925 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1925 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1925 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1925 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1925 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1925 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1925 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1925 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1925 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1925 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState1239) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1241 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1242 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1241 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_749 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _ -> + and _menhir_run_1228 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_LET (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + ( _menhir_stack, + _startpos__1_inlined1_, + _endpos__1_inlined1_ )) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_585 _1 _endpos__1_inlined1_ _endpos_name_ + _startpos__1_inlined1_ _startpos_name_ name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1195 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _startpos__1_inlined3_ _endpos__1_inlined4_ - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_749 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_749 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell0_CONST (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) + = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_599 _1 _endpos_attr_ _endpos_binder_name_ + _startpos__1_inlined1_ _startpos_binder_name_ attr + binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1908 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + and _menhir_run_1164 : type ttv_stack. + (( ( ( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE + _menhir_cell1_type_name + _menhir_cell0_FOR as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1908 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1908 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_779 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _1_inlined1 _endpos_2 _endpos _v - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1908 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1908 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1908 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1908 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1908 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1908 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1908 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1908 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1908 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1908 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1908 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState1164) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1166 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1167 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1166 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_779 : - type ttv_stack. - ttv_stack -> + and _menhir_run_1153 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_LET (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) + = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_587 _1 _endpos_attr_ _endpos_name_ + _startpos__1_inlined1_ _startpos_name_ attr name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1085 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_alias_header + _menhir_cell0_EQUAL + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1085 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1086 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1080 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header as 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _1_inlined1 - _endpos__4_ _endpos__1_inlined3_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_779 _1_inlined1 _1_inlined3 _endpos__0_ - _endpos__1_inlined3_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_779 _1_inlined1 _1_inlined3 _endpos__0_ - _endpos__1_inlined3_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1080 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1081 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1896 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + and _menhir_run_1076 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1896 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1896 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_785 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos_2 - _startpos__1_inlined3_ _endpos _v _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1896 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1896 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1896 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1896 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1896 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1896 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1896 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1896 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1896 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1896 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1896 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let x = _v in + let _v = _menhir_action_333 x in + _menhir_goto_option_type__ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_785 : - type ttv_stack. - ttv_stack -> + and _menhir_goto_option_type__ : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_type_header_bang + as + 'stack) -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_type__ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1077 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1078 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1059 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell1_CONST (_menhir_stack, _menhir_s, _startpos__3_)) + = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_589 _endpos_binder_name_ _startpos_binder_name_ + binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1028 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _startpos__1_inlined3_ - _endpos__1_inlined4_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_785 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_785 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState1028) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1030 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1031 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1030 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_run_1880 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE + and _menhir_run_1017 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_LET _menhir_cell0_LIDENT + _menhir_cell0_COLON as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1880 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1880 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_767 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _startpos__1_inlined1_ _endpos_2 _endpos _v - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1880 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1880 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1880 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1880 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1880 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1880 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1880 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1880 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1880 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1880 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1880 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__3_)) + = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_577 _endpos_name_ _startpos_name_ name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_1006 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell0_CONST (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_591 _endpos__1_ _endpos_binder_name_ + _startpos__1_ _startpos_binder_name_ binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_767 : - type ttv_stack. - ttv_stack -> + and _menhir_run_0975 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR + as + 'stack) -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState0975) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0977 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_0978 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState0977 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0964 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_LET (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_579 _endpos__1_ _endpos_name_ _startpos__1_ + _startpos_name_ name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0931 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_CONST + _menhir_cell0_UIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ - _startpos__1_inlined1_ _endpos__4_ _endpos__1_inlined2_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_767 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_767 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_UIDENT + ( _menhir_stack, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let (MenhirCell0_CONST (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) + = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) + = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_593 _endpos_attr_ _endpos_binder_name_ + _startpos__1_ _startpos_binder_name_ attr binder_name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1868 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + and _menhir_run_0890 : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_type_name + _menhir_cell0_FOR as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1868 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1868 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_773 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 _endpos _v - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1868 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1868 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1868 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1868 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1868 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1868 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1868 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1868 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1868 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1868 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1868 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _menhir_stack = + MenhirCell1_WITH (_menhir_stack, MenhirState0890) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0892 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_0893 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState0892 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_773 : - type ttv_stack. - ttv_stack -> + and _menhir_run_0874 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_LET + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_LET (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) + = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) + = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_581 _endpos_attr_ _endpos_name_ _startpos__1_ + _startpos_name_ attr name t + in + _menhir_goto_val_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0816 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, mut, _, _)) = + _menhir_stack + in + let ty = _v in + let _v = _menhir_action_039 mut ty in + _menhir_goto_constructor_param _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_goto_constructor_param : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined3_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_773 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_773 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1848 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0811 -> + _menhir_run_0823 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0818 -> + _menhir_run_0819 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0823 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT + _menhir_cell0_LPAREN as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1848 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1848 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_851 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_2 _startpos__1_inlined3_ _1_inlined2 - _endpos _v _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1848 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1848 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1848 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1848 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1848 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1848 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1848 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1848 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1848 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1848 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1848 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_217 x in + _menhir_goto_non_empty_list_commas_rev_constructor_param_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp - and _menhir_act_goto_851 : + and _menhir_goto_non_empty_list_commas_rev_constructor_param_ : type ttv_stack. - ttv_stack -> - _ -> + ((ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT + _menhir_cell0_LPAREN + as + 'stack) -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_constructor_param_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MUTABLE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0817, _endpos) + in + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0818 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0820 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.POST_LABEL _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0817, _endpos) + in + let _v_1 = _menhir_action_288 () in + _menhir_run_0812 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_1 MenhirState0818 _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0820 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0819 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_constructor_param_, + _menhir_box_structure ) + _menhir_cell1_COMMA -> _ -> _ -> _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_constructor_param_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_218 x xs in + _menhir_goto_non_empty_list_commas_rev_constructor_param_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0815 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, + _menhir_box_structure ) + _menhir_cell1_POST_LABEL + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _startpos__1_inlined3_ _1_inlined2 _endpos__1_inlined4_ _1_inlined4 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_851 _1_inlined2 _1_inlined4 _endpos__0_ - _endpos__1_inlined4_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_851 _1_inlined2 _1_inlined4 _endpos__0_ - _endpos__1_inlined4_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_POST_LABEL + ( _menhir_stack, + _, + label_name, + _startpos_label_name_, + _endpos_label_name_ )) = + _menhir_stack + in + let (MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, mut, _, _)) = + _menhir_stack + in + let typ = _v in + let _v = + _menhir_action_040 _endpos_label_name_ _startpos_label_name_ + label_name mut typ + in + _menhir_goto_constructor_param _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1836 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + and _menhir_run_0797 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1836 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1836 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_857 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 _1_inlined2 - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers _endpos _v - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1836 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1836 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1836 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1836 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1836 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1836 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1836 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1836 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1836 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1836 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1836 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_option_MUTABLE_ + ( _menhir_stack, + _menhir_s, + mutflag, + _startpos_mutflag_, + _endpos_mutflag_ )) = + _menhir_stack + in + _menhir_act_goto_384 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ + name _endpos _v _endpos_mutflag_ _startpos_mutflag_ mutflag + | _ -> _eRR () - and _menhir_act_goto_857 : - type ttv_stack. + and _menhir_act_goto_384 : type ttv_stack. ttv_stack -> _ -> _ -> @@ -194201,60 +58474,89 @@ include struct _ -> _ -> _ -> - _ -> - _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _endpos_ty_ -> + fun ty -> + fun _endpos_mutflag_ -> + fun _startpos_mutflag_ -> + fun mutflag -> + match _menhir_s with + | MenhirState0801 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_384 _endpos__0_ _endpos_mutflag_ + _endpos_name_ _endpos_ty_ _startpos_mutflag_ + _startpos_name_ mutflag name ty + in + _menhir_run_0802 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | MenhirState1090 -> + let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_384 _endpos__0_ _endpos_mutflag_ + _endpos_name_ _endpos_ty_ _startpos_mutflag_ + _startpos_name_ mutflag name ty + in + _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | MenhirState0775 -> + let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_384 _endpos__0_ _endpos_mutflag_ + _endpos_name_ _endpos_ty_ _startpos_mutflag_ + _startpos_name_ mutflag name ty + in + _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0802 : type ttv_stack. + ( ( ttv_stack _menhir_cell0_LBRACE, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_, + _menhir_box_structure ) + _menhir_cell1_SEMI -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _1_inlined2 _startpos__1_inlined4_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers - _endpos__1_inlined5_ _1_inlined5 -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_857 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_857 _1_inlined2 _1_inlined5 _2_inlined1 _endpos__0_ - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_SEMI (_menhir_stack, _, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_261 x xs in + _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp - and _menhir_run_1820 : + and _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ : type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> + (ttv_stack _menhir_cell0_LBRACE as 'stack) -> _ -> _ -> _ -> @@ -194262,3759 +58564,2205 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1820 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1820 _menhir_initp - | Lex_menhir_token.RETURN -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.SEMI _v_0 -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PUB -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0800, _v_0, _endpos) + in + _menhir_run_0776 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0801 _menhir_initp + | Lex_menhir_token.PRIV -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0800, _v_0, _endpos) + in + _menhir_run_0788 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0801 _menhir_initp + | Lex_menhir_token.MUTABLE -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0800, _v_0, _endpos) + in + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0801 _menhir_initp + | Lex_menhir_token.LIDENT _ -> + let _menhir_stack = + MenhirCell1_SEMI + (_menhir_stack, MenhirState0800, _v_0, _endpos) + in + let _v_1 = _menhir_action_288 () in + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_1 MenhirState0801 _tok _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = + let x = _v_0 in + _menhir_action_293 x + in + _menhir_run_0803 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_292 () in + _menhir_run_0803 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0776 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) + MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos) in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_839 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _endpos_2 _endpos _v _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1820 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1820 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1820 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1820 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1820 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1820 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1820 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1820 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1820 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1820 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1820 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_839 : - type ttv_stack. + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> + _menhir_run_0777 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0776 _menhir_initp + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.MUTABLE -> + let _v = _menhir_action_368 () in + _menhir_run_0782 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _v MenhirState0776 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0788 : type ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.MUTABLE -> + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0788 _menhir_initp + | Lex_menhir_token.LIDENT _ -> + let _v = _menhir_action_288 () in + _menhir_run_0789 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _endpos _v MenhirState0788 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0789 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV as 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _v = _v_0 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0791 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0794 : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _endpos__4_ - _endpos__1_inlined3_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_839 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_839 _1_inlined3 _endpos__0_ _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_MUTABLE_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _v = _v_0 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0796 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1808 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, + and _menhir_run_0793 : type ttv_stack. + (ttv_stack _menhir_cell0_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_260 x in + _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0792 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1808 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1808 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_845 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 - _startpos__1_inlined3_ _endpos _v _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1808 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1808 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1808 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1808 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1808 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1808 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1808 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1808 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1808 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1808 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1808 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_option_MUTABLE_ + ( _menhir_stack, + _, + mutflag, + _startpos_mutflag_, + _endpos_mutflag_ )) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_ty_, ty = (_endpos, _v) in + let _v = + _menhir_action_385 _endpos__1_ _endpos_mutflag_ _endpos_name_ + _endpos_ty_ _startpos__1_ _startpos_mutflag_ _startpos_name_ + mutflag name ty + in + _menhir_goto_record_decl_field _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_845 : - type ttv_stack. + and _menhir_goto_record_decl_field : type ttv_stack. ttv_stack -> _ -> _ -> + _ -> (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0801 -> + _menhir_run_0802 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1090 -> + _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0775 -> + _menhir_run_0793 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0787 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr, + _menhir_box_structure ) + _menhir_cell1_option_MUTABLE_ + _menhir_cell0_LIDENT + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_LIDENT + (_menhir_stack, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_option_MUTABLE_ + ( _menhir_stack, + _, + mutflag, + _startpos_mutflag_, + _endpos_mutflag_ )) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) + = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) + = + _menhir_stack + in + let _endpos_ty_, ty = (_endpos, _v) in + let _v = + _menhir_action_386 _endpos_attr_ _endpos_mutflag_ + _endpos_name_ _endpos_ty_ _startpos__1_ _startpos_mutflag_ + _startpos_name_ attr mutflag name ty + in + _menhir_goto_record_decl_field _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0757 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _startpos__1_inlined3_ _endpos__1_inlined4_ - _1_inlined4 _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_845 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_845 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0757 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_0772 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1791 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_run_0727 : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1791 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1791 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_875 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _1_inlined1 _endpos_2 _endpos _v - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1791 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1791 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1791 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1791 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1791 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1791 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1791 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1791 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1791 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1791 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1791 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let typ = _v in + let _v = _menhir_action_531 typ in + _menhir_goto_trait_method_param _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_875 : - type ttv_stack. + and _menhir_goto_trait_method_param : type ttv_stack. ttv_stack -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0730 -> + _menhir_run_0731 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0723 -> + _menhir_run_0728 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0731 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_trait_method_param_, + _menhir_box_structure ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_trait_method_param_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_244 x xs in + _menhir_goto_non_empty_list_commas_rev_trait_method_param_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_non_empty_list_commas_rev_trait_method_param_ : + type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_trait_method_param_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0730 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0730 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0724 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0730 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0730 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0730 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0730 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0730 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0729, _endpos) + in + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0730 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0732 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0732 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0728 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_243 x in + _menhir_goto_non_empty_list_commas_rev_trait_method_param_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0726 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_POST_LABEL + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_POST_LABEL + ( _menhir_stack, + _menhir_s, + label_name, + _startpos_label_name_, + _endpos_label_name_ )) = + _menhir_stack + in + let typ = _v in + let _v = + _menhir_action_532 _endpos_label_name_ _startpos_label_name_ + label_name typ + in + _menhir_goto_trait_method_param _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0653 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_expr + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ _1_inlined1 - _endpos__4_ _endpos__1_inlined3_ _1_inlined3 _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_875 _1_inlined1 _1_inlined3 _endpos__0_ - _endpos__1_inlined3_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_875 _1_inlined1 _1_inlined3 _endpos__0_ - _endpos__1_inlined3_ _endpos__3_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = + _menhir_stack + in + let (MenhirCell1_LPAREN + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__4_, t = (_endpos_0, _v) in + let _v = _menhir_action_440 _endpos__4_ _startpos__1_ expr t in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_run_1779 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + and _menhir_run_0572 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON as 'stack) -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1779 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1779 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_881 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _1_inlined1 _endpos__2_inlined1_ _2_inlined1 _endpos_2 - _startpos__1_inlined3_ _endpos _v _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1779 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1779 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1779 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1779 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1779 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1779 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1779 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1779 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1779 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1779 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1779 _menhir_initp - | _ -> _menhir_fail () + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + ( _menhir_stack, + _menhir_s, + name, + _startpos_name_, + _endpos_name_ )) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_350 _endpos_name_ _startpos_name_ name t + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_881 : - type ttv_stack. - ttv_stack -> + and _menhir_run_0570 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION + _menhir_cell0_COLON + as + 'stack) -> + _ -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_LIDENT + ( _menhir_stack, + _menhir_s, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_356 _endpos_binder_name_ _startpos_binder_name_ + binder_name t + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0564 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> ( + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0564 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0565 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_POST_LABEL + ( _menhir_stack, + _menhir_s, + binder_name, + _startpos_binder_name_, + _endpos_binder_name_ )) = + _menhir_stack + in + let t = _v in + let _v = + _menhir_action_352 _endpos_binder_name_ _startpos_binder_name_ + binder_name t + in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0497 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _startpos__1_inlined3_ - _endpos__1_inlined4_ _1_inlined4 _endpos_name_inlined1_ - _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_881 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_881 _1_inlined1 _1_inlined4 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> ( + let _menhir_s = MenhirState0497 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0498 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1763 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE + and _menhir_run_0490 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_MUTABLE + _menhir_cell0_LIDENT + _menhir_cell0_COLON as 'stack) -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1763 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1763 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_863 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__3_ _startpos__1_inlined1_ _endpos_2 _endpos _v - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1763 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1763 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1763 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1763 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1763 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1763 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1763 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1763 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1763 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1763 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1763 _menhir_initp - | _ -> _menhir_fail () + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EQUAL -> ( + let _menhir_s = MenhirState0490 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0491 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_act_goto_863 : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> - _ -> + and _menhir_run_0254 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = + _menhir_stack + in + let (MenhirCell1_LPAREN + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__4_, t = (_endpos_0, _v) in + let _v = _menhir_action_457 _endpos__4_ _startpos__1_ pat t in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0094 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_UNDERSCORE _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__3_ - _startpos__1_inlined1_ _endpos__4_ _endpos__1_inlined2_ _1_inlined2 - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_863 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_863 _1_inlined2 _endpos__0_ _endpos__1_inlined2_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ name name_inlined1 quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_UNDERSCORE + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let t = _v in + let _v = _menhir_action_348 _endpos__1_ _startpos__1_ t in + _menhir_goto_parameter _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1751 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> - _ -> - _ -> + and _menhir_run_0082 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1751 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1751 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_869 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos__2_inlined1_ _2_inlined1 _endpos_2 _endpos _v - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1751 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1751 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1751 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1751 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1751 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1751 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1751 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1751 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1751 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1751 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1751 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_act_goto_869 : - type ttv_stack. - ttv_stack -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_RPAREN + (_menhir_stack, MenhirState0082, _endpos_0) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0084 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE + | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> + let (MenhirCell1_LPAREN + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos__3_, t = (_endpos_0, _v) in + let _v = _menhir_action_547 t in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0082 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0086 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0088 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0069 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> ( + let _menhir_s = MenhirState0069 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0071 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.QUESTION -> + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA -> ( + let _menhir_s = MenhirState0069 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0073 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.RPAREN -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.THIN_ARROW -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_THIN_ARROW (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0075 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0062 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_type__, + ttv_result ) + _menhir_cell1_COMMA + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined3_ _1_inlined3 - _startpos__1_inlined2_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_869 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_869 _1_inlined3 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_type__ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_246 x xs in + _menhir_goto_non_empty_list_commas_rev_type__ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1650 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> + and _menhir_goto_non_empty_list_commas_rev_type__ : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1650 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1650 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_803 _1_inlined2 _1_inlined4 _endpos__1_inlined4_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1650 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1650 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1650 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1650 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1650 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1650 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1650 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1650 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1650 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1650 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1650 _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_type__ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0061 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0061 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0061 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0061 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0061 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0061 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0060, _endpos) + in + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0061 _menhir_initp + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0063 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0063 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0059 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN -> + let x = _v in + let _v = _menhir_action_245 x in + _menhir_goto_non_empty_list_commas_rev_type__ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1638 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + and _menhir_run_0056 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_EXCLAMATION as 'stack) -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1638 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1638 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined5_, _1_inlined5 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_809 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1638 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1638 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1638 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1638 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1638 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1638 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1638 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1638 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1638 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1638 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1638 _menhir_initp - | _ -> _menhir_fail () + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ + | Lex_menhir_token.WITH -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell1_type_ (_menhir_stack, _menhir_s, t1, _, _)) = + _menhir_stack + in + let _endpos_t2_, t2 = (_endpos, _v) in + let _v = _menhir_action_394 t1 t2 in + _menhir_goto_return_type _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_t2_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1622 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_goto_return_type : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0922 -> + _menhir_run_0923 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0908 -> + _menhir_run_0909 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0895 -> + _menhir_run_0896 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0882 -> + _menhir_run_0883 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0736 -> + _menhir_run_0737 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0531 -> + _menhir_run_0532 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0107 -> + _menhir_run_0108 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0092 -> + _menhir_run_0093 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0088 -> + _menhir_run_0089 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0084 -> + _menhir_run_0085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0044 -> + _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0079 -> + _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0075 -> + _menhir_run_0076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0071 -> + _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0049 -> + _menhir_run_0068 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0923 : type ttv_stack. + ( ( ( ( ( ttv_stack _menhir_cell0_STRING _menhir_cell0_FN, + _menhir_box_structure ) + _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1622 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1622 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_791 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1622 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1622 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1622 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1622 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1622 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1622 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1622 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1622 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1622 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1622 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1622 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1610 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let t = _v in + let _v = _menhir_action_297 t in + _menhir_goto_option___anonymous_1_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option___anonymous_1_ : type ttv_stack. + (( ( ( ( ttv_stack _menhir_cell0_STRING _menhir_cell0_FN, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_option_parameters_ as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1610 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1610 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_797 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1610 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1610 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1610 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1610 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1610 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1610 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1610 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1610 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1610 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1610 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1610 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1593 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1315 -> + _menhir_run_1316 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1262 -> + _menhir_run_1263 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1187 -> + _menhir_run_1188 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1051 -> + _menhir_run_1052 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0998 -> + _menhir_run_0999 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0921 -> + _menhir_run_0924 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0909 : type ttv_stack. + ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_binder, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_option_parameters_, + _menhir_box_structure ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let t = _v in + let _v = _menhir_action_295 t in + _menhir_goto_option___anonymous_0_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option___anonymous_0_ : type ttv_stack. + (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_fun_binder, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE + _menhir_cell1_option_parameters_ as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1593 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1593 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_827 _1_inlined1 _1_inlined3 _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1593 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1593 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1593 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1593 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1593 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1593 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1593 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1593 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1593 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1593 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1593 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1329 -> + _menhir_run_1330 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1303 -> + _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1276 -> + _menhir_run_1277 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1250 -> + _menhir_run_1251 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1201 -> + _menhir_run_1202 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1175 -> + _menhir_run_1176 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1066 -> + _menhir_run_1067 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1039 -> + _menhir_run_1040 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState1012 -> + _menhir_run_1013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0986 -> + _menhir_run_0987 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0937 -> + _menhir_run_0938 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0907 -> + _menhir_run_0910 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0896 : type ttv_stack. + ( ( ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_FOR, + _menhir_box_structure ) + _menhir_cell1_type_, + _menhir_box_structure ) + _menhir_cell1_WITH + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let _endpos__2_, _2 = (_endpos, _v) in + let _v = _menhir_action_309 _2 in + _menhir_goto_option___anonymous_3_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1581 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, + and _menhir_goto_option___anonymous_3_ : type ttv_stack. + (( ( ( ( ( ( ttv_stack, _menhir_box_structure ) _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty + _menhir_cell1_type_name _menhir_cell0_FOR, _menhir_box_structure ) _menhir_cell1_type_, _menhir_box_structure ) _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_parameters as 'stack) -> _ -> @@ -198025,323 +60773,81 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1581 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1581 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_833 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1581 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1581 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1581 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1581 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1581 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1581 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1581 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1581 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1581 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1581 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1581 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1296 -> + _menhir_run_1297 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1243 -> + _menhir_run_1244 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1168 -> + _menhir_run_1169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1032 -> + _menhir_run_1033 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0979 -> + _menhir_run_0980 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0894 -> + _menhir_run_0897 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0883 : type ttv_stack. + ( ( ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters, + _menhir_box_structure ) + _menhir_cell1_type_name + _menhir_cell0_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_parameters, + _menhir_box_structure ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let _endpos__2_, _2 = (_endpos, _v) in + let _v = _menhir_action_311 _2 in + _menhir_goto_option___anonymous_4_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1565 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + and _menhir_goto_option___anonymous_4_ : type ttv_stack. + (( ( ( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, + _menhir_cell1_optional_type_parameters, _menhir_box_structure ) - _menhir_cell1_type_, + _menhir_cell1_type_name + _menhir_cell0_LIDENT, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_optional_bang, _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE + _menhir_cell1_parameters as 'stack) -> _ -> @@ -198352,1591 +60858,2746 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1565 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1565 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined2_, _1_inlined2 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_815 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1565 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1565 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1565 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1565 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1565 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1565 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1565 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1565 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1565 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1565 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1565 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1288 -> + _menhir_run_1289 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1235 -> + _menhir_run_1236 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1160 -> + _menhir_run_1161 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState1024 -> + _menhir_run_1025 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0971 -> + _menhir_run_0972 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | MenhirState0881 -> + _menhir_run_0884 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0737 : type ttv_stack. + ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + _menhir_box_structure ) + _menhir_cell1_optional_bang, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + _menhir_cell0_LPAREN, + _menhir_box_structure ) + _menhir_cell1_list_commas_trait_method_param_ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let _endpos_t_, t = (_endpos, _v) in + let _v = _menhir_action_313 t in + _menhir_goto_option___anonymous_6_ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_t_ _v _tok _menhir_initp + + and _menhir_run_0532 : type ttv_stack ttv_result. + ( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let t = _v in + let _v = _menhir_action_315 t in + _menhir_goto_option___anonymous_7_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option___anonymous_7_ : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_LIDENT, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0539 -> + _menhir_run_0540 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0530 -> + _menhir_run_0533 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0108 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters, + ttv_result ) + _menhir_cell1_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let t = _v in + let _v = _menhir_action_299 t in + _menhir_goto_option___anonymous_14_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option___anonymous_14_ : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_FN, + ttv_result ) + _menhir_cell1_optional_bang, + ttv_result ) + _menhir_cell1_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0581 -> + _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0106 -> + _menhir_run_0109 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0093 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_non_empty_list_commas_type__ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_type__ (_menhir_stack, _, x)) = + _menhir_stack + in + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__2_, _)) + = + _menhir_stack + in + _menhir_act_goto_544 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ x t _endpos _v + + and _menhir_act_goto_544 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun x -> + fun t -> + fun _endpos_rty_ -> + fun rty -> + match _menhir_s with + | MenhirState1322 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1323 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1292 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1239 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1228 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1153 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + let (MenhirCell1_type_header (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + let (MenhirCell1_type_header_bang (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1028 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_1006 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0975 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0964 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0931 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0890 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0874 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + let (MenhirCell1_option_MUTABLE_ (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0815 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0797 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + let (MenhirCell1_luident (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0757 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0726 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0653 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0570 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0497 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0094 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + let (MenhirCell1_EXCLAMATION (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0056 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_544 _endpos__0_ _endpos_rty_ _startpos__2_ + rty t x + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0053 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.EXCLAMATION -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0055 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0055 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0055 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0055 _menhir_initp + | Lex_menhir_token.LIDENT _v_4 -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0055 _menhir_initp + | Lex_menhir_token.ASYNC -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0055 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_type_ + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell1_EXCLAMATION + (_menhir_stack, MenhirState0053, _startpos_0, _endpos_1) + in + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0055 _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE + | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> + let _endpos__2_, _startpos__2_, t1 = + (_endpos_1, _startpos_0, _v) + in + let _v = _menhir_action_393 _endpos__2_ _startpos__2_ t1 in + _menhir_goto_return_type _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> + let _endpos_t_, t = (_endpos, _v) in + let _v = _menhir_action_392 t in + _menhir_goto_return_type _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_t_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0089 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__2_, _)) + = + _menhir_stack + in + _menhir_act_goto_543 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ t _endpos _v + + and _menhir_act_goto_543 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun t -> + fun _endpos_rty_ -> + fun rty -> + match _menhir_s with + | MenhirState1322 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1323 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1292 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1239 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1228 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1153 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + let (MenhirCell1_type_header (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + let (MenhirCell1_type_header_bang (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1028 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1006 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0975 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0964 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0931 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0890 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0874 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + let (MenhirCell1_option_MUTABLE_ (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0815 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0797 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + let (MenhirCell1_luident (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0757 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0726 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0653 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0570 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0497 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0094 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + let (MenhirCell1_EXCLAMATION (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0056 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_543 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0085 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__2_, _)) + = + _menhir_stack + in + _menhir_act_goto_549 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ t _endpos _v + + and _menhir_act_goto_549 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun t -> + fun _endpos_rty_ -> + fun rty -> + match _menhir_s with + | MenhirState1322 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1323 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1292 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1239 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1228 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1153 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + let (MenhirCell1_type_header (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + let (MenhirCell1_type_header_bang (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1028 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_1006 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0975 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0964 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0931 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0890 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0874 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + let (MenhirCell1_option_MUTABLE_ (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0815 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0797 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + let (MenhirCell1_luident (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0757 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0726 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0653 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0570 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0497 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0094 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + let (MenhirCell1_EXCLAMATION (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0056 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_549 _endpos__0_ _endpos_rty_ _startpos__2_ rty + t + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0081 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__2_, _)) + = + _menhir_stack + in + _menhir_act_goto_546 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__2_ _endpos _v - and _menhir_run_1553 : - type ttv_stack. - (( ( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_act_goto_546 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1553 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1553 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_821 _1_inlined3 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1553 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1553 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1553 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1553 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1553 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1553 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1553 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1553 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1553 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1553 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1553 _menhir_initp - | _ -> _menhir_fail () + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__2_ -> + fun _endpos_rty_ -> + fun rty -> + match _menhir_s with + | MenhirState1322 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1323 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1291 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1292 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1280 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1281 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1269 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1270 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1238 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1239 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1227 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1228 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1194 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1195 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1163 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1164 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1152 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1153 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1084 -> + let (MenhirCell0_EQUAL (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1085 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1079 -> + let (MenhirCell1_type_header (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1080 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1071 -> + let (MenhirCell1_type_header_bang (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1076 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1058 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1027 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1028 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1016 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1017 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState1005 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_1006 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0974 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0975 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0963 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0964 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0930 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0931 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0889 -> + let (MenhirCell0_FOR (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0890 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0873 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0874 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0812 -> + let (MenhirCell1_option_MUTABLE_ (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0816 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0814 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0815 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0796 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0797 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0791 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0792 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0786 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0787 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0756 -> + let (MenhirCell1_luident (_, _, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0757 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0730 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0723 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0727 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0725 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0726 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0652 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0653 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0571 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0569 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0570 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0563 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0564 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0496 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0497 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0489 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0490 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0253 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0254 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0036 -> + let (MenhirCell0_COLON (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0094 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0042 -> + let (MenhirCell1_LPAREN (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0047 -> + let (MenhirCell0_LPAREN (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0061 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0086 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0073 -> + let (MenhirCell1_COMMA (_, _, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0058 -> + let (MenhirCell0_LBRACKET (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0059 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0055 -> + let (MenhirCell1_EXCLAMATION (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0056 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0922 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0908 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0895 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0882 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0736 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0531 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0107 -> + let (MenhirCell1_THIN_ARROW (_, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0092 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0088 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0084 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0044 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0079 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0075 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0071 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | MenhirState0049 -> + let (MenhirCell0_THIN_ARROW (_, _endpos__0_)) = _menhir_stack in + let _v = + _menhir_action_546 _endpos__0_ _endpos_rty_ _startpos__2_ rty + in + _menhir_run_0053 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__2_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () - and _menhir_run_1533 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_run_0080 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_non_empty_list_commas_type__ + _menhir_cell0_RPAREN + _menhir_cell0_THIN_ARROW -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1533 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1533 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_899 _1_inlined2 _1_inlined4 _endpos__1_inlined4_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined3_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1533 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1533 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1533 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1533 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1533 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1533 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1533 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1533 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1533 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1533 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1533 _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_type__ (_menhir_stack, _, x)) = + _menhir_stack + in + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_LPAREN (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_rty_, rty = (_endpos, _v) in + let _v = + _menhir_action_542 _endpos__1_ _endpos_rty_ _startpos__1_ + _startpos__2_ rty t x + in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1521 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_run_0076 : type ttv_stack ttv_result. + ( ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1521 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1521 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined4_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined5_, _1_inlined5 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_905 _1_inlined2 _1_inlined5 _2_inlined1 - _endpos__1_inlined5_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1521 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1521 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1521 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1521 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1521 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1521 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1521 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1521 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1521 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1521 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1521 _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_LPAREN (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_rty_, rty = (_endpos, _v) in + let _v = + _menhir_action_541 _endpos__1_ _endpos_rty_ _startpos__1_ + _startpos__2_ rty t + in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1505 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_run_0072 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_type_, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in + let (MenhirCell0_LPAREN (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_rty_, rty = (_endpos, _v) in + let _v = + _menhir_action_548 _endpos__1_ _endpos_rty_ _startpos__1_ + _startpos__2_ rty t + in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0068 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_ASYNC _menhir_cell0_LPAREN, + ttv_result ) + _menhir_cell1_RPAREN + _menhir_cell0_THIN_ARROW -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1505 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1505 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_887 _1_inlined3 _endpos__1_inlined3_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1505 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1505 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1505 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1505 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1505 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1505 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1505 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1505 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1505 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1505 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1505 _menhir_initp - | _ -> _menhir_fail () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_THIN_ARROW (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell0_LPAREN (_menhir_stack, _startpos__2_, _)) = + _menhir_stack + in + let (MenhirCell1_ASYNC + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_rty_, rty = (_endpos, _v) in + let _v = + _menhir_action_545 _endpos__1_ _endpos_rty_ _startpos__1_ + _startpos__2_ rty + in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rty_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1493 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + and _menhir_run_1308 : type ttv_stack. + (( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_luident as 'stack) -> _ -> @@ -199947,627 +63608,78 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1493 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1493 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_893 _1_inlined4 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1493 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1493 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1493 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1493 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1493 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1493 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1493 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1493 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1493 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1493 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1493 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1476 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1308 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1309 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1266 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1476 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1476 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _endpos__3_)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_923 _1_inlined1 _1_inlined3 _endpos__1_inlined3_ - _endpos__3_ _endpos__4_ _endpos_name_ _endpos_name_inlined1_ - _endpos_x_ _startpos__1_inlined2_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1476 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1476 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1476 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1476 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1476 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1476 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1476 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1476 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1476 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1476 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1476 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1464 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_050 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1255 : type ttv_stack. + (( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE + _menhir_cell1_luident as 'stack) -> _ -> @@ -200578,932 +63690,368 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1464 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1464 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined3_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined4_, _1_inlined4 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_929 _1_inlined1 _1_inlined4 _2_inlined1 - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1464 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1464 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1464 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1464 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1464 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1464 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1464 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1464 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1464 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1464 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1464 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1448 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - _menhir_cell0_LBRACE - as - 'stack) -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1255 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1256 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1224 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1448 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1448 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _endpos__3_)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined2_, _1_inlined2 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_911 _1_inlined2 _endpos__1_inlined2_ _endpos__3_ - _endpos__4_ _endpos_name_ _endpos_name_inlined1_ _endpos_x_ - _startpos__1_inlined1_ _startpos__2_ _startpos_name_ - _startpos_name_inlined1_ _startpos_x_ name name_inlined1 quantifiers - x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1448 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1448 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1448 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1448 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1448 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1448 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1448 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1448 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1448 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1448 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1448 _menhir_initp - | _ -> _menhir_fail () + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_481 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_struct_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_struct_header (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PUB -> + _menhir_run_0776 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1090 _menhir_initp + | Lex_menhir_token.PRIV -> + _menhir_run_0788 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1090 _menhir_initp + | Lex_menhir_token.MUTABLE -> + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1090 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_154 () in + _menhir_run_1091 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState1090 _menhir_initp + | Lex_menhir_token.LIDENT _ -> + let _v_2 = _menhir_action_288 () in + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _endpos _v_2 MenhirState1090 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1211 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_565 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1436 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN, - _menhir_box_structure ) - _menhir_cell1_return_type - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_goto_type_header : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1436 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1436 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined2_, _)) = - _menhir_stack - in - let (MenhirCell1_return_type - (_menhir_stack, _, _2_inlined1, _endpos__2_inlined1_)) = - _menhir_stack - in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let x, _endpos__4_, _endpos__1_inlined3_, _1_inlined3 = - ((), _endpos_2, _endpos, _v) - in - let _v = - _menhir_action_917 _1_inlined3 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ _startpos_x_ - name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1436 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1436 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1436 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1436 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1436 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1436 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1436 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1436 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1436 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1436 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1436 _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_header + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1079 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1079 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1079 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1079 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1079 _menhir_initp + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1079 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1079 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1079 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_3 = _menhir_action_043 () in + _menhir_run_1082 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_3 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1403 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TEST - _menhir_cell0_option_loced_string_, + and _menhir_run_1206 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_557 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_type_alias_header : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_alias_header + (_menhir_stack, _menhir_s, _v, _startpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState1084 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1191 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_051 _1 _endpos_attr_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ attr params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1180 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_option_parameters_ - _menhir_cell0_LBRACE + _menhir_cell1_luident as 'stack) -> _ -> @@ -201514,682 +64062,562 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1403 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.STRING _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1403 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _startpos__1_inlined1_, _)) = - _menhir_stack - in - let (MenhirCell1_option_parameters_ (_menhir_stack, _, params, _, _)) = - _menhir_stack - in - let (MenhirCell0_option_loced_string_ (_menhir_stack, name)) = - _menhir_stack - in - let (MenhirCell1_TEST (_menhir_stack, _menhir_s, _startpos__1_)) = - _menhir_stack - in - let _endpos__4_, _endpos__1_inlined2_, _1_inlined2 = - (_endpos_2, _endpos, _v) - in - let _v = - _menhir_action_737 _1_inlined2 _endpos__1_inlined2_ _endpos__4_ - _startpos__1_ _startpos__1_inlined1_ name params - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer - _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1403 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1403 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_5 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1403 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.LIDENT _v_6 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1403 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.INTERP _v_7 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1403 _menhir_initp - | Lex_menhir_token.INT _v_8 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1403 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.FLOAT _v_9 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1403 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | Lex_menhir_token.CHAR _v_10 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1403 _menhir_initp - | Lex_menhir_token.BYTES _v_11 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1403 _menhir_initp - | Lex_menhir_token.BYTE _v_12 -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1403 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_local_type_decl_ - (_menhir_stack, _menhir_s, _v, _endpos) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1403 _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1415 : - type ttv_stack. - ( ttv_stack _menhir_cell0_LBRACE, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1180 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1181 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1149 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_local_type_decl_ - _menhir_cell0_SEMI -> - _ -> + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_local_type_decl_ - (_menhir_stack, _menhir_s, xs, _)) = - _menhir_stack - in - let _endpos_x_, x = (_endpos, _v) in - let _v = _menhir_action_433 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_local_type_decl_ _menhir_stack - _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1401 : - type ttv_stack. - ( ttv_stack, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_482 _1 _endpos_attr_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ attr params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1136 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_enum_constructor_ - _menhir_cell0_SEMI -> + _menhir_cell1_luident -> + _ -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_enum_constructor_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_431 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_enum_constructor_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_566 _1 _endpos_attr_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ attr params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1391 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_UIDENT - _menhir_cell0_LPAREN, + and _menhir_run_1131 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_constructor_param_ - _menhir_cell0_COMMA -> + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_constructor_param_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_169 x xs in - _menhir_goto_non_empty_list_commas_rev_constructor_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1387 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, - _menhir_box_structure ) - _menhir_cell1_LABEL - _menhir_cell0_COLON - as - 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_558 _1 _endpos_attr_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ attr params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1126 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_480 _1 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1109 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LABEL - ( _menhir_stack, - _, - label_name, - _startpos_label_name_, - _endpos_label_name_ )) = - _menhir_stack - in - let (MenhirCell1_option_MUTABLE_ (_menhir_stack, _menhir_s, mut, _, _)) - = - _menhir_stack - in - let typ = _v in - let _v = - _menhir_action_027 _endpos_label_name_ _startpos_label_name_ - label_name mut typ - in - _menhir_goto_constructor_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_564 _1 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1384 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_, - _menhir_box_structure ) - _menhir_cell1_POST_LABEL - _menhir_cell0_COLON - as - 'stack) -> + and _menhir_run_1104 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_556 _1 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1055 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_POST_LABEL - ( _menhir_stack, - _, - label_name, - _startpos_label_name_, - _endpos_label_name_ )) = - _menhir_stack - in - let (MenhirCell1_option_MUTABLE_ (_menhir_stack, _menhir_s, mut, _, _)) - = - _menhir_stack - in - let typ = _v in - let _v = - _menhir_action_028 _endpos_label_name_ _startpos_label_name_ - label_name mut typ - in - _menhir_goto_constructor_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1369 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_ENUM (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_046 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__3_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_1044 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident as 'stack) -> _ -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_option_MUTABLE_ - ( _menhir_stack, - _menhir_s, - mutflag, - _startpos_mutflag_, - _endpos_mutflag_ )) = - _menhir_stack - in - _menhir_act_goto_549 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _endpos _v _endpos_mutflag_ _startpos_mutflag_ mutflag - | _ -> _eRR () - - and _menhir_act_goto_549 : - type ttv_stack. - ttv_stack -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1044 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_1045 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1002 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_047 _endpos__1_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0991 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _endpos_ty_ ty _endpos_mutflag_ - _startpos_mutflag_ mutflag -> - match _menhir_s with - | MenhirState1373 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_549 _endpos__0_ _endpos_mutflag_ _endpos_name_ - _endpos_ty_ _startpos_mutflag_ _startpos_name_ mutflag name ty - in - _menhir_run_1374 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState2041 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_549 _endpos__0_ _endpos_mutflag_ _endpos_name_ - _endpos_ty_ _startpos_mutflag_ _startpos_name_ mutflag name ty - in - _menhir_run_1365 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1346 -> - let (MenhirCell0_LBRACE (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_549 _endpos__0_ _endpos_mutflag_ _endpos_name_ - _endpos_ty_ _startpos_mutflag_ _startpos_name_ mutflag name ty - in - _menhir_run_1365 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1374 : - type ttv_stack. - ( ttv_stack _menhir_cell0_LBRACE, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0991 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_0992 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0960 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_STRUCT, _menhir_box_structure ) - _menhir_cell1_non_empty_list_semi_rev_aux_record_decl_field_ - _menhir_cell0_SEMI -> + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_SEMI (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_435 x xs in - _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_478 _endpos__1_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0947 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.SEMI _v_0 -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.PUB -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1348 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1373 _menhir_initp - | Lex_menhir_token.PRIV -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1360 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1373 _menhir_initp - | Lex_menhir_token.MUTABLE -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1373 _menhir_initp - | Lex_menhir_token.RBRACE -> - let x, xs = (_v_0, _v) in - let _v = _menhir_action_457 x xs in - _menhir_goto_non_empty_list_semis_record_decl_field_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _ -> - let _menhir_stack = - MenhirCell1_non_empty_list_semi_rev_aux_record_decl_field_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = - MenhirCell0_SEMI (_menhir_stack, _v_0, _endpos) - in - let _v_1 = _menhir_action_465 () in - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_1 MenhirState1373 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACE -> - let xs = _v in - let _v = _menhir_action_456 xs in - _menhir_goto_non_empty_list_semis_record_decl_field_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_562 _endpos__1_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1348 : - type ttv_stack. - ttv_stack -> + and _menhir_run_0942 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LPAREN -> - _menhir_run_1349 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1348 _menhir_initp - | Lex_menhir_token.LIDENT _ | Lex_menhir_token.MUTABLE -> - let _v = _menhir_action_536 () in - _menhir_run_1354 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - MenhirState1348 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1360 : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_554 _endpos__1_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0927 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ENUM, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_PRIV (_menhir_stack, _menhir_s, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.MUTABLE -> - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1360 _menhir_initp - | Lex_menhir_token.LIDENT _ -> - let _v = _menhir_action_465 () in - _menhir_run_1361 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v MenhirState1360 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1361 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV as 'stack) -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_048 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon + in + _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0914 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> + _ -> _ -> _ -> _ -> @@ -202197,278 +64625,311 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_MUTABLE_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _v = _v_0 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1363 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_goto_non_empty_list_semis_record_decl_field_ : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_optional_type_parameters_no_constraints + (_menhir_stack, _menhir_s, _v, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.DERIVE -> + _menhir_run_0758 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0914 _menhir_initp + | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> + let _v_0 = _menhir_action_043 () in + _menhir_run_0915 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v_0 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0870 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_479 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0857 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> + _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState2041 -> - _menhir_run_2044 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1346 -> - _menhir_run_1370 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_563 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_2044 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_struct_header - _menhir_cell0_LBRACE - as - 'stack) -> + and _menhir_run_0852 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident -> + _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_semis_record_decl_field_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RBRACE (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2045 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_032 () in - _menhir_run_2046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1370 : - type ttv_stack. + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_555 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0847 : type ttv_stack. ( (ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT, _menhir_box_structure ) - _menhir_cell1_luident - _menhir_cell0_LBRACE -> + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACE (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _)) = _menhir_stack in - let _endpos__5_, _1_inlined1 = (_endpos, _v) in - let _v = - _menhir_action_113 _1_inlined1 _endpos_tycon_ _startpos_tycon_ tycon - in - _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1366 : - type ttv_stack. - ttv_stack -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_477 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer + _startpos__3_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0691 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_option_MUTABLE_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LIDENT _v_0 -> ( - let _v = _v_0 in - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LIDENT (_menhir_stack, _v, _startpos, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1368 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | _ -> _eRR () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let _endpos_params_, params = (_endpos, _v) in + let _v = + _menhir_action_561 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_params_ _startpos__3_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1365 : - type ttv_stack. - (ttv_stack _menhir_cell0_LBRACE as 'stack) -> + and _menhir_run_0685 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPEALIAS, + _menhir_box_structure ) + _menhir_cell1_luident -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_434 x in - _menhir_goto_non_empty_list_semi_rev_aux_record_decl_field_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1364 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_luident + (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = + _menhir_stack + in + let (MenhirCell1_TYPEALIAS (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let params = _v in + let _v = + _menhir_action_553 _endpos_tycon_ _startpos_tycon_ params tycon + in + _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf + _menhir_lexer _startpos__3_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0677 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON + _menhir_cell1_LBRACKET as 'stack) -> _ -> _ -> _ -> - _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_option_MUTABLE_ - (_menhir_stack, _, mutflag, _startpos_mutflag_, _endpos_mutflag_)) - = - _menhir_stack - in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_ty_, ty = (_endpos, _v) in - let _v = - _menhir_action_550 _endpos__1_ _endpos_mutflag_ _endpos_name_ - _endpos_ty_ _startpos__1_ _startpos_mutflag_ _startpos_name_ mutflag - name ty - in - _menhir_goto_record_decl_field _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_record_decl_field : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _1 = _v in + let _v = _menhir_action_229 _1 in + _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_1307 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_EXTERN + _menhir_cell0_TYPE + as + 'stack) -> + _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1373 -> - _menhir_run_1374 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState2041 -> - _menhir_run_1365 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1346 -> - _menhir_run_1365 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1359 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1307 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState1307 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1265 : type ttv_stack. + (( ttv_stack, _menhir_box_structure ) - _menhir_cell1_option_MUTABLE_ - _menhir_cell0_LIDENT - _menhir_cell0_COLON + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_ENUM as 'stack) -> _ -> @@ -202480,235 +64941,195 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - (_menhir_stack, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_option_MUTABLE_ - (_menhir_stack, _, mutflag, _startpos_mutflag_, _endpos_mutflag_)) - = - _menhir_stack - in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_ty_, ty = (_endpos, _v) in - let _v = - _menhir_action_551 _endpos_attr_ _endpos_mutflag_ _endpos_name_ - _endpos_ty_ _startpos__1_ _startpos_mutflag_ _startpos_name_ attr - mutflag name ty - in - _menhir_goto_record_decl_field _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1313 : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1265 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1265 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1254 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let typ = _v in - let _v = _menhir_action_936 typ in - _menhir_goto_trait_method_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_trait_method_param : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1254 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState1254 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1223 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_STRUCT + as + 'stack) -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1316 -> - _menhir_run_1317 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1323 -> - _menhir_run_1314 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState1302 -> - _menhir_run_1314 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1317 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_trait_method_param_ - _menhir_cell0_COMMA -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_257 x xs in - _menhir_goto_non_empty_list_commas_rev_trait_method_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_non_empty_list_commas_rev_trait_method_param_ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1223 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1223 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1217 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT as 'stack) -> _ -> _ -> _ -> + _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1316 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1316 _menhir_initp - | Lex_menhir_token.POST_LABEL _v_1 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_1307 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1316 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_2 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1316 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1316 _menhir_initp - | Lex_menhir_token.LIDENT _v_3 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState1316 _menhir_initp - | Lex_menhir_token.LABEL _v_4 -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_trait_method_param_ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_1310 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1316 _menhir_initp - | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_156 x xs in - _menhir_goto_non_empty_list_commas_trait_method_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_155 xs in - _menhir_goto_non_empty_list_commas_trait_method_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp - | _ -> _menhir_fail () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1217 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_1218 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1217 _tok _menhir_initp + | _ -> _eRR () - and _menhir_goto_non_empty_list_commas_trait_method_param_ : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN - as - 'stack) -> - _ -> + and _menhir_run_0698 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> _ -> _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - match _menhir_s with - | MenhirState1323 -> - _menhir_run_1326 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | MenhirState1302 -> - _menhir_run_1318 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) + in + let _menhir_s = MenhirState0698 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0699 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1326 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, + and _menhir_run_1218 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN + _menhir_cell1_luident as 'stack) -> _ -> @@ -202716,205 +65137,262 @@ include struct _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> + _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1327 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_483 () in - _menhir_run_1328 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1328 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_trait_method_param_ - _menhir_cell0_RPAREN -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState1219 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_1220 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1213 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAITALIAS + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_trait_method_param_ - (_menhir_stack, _, _1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_return_type_, return_type = (_endpos, _v) in - let _v = - _menhir_action_935 _1 _endpos_name_ _endpos_return_type_ _startpos_name_ - name quantifiers return_type - in - _menhir_goto_trait_method_decl _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1214 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1318 : - type ttv_stack. - (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + and _menhir_run_1210 : type ttv_stack. + (( ttv_stack, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE as 'stack) -> _ -> _ -> _ -> + _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> + _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _menhir_initp -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_trait_method_param_ - (_menhir_stack, _menhir_s, _v) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> - _menhir_run_1304 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1319 _menhir_initp - | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> - let _v_0 = _menhir_action_483 () in - _menhir_run_1320 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1320 : - type ttv_stack. - ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LIDENT, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1210 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState1210 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1209 : type ttv_stack. + ( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPE, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_trait_method_param_ - _menhir_cell0_RPAREN -> - _ -> - _ -> - _ -> - _ -> + _menhir_cell1_EXCLAMATION -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_trait_method_param_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_optional_type_parameters (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let _endpos_return_type_, return_type = (_endpos, _v) in - let _v = - _menhir_action_933 _1_inlined1 _endpos_name_ _endpos_return_type_ - _startpos_name_ name quantifiers return_type - in - _menhir_goto_trait_method_decl _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - - and _menhir_run_1314 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_optional_type_parameters - _menhir_cell0_LPAREN - as - 'stack) -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - let x = _v in - let _v = _menhir_action_256 x in - _menhir_goto_non_empty_list_commas_rev_trait_method_param_ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1312 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_LABEL - _menhir_cell0_COLON - as - 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_571 _1 _endpos__1_inlined1_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ tycon + in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_goto_type_header_bang : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LABEL - ( _menhir_stack, - _menhir_s, - label_name, - _startpos_label_name_, - _endpos_label_name_ )) = - _menhir_stack - in - let typ = _v in - let _v = - _menhir_action_937 _endpos_label_name_ _startpos_label_name_ - label_name typ - in - _menhir_goto_trait_method_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1309 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_POST_LABEL - _menhir_cell0_COLON + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_header_bang + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1071 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1071 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState1071 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1071 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState1071 _menhir_initp + | Lex_menhir_token.LBRACE -> ( + let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_LBRACE + (_menhir_stack, MenhirState1071, _startpos_3, _endpos_4) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_5 -> + _menhir_run_0810 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState1072 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_6 = _menhir_action_150 () in + _menhir_run_1073 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState1072 _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1071 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1071 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState1071 in + let _v = _menhir_action_332 () in + _menhir_goto_option_type__ _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1205 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TYPEALIAS as 'stack) -> _ -> @@ -202926,40 +65404,39 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_POST_LABEL - ( _menhir_stack, - _menhir_s, - label_name, - _startpos_label_name_, - _endpos_label_name_ )) = - _menhir_stack - in - let typ = _v in - let _v = - _menhir_action_938 _endpos_label_name_ _startpos_label_name_ - label_name typ - in - _menhir_goto_trait_method_param _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1238 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_expr - _menhir_cell0_COLON + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1205 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState1205 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1190 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ENUM as 'stack) -> _ -> @@ -202967,36 +65444,44 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_expr (_menhir_stack, _, expr, _, _)) = _menhir_stack in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__4_, t = (_endpos_0, _v) in - let _v = _menhir_action_639 _endpos__4_ _startpos__1_ expr t in - _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0641 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_fn_label _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1190 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1190 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1179 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE as 'stack) -> _ -> @@ -203004,128 +65489,44 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0641 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) - in - let _menhir_s = MenhirState0642 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_fn_label (_menhir_stack, _menhir_s, label, _, _)) = - _menhir_stack - in - let t = _v in - let _v = _menhir_action_516 label t in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0637 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_fn_label _menhir_cell0_QUESTION - _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1179 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState1179 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1148 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT as 'stack) -> _ -> @@ -203133,34 +65534,43 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_fn_label (_menhir_stack, _menhir_s, label, _, _)) = - _menhir_stack - in - let t = _v in - let _v = _menhir_action_520 label t in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0629 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1148 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1148 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1142 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT as 'stack) -> _ -> @@ -203168,79 +65578,145 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) - = - _menhir_stack - in - let t = _v in - let _v = _menhir_action_514 _endpos_name_ _startpos_name_ name t in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1142 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_1143 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1142 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_0627 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_QUESTION - _menhir_cell0_COLON + and _menhir_run_1143 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident as 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState1144 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_1145 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1138 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS + as + 'stack) -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell0_QUESTION (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_LIDENT - ( _menhir_stack, - _menhir_s, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let t = _v in - let _v = - _menhir_action_526 _endpos_binder_name_ _startpos_binder_name_ - binder_name t - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1139 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_0621 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_POST_LABEL _menhir_cell0_COLON + and _menhir_run_1135 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE as 'stack) -> _ -> @@ -203248,138 +65724,98 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_s = MenhirState0621 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) - in - let _menhir_s = MenhirState0622 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_POST_LABEL - ( _menhir_stack, - _menhir_s, - binder_name, - _startpos_binder_name_, - _endpos_binder_name_ )) = - _menhir_stack - in - let t = _v in - let _v = - _menhir_action_522 _endpos_binder_name_ _startpos_binder_name_ - binder_name t - in - _menhir_goto_parameter _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_0478 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1135 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState1135 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1134 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_572 _1 _endpos_attr_ _endpos_tycon_ + _startpos__1_inlined1_ _startpos_tycon_ attr tycon + in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_1130 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS as 'stack) -> _ -> @@ -203387,119 +65823,40 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_s = MenhirState0478 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) - in - let _menhir_s = MenhirState0479 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0471 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LET, - ttv_result ) - _menhir_cell1_MUTABLE - _menhir_cell0_LIDENT - _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1130 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState1130 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1125 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_STRUCT as 'stack) -> _ -> @@ -203507,118 +65864,40 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EQUAL -> ( - let _menhir_s = MenhirState0471 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) - in - let _menhir_s = MenhirState0472 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0451 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_pattern - _menhir_cell0_COLON + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1125 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1125 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1115 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT as 'stack) -> _ -> @@ -203626,150 +65905,222 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = - _menhir_stack - in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__4_, t = (_endpos_0, _v) in - let _v = _menhir_action_657 _endpos__4_ _startpos__1_ pat t in - _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__4_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | _ -> _eRR () + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1115 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_1116 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState1115 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_0059 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> + and _menhir_run_1116 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState1117 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_1118 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1111 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAITALIAS + as + 'stack) -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _menhir_s = MenhirState0059 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RPAREN (_menhir_stack, _menhir_s, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( - let _menhir_s = MenhirState0061 in - let _tok = _menhir_lexer _menhir_lexbuf in + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE - | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE - | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> - let _v = _menhir_action_477 () in - _menhir_goto_option___anonymous_19_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos _v _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.QUESTION -> - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA -> ( - let _menhir_s = MenhirState0059 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_COMMA (_menhir_stack, _menhir_s, _endpos) - in - let _menhir_s = MenhirState0064 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState1112 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_goto_option___anonymous_19_ : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_RPAREN -> + and _menhir_run_1108 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1108 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState1108 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1107 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION -> _ -> _ -> _ -> _ -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_rty_, rty = (_endpos, _v) in - let _v = _menhir_action_949 _endpos_rty_ _startpos__1_ rty t in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rty_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0052 : - type ttv_stack ttv_result. - ((ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_type__ - _menhir_cell0_COMMA + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_570 _1 _endpos_tycon_ _startpos_tycon_ tycon + in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_1103 : type ttv_stack. + (( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TYPEALIAS as 'stack) -> _ -> @@ -203777,248 +66128,361 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let x = _v in - let _v = _menhir_action_259 x xs in - _menhir_goto_non_empty_list_commas_rev_type__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_non_empty_list_commas_rev_type__ : - type ttv_stack ttv_result. - ttv_stack -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1103 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState1103 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1054 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM as 'stack) -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COMMA -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, _v) - in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0051 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState0051 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1054 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1054 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1043 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_EXTERN + _menhir_cell0_TYPE + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState0051 _menhir_initp - | Lex_menhir_token.LPAREN -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1043 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState1043 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_1001 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0051 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState1001 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState1001 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0990 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_EXTERN + _menhir_cell0_TYPE + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_rev_type__ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _endpos) in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0051 _menhir_initp - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let x, xs = ((), _v) in - let _v = _menhir_action_158 x xs in - _menhir_goto_non_empty_list_commas_type__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN -> - let xs = _v in - let _v = _menhir_action_157 xs in - _menhir_goto_non_empty_list_commas_type__ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_goto_non_empty_list_commas_type__ : - type ttv_stack ttv_result. - ttv_stack -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0990 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState0990 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0959 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_STRUCT + as + 'stack) -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0064 -> - _menhir_run_0065 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0048 -> - _menhir_run_0054 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0065 : - type ttv_stack ttv_result. - (( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_COMMA + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0959 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState0959 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0953 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT as 'stack) -> _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RPAREN -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.THIN_ARROW -> ( + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_non_empty_list_commas_type__ - (_menhir_stack, _menhir_s, _v) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - let _menhir_stack = MenhirCell0_RPAREN (_menhir_stack, _endpos) in - let _menhir_s = MenhirState0067 in - let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE - | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE - | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> - let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = - _menhir_stack - in - let (MenhirCell1_LPAREN - (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos__5_, ts = (_endpos, _v) in - let _v = _menhir_action_946 _endpos__5_ _startpos__1_ t ts in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__5_ _startpos__1_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_0054 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_qual_ident_ty _menhir_cell0_LBRACKET -> + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0953 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_0954 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0953 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0954 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACKET -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_LBRACKET (_menhir_stack, _, _)) = _menhir_stack in - let _endpos__3_, x = (_endpos, _v) in - let _v = _menhir_action_490 x in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_0049 : - type ttv_stack ttv_result. - ttv_stack -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0955 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_0956 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0949 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TRAITALIAS + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET - | Lex_menhir_token.RPAREN -> - let x = _v in - let _v = _menhir_action_258 x in - _menhir_goto_non_empty_list_commas_rev_type__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0950 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_0046 : - type ttv_stack ttv_result. - (( (ttv_stack, ttv_result) _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_EXCLAMATION + and _menhir_run_0946 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE as 'stack) -> _ -> @@ -204026,994 +66490,431 @@ include struct _ -> _ -> _ -> - ('stack, ttv_result) _menhir_state -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF - | Lex_menhir_token.EQUAL | Lex_menhir_token.EXCLAMATION - | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = - _menhir_stack - in - let (MenhirCell1_type_ (_menhir_stack, _menhir_s, t1, _, _)) = - _menhir_stack - in - let _endpos_t2_, t2 = (_endpos, _v) in - let _v = _menhir_action_560 t1 t2 in - _menhir_goto_return_type _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_t2_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_goto_return_type : - type ttv_stack ttv_result. - ttv_stack -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0946 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState0946 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0945 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION -> _ -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1949 -> - _menhir_run_1950 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1921 -> - _menhir_run_1922 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1892 -> - _menhir_run_1893 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1864 -> - _menhir_run_1865 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1832 -> - _menhir_run_1833 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1804 -> - _menhir_run_1805 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1775 -> - _menhir_run_1776 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1747 -> - _menhir_run_1748 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1682 -> - _menhir_run_1683 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1669 -> - _menhir_run_1670 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1634 -> - _menhir_run_1635 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1606 -> - _menhir_run_1607 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1577 -> - _menhir_run_1578 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1549 -> - _menhir_run_1550 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1517 -> - _menhir_run_1518 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1489 -> - _menhir_run_1490 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1460 -> - _menhir_run_1461 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1432 -> - _menhir_run_1433 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _menhir_s _tok _menhir_initp - | MenhirState1304 -> - _menhir_run_1305 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0576 -> - _menhir_run_0577 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0033 -> - _menhir_run_0069 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState0067 -> - _menhir_run_0068 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0061 -> - _menhir_run_0062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState0041 -> - _menhir_run_0058 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1950 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_568 _endpos__1_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ tycon + in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0941 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TYPEALIAS as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1951 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1951 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_758 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _1_inlined2 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1951 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1951 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1951 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1951 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1951 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1951 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1951 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1951 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1951 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1951 _menhir_initp - | Lex_menhir_token.BREAK -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0941 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState0941 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0926 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_ENUM + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1951 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_758 : - type ttv_stack. - ttv_stack -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0926 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState0926 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0913 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_EXTERN + _menhir_cell0_TYPE + as + 'stack) -> + _ -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0913 _menhir_initp + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.SEMI _ -> + let _menhir_s = MenhirState0913 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0869 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_STRUCT + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0869 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState0869 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0863 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _1_inlined2 _endpos__1_inlined4_ - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_758 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_758 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0863 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_0864 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0863 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1922 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, + and _menhir_run_0864 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_TRAIT, _menhir_box_structure ) - _menhir_cell1_RPAREN + _menhir_cell1_luident as 'stack) -> _ -> _ -> _ -> - _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1923 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1923 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_746 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1923 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1923 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1923 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1923 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1923 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1923 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1923 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1923 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1923 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1923 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1923 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_746 : - type ttv_stack. - ttv_stack -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0865 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_0866 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0859 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS + as + 'stack) -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0860 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0856 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE + as + 'stack) -> + _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0856 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState0856 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0855 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION -> _ -> _ -> _ -> @@ -205022,507 +66923,212 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined3_ _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_746 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_746 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1893 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_569 _endpos_attr_ _endpos_tycon_ _startpos__1_ + _startpos_tycon_ attr tycon + in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0851 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN + _menhir_cell1_pub_attr + _menhir_cell0_TYPEALIAS as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1894 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1894 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_782 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _1_inlined1 _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1894 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1894 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1894 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1894 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1894 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1894 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1894 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1894 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1894 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1894 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1894 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_act_goto_782 : - type ttv_stack. - ttv_stack -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0851 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState0851 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0846 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT as 'stack) -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0846 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_s = MenhirState0846 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0808 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM as 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0810 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0809 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_3 = _menhir_action_150 () in + _menhir_run_0834 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0809 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0774 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT as 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _endpos__1_inlined3_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 self_ty quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_782 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_782 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PUB -> + _menhir_run_0776 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0775 _menhir_initp + | Lex_menhir_token.PRIV -> + _menhir_run_0788 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0775 _menhir_initp + | Lex_menhir_token.MUTABLE -> + _menhir_run_0783 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0775 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_2 = _menhir_action_154 () in + _menhir_run_0804 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0775 _menhir_initp + | Lex_menhir_token.LIDENT _ -> + let _v_3 = _menhir_action_288 () in + _menhir_run_0794 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_1 _endpos_1 _v_3 MenhirState0775 _tok + _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1865 : - type ttv_stack. - (( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - as - 'stack) -> + and _menhir_run_0756 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE as 'stack) -> + _ -> _ -> _ -> _ -> @@ -205531,442 +67137,225 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1866 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1866 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_770 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - self_ty quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1866 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1866 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1866 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1866 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1866 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1866 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1866 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1866 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1866 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1866 _menhir_initp - | Lex_menhir_token.BREAK -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1866 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0756 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0756 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_1 -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0756 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0756 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0756 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0756 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0756 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0715 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0716 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0699 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_535 _endpos_name_ _startpos_name_ name + in + _menhir_goto_tvar_binder _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_770 : - type ttv_stack. + and _menhir_goto_tvar_binder : type ttv_stack. ttv_stack -> _ -> _ -> + _ -> (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0713 -> + _menhir_run_0714 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0710 -> + _menhir_run_0711 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0714 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET, + _menhir_box_structure ) + _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__, + _menhir_box_structure ) + _menhir_cell1_COMMA -> + _ -> _ -> _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _1 = _v in + let _v = _menhir_action_228 _1 xs in + _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET as 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0712, _endpos) + in + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0713 _menhir_initp + | Lex_menhir_token.LIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0712, _endpos) + in + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0713 _menhir_initp + | Lex_menhir_token.RBRACKET -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0718 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACKET -> + let _ = _menhir_action_286 () in + _menhir_run_0718 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0711 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET as 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined2_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 self_ty - quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_770 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_770 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers self_ty - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_1833 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _1 = _v in + let _v = _menhir_action_227 _1 in + _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0697 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT as 'stack) -> + _ -> _ -> _ -> _ -> @@ -205975,1259 +67364,1507 @@ include struct _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1834 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1834 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_854 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _1_inlined2 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1834 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1834 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1834 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1834 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.LBRACE -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1834 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1834 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1834 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1834 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1834 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> + _menhir_run_0698 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0697 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _v_0 = _menhir_action_306 () in + _menhir_run_0706 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0697 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0706 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT, + _menhir_box_structure ) + _menhir_cell1_luident + as + 'stack) -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option___anonymous_2_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> + _menhir_run_0708 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0707 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _v_1 = _menhir_action_160 () in + _menhir_run_0747 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0693 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TRAITALIAS as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0694 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0690 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1834 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0690 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.ASYNC + | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF + | Lex_menhir_token.LIDENT _ | Lex_menhir_token.LPAREN + | Lex_menhir_token.PACKAGE_NAME _ | Lex_menhir_token.SEMI _ + | Lex_menhir_token.UIDENT _ | Lex_menhir_token.UNDERSCORE -> + let _menhir_s = MenhirState0690 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0689 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, + _menhir_box_structure ) + _menhir_cell1_EXCLAMATION -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = + _menhir_stack + in + let (MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__3_)) = + _menhir_stack + in + let _endpos_tycon_, _startpos_tycon_, tycon = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_567 _endpos_tycon_ _startpos_tycon_ tycon in + _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_tycon_ _startpos__3_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0681 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) in + let _v = _menhir_action_559 _endpos_name_ _startpos_name_ name in + _menhir_goto_type_decl_binder _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0674 : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_TYPEALIAS as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_luident + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1834 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> + _menhir_run_0675 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0674 _menhir_initp + | Lex_menhir_token.EQUAL -> + let _menhir_s = MenhirState0674 in + let _v = _menhir_action_320 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v + _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_act_goto_854 : + and _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ : type ttv_stack. ttv_stack -> _ -> _ -> + _ -> (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0716 -> + _menhir_run_0717 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0698 -> + _menhir_run_0705 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | MenhirState0702 -> + _menhir_run_0703 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0717 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_luident + _menhir_cell0_COLON -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_)) + = + _menhir_stack + in + let constraints = _v in + let _v = + _menhir_action_536 _endpos_name_ _startpos_name_ constraints name + in + _menhir_goto_tvar_binder _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + + and _menhir_run_0705 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, + _menhir_box_structure ) + _menhir_cell1_COLON -> + _ -> _ -> _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COLON (_menhir_stack, _menhir_s, _)) = + _menhir_stack + in + let _2 = _v in + let _v = _menhir_action_307 _2 in + _menhir_goto_option___anonymous_2_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option___anonymous_2_ : type ttv_stack. + ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1217 -> + _menhir_run_1218 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1142 -> + _menhir_run_1143 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1115 -> + _menhir_run_1116 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0953 -> + _menhir_run_0954 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0863 -> + _menhir_run_0864 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0697 -> + _menhir_run_0706 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0703 : type ttv_stack. + (ttv_stack, _menhir_box_structure) _menhir_cell1_tvar_constraint + _menhir_cell0_PLUS -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _1_inlined2 _endpos__1_inlined4_ - _startpos__1_inlined4_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_854 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_854 _1_inlined2 _2_inlined1 _endpos__0_ - _endpos__1_inlined4_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined4_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_PLUS (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_tvar_constraint (_menhir_stack, _menhir_s, x)) = + _menhir_stack + in + let xs = _v in + let _v = _menhir_action_396 x xs in + _menhir_goto_separated_nonempty_list_PLUS_tvar_constraint_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0157 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_573 _endpos_name_ _startpos_name_ name in + _menhir_goto_type_name _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_name_ _startpos_name_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1805 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + and _menhir_goto_type_name : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState1283 -> + _menhir_run_1284 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1230 -> + _menhir_run_1231 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1214 -> + _menhir_run_1215 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1155 -> + _menhir_run_1156 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1139 -> + _menhir_run_1140 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1112 -> + _menhir_run_1113 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1019 -> + _menhir_run_1020 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0966 -> + _menhir_run_0967 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0950 -> + _menhir_run_0951 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState1325 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1311 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1299 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1272 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1258 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1246 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1197 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1183 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1171 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1062 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1047 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1035 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState1008 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0994 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0982 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0933 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0917 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0899 -> + _menhir_run_0901 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0876 -> + _menhir_run_0877 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0860 -> + _menhir_run_0861 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0765 -> + _menhir_run_0760 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0759 -> + _menhir_run_0760 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0694 -> + _menhir_run_0695 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0257 -> + _menhir_run_0258 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0662 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0128 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0181 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0155 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0152 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState1069 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0841 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0754 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0761 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0000 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0003 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0008 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0014 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0646 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0015 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0016 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0019 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0024 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0630 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0025 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0626 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0618 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0026 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0602 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0597 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0590 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0027 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0030 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0565 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0096 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0551 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0110 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0500 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0514 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0511 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0503 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0498 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0494 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0491 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0487 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0466 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0460 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0456 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0448 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0446 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0441 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0437 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0433 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0430 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0423 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0419 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0415 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0412 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0407 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0403 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0397 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0395 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0387 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0385 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0369 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0379 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0380 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0374 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0375 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0358 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0353 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0349 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0342 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0338 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0328 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0312 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0310 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0304 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0300 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0298 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0296 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0294 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0292 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0290 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0288 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0286 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0284 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0280 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0278 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0276 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0273 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0261 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0125 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0121 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0111 -> + _menhir_run_0115 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_1284 : type ttv_stack. + (( ( ttv_stack, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN + _menhir_cell1_optional_type_parameters as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1806 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1806 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_842 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1806 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1806 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1806 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1806 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1806 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1806 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1806 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1806 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1806 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1806 _menhir_initp - | Lex_menhir_token.BREAK -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1286 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1287 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1286 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState1291 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1231 : type ttv_stack. + (( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1233 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1234 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1233 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState1238 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_1215 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PRIV + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAITALIAS (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell0_PRIV + (_menhir_stack, _startpos__1_inlined1_, _endpos__1_inlined1_)) + = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_target_, target = (_endpos, _v) in + let _v = + _menhir_action_514 _1 _endpos__1_ _endpos__1_inlined1_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ name target + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1156 : type ttv_stack. + (( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1806 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1158 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1159 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1158 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState1163 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_act_goto_842 : - type ttv_stack. - ttv_stack -> + and _menhir_run_1140 : type ttv_stack. + ( ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL -> + _ -> + _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAITALIAS (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell0_PUB (_menhir_stack, _startpos__1_inlined1_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_target_, target = (_endpos, _v) in + let _v = + _menhir_action_515 _1 _endpos__1_ _endpos_attr_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__1_inlined1_ _startpos__3_ + _startpos_name_ attr name target + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1113 : type ttv_stack. + ( ( ttv_stack, + _menhir_box_structure ) + _menhir_cell1_non_empty_list___anonymous_5_ + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL -> _ -> _ -> _ -> _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAITALIAS (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_non_empty_list___anonymous_5_ + (_menhir_stack, _menhir_s, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let _endpos_target_, target = (_endpos, _v) in + let _v = + _menhir_action_513 _1 _endpos__1_ _endpos_name_ _endpos_target_ + _startpos__1_ _startpos__3_ _startpos_name_ name target + in + _menhir_goto_structure_item _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_run_1020 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, + _menhir_box_structure ) + _menhir_cell1_optional_type_parameters + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined3_ _startpos__1_inlined3_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_842 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_842 _2_inlined1 _endpos__0_ _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState1022 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_1023 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState1022 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState1027 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1776 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + and _menhir_run_0967 : type ttv_stack. + (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN + _menhir_cell1_optional_type_parameters as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1777 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1777 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_878 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _1_inlined1 _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1777 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1777 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1777 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1777 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1777 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1777 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1777 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1777 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1777 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1777 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1777 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0969 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_0970 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState0969 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0974 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_act_goto_878 : - type ttv_stack. + and _menhir_run_0951 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAITALIAS (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_PRIV + (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + _menhir_act_goto_511 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos__1_ _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos _v + + and _menhir_act_goto_511 : type ttv_stack. ttv_stack -> _ -> _ -> @@ -207242,429 +68879,211 @@ include struct _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos__1_ -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_target_ -> + fun target -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_511 _endpos__0_ _endpos__1_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__3_ + _startpos_name_ name target + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_511 _endpos__0_ _endpos__1_ _endpos_name_ + _endpos_target_ _startpos__1_ _startpos__3_ + _startpos_name_ name target + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0901 : type ttv_stack. + ttv_stack -> _ -> _ -> _ -> - _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _1_inlined1 - _endpos__2_inlined1_ _2_inlined1 _endpos__4_ _endpos__1_inlined3_ - _startpos__1_inlined3_ _endpos_name_inlined1_ _startpos_name_inlined1_ - name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_878 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_878 _1_inlined1 _2_inlined1 _endpos__0_ - _endpos__1_inlined3_ _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined3_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLONCOLON -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_1 -> + let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let ( _endpos, + type_name, + _endpos_func_name_, + _startpos_func_name_, + func_name ) = + (_endpos_3, _v, _endpos_3, _startpos_2, _v_1) + in + let _v = + _menhir_action_087 _endpos_func_name_ _startpos_func_name_ + func_name type_name + in + _menhir_goto_fun_binder _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _v _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1748 : - type ttv_stack. - (( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, + and _menhir_run_0877 : type ttv_stack. + (( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, + _menhir_cell1_pub_attr + _menhir_cell0_IMPL, _menhir_box_structure ) - _menhir_cell1_RPAREN + _menhir_cell1_optional_type_parameters as 'stack) -> _ -> _ -> _ -> _ -> + _ -> ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1749 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1749 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - _menhir_act_goto_866 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name - _startpos__2_ _endpos _v _endpos_3 _endpos_0 _startpos - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 - quantifiers - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1749 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1749 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1749 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1749 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1749 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1749 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1749 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1749 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1749 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1749 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1749 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.WITH -> ( + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_0 -> ( + let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LIDENT + (_menhir_stack, _v_0, _startpos_1, _endpos_2) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EXCLAMATION -> + _menhir_run_0032 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0879 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _v_3 = _menhir_action_337 () in + _menhir_run_0880 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_3 MenhirState0879 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.FOR -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_FOR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0889 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_act_goto_866 : - type ttv_stack. + and _menhir_run_0861 : type ttv_stack. + ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, + _menhir_box_structure ) + _menhir_cell1_pub_attr + _menhir_cell0_TRAITALIAS, + _menhir_box_structure ) + _menhir_cell1_luident + _menhir_cell0_EQUAL -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell0_TRAITALIAS (_menhir_stack, _startpos__3_)) = + _menhir_stack + in + let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = + _menhir_stack + in + let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_)) = + _menhir_stack + in + _menhir_act_goto_512 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _startpos__1_ _endpos_name_ + _startpos_name_ name _startpos__3_ _endpos_attr_ attr _endpos _v + + and _menhir_act_goto_512 : type ttv_stack. ttv_stack -> _ -> _ -> @@ -207680,4337 +69099,4402 @@ include struct _ -> _ -> _ -> + _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _startpos__1_ -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_attr_ -> + fun attr -> + fun _endpos_target_ -> + fun target -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_512 _endpos__0_ _endpos_attr_ + _endpos_name_ _endpos_target_ _startpos__1_ + _startpos__3_ _startpos_name_ attr name target + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_512 _endpos__0_ _endpos_attr_ + _endpos_name_ _endpos_target_ _startpos__1_ + _startpos__3_ _startpos_name_ attr name target + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0760 : type ttv_stack. + ttv_stack -> + _ -> + _ -> _ -> _ -> _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _menhir_initp - _endpos_name_ _startpos_name_ name _startpos__2_ _endpos__2_inlined1_ - _2_inlined1 _endpos__4_ _endpos__1_inlined2_ _startpos__1_inlined2_ - _endpos_name_inlined1_ _startpos_name_inlined1_ name_inlined1 quantifiers -> - match _menhir_s with - | MenhirState2050 -> - let (MenhirCell0_SEMI (_, _, _endpos__0_)) = _menhir_stack in - let _v = - _menhir_action_866 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1254 -> - let _endpos__0_ = _menhir_initp in - let _v = - _menhir_action_866 _2_inlined1 _endpos__0_ _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _startpos__1_inlined2_ _startpos__2_ - _startpos_name_ _startpos_name_inlined1_ name name_inlined1 - quantifiers - in - _menhir_run_2038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LPAREN -> ( + let _menhir_stack = + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LPAREN (_menhir_stack, _startpos_0, _endpos_1) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.UIDENT _v_2 -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0761 _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.STRING _v_3 -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0761 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_4 -> + _menhir_run_0020 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0761 _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_5 -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0761 _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v_6 -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0761 _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v_7 -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0761 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.LIDENT _v_8 -> + _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0761 _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.INTERP _v_9 -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0761 _menhir_initp + | Lex_menhir_token.INT _v_10 -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_10 MenhirState0761 _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.FLOAT _v_11 -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_11 MenhirState0761 _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.CHAR _v_12 -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_12 MenhirState0761 _menhir_initp + | Lex_menhir_token.BYTES _v_13 -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_13 MenhirState0761 _menhir_initp + | Lex_menhir_token.BYTE _v_14 -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_14 MenhirState0761 _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0761 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _v_15 = _menhir_action_126 () in + _menhir_run_0762 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_15 _tok _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + let _endpos, _menhir_s = (_endpos_1, MenhirState0761) in + let _v = _menhir_action_172 () in + _menhir_goto_loop_label_colon _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _endpos _v _menhir_s _tok + _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let _endpos_type_name_, _startpos_type_name_, type_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_041 _endpos_type_name_ _startpos_type_name_ + type_name + in + _menhir_goto_deriving_directive _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1683 : - type ttv_stack. - ( ( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, + and _menhir_run_0695 : type ttv_stack. + ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TRAITALIAS, _menhir_box_structure ) - _menhir_cell1_THIN_ARROW -> + _menhir_cell1_luident + _menhir_cell0_EQUAL -> + _ -> _ -> _ -> _ -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s)) = _menhir_stack in - let t = _v in - let _v = _menhir_action_470 t in - _menhir_goto_option___anonymous_1_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_1_ : - type ttv_stack. - (( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - as - 'stack) -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_luident + (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = + _menhir_stack + in + let (MenhirCell1_TRAITALIAS (_menhir_stack, _menhir_s, _startpos__3_)) + = + _menhir_stack + in + _menhir_act_goto_510 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _tok _menhir_initp _endpos_name_ _startpos_name_ name + _startpos__3_ _endpos _v + + and _menhir_act_goto_510 : type ttv_stack. + ttv_stack -> + _ -> + _ -> + (ttv_stack, _menhir_box_structure) _menhir_state -> + _ -> + _ -> + _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1993 -> - _menhir_run_1994 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1990 -> - _menhir_run_1991 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1686 -> - _menhir_run_1687 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1681 -> - _menhir_run_1684 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | _ -> _menhir_fail () + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + fun _endpos_name_ -> + fun _startpos_name_ -> + fun name -> + fun _startpos__3_ -> + fun _endpos_target_ -> + fun target -> + match _menhir_s with + | MenhirState1097 -> + let (MenhirCell1_SEMI (_, _, _, _endpos__0_)) = + _menhir_stack + in + let _v = + _menhir_action_510 _endpos__0_ _endpos_name_ + _endpos_target_ _startpos__3_ _startpos_name_ name target + in + _menhir_run_1098 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _tok _menhir_initp + | MenhirState0672 -> + let _endpos__0_ = _menhir_initp in + let _v = + _menhir_action_510 _endpos__0_ _endpos_name_ + _endpos_target_ _startpos__3_ _startpos_name_ name target + in + _menhir_run_1087 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0258 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_range_expr -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_range_expr + (_menhir_stack, _menhir_s, expr, _startpos_expr_, _)) = + _menhir_stack + in + let _endpos_trait_, trait = (_endpos, _v) in + let _v = + _menhir_action_362 _endpos_trait_ _startpos_expr_ expr trait + in + _menhir_goto_postfix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_trait_ _startpos_expr_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1670 : - type ttv_stack. - ( ( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_, - _menhir_box_structure ) - _menhir_cell1_THIN_ARROW -> + and _menhir_run_0152 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s)) = _menhir_stack in - let t = _v in - let _v = _menhir_action_468 t in - _menhir_goto_option___anonymous_0_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_0_ : - type ttv_stack. - (( ( ttv_stack, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_option_parameters_ - as - 'stack) -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLONCOLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLONCOLON (_menhir_stack, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0117 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_type_name _menhir_cell0_COLONCOLON -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1982 -> - _menhir_run_1983 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1979 -> - _menhir_run_1980 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1673 -> - _menhir_run_1674 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok - _menhir_initp - | MenhirState1668 -> - _menhir_run_1671 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell0_COLONCOLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_type_name + (_menhir_stack, _menhir_s, type_name, _startpos_type_name_, _)) = + _menhir_stack + in + let _endpos_constr_name_, _startpos_constr_name_, constr_name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_032 _endpos_constr_name_ _startpos_constr_name_ + _startpos_type_name_ constr_name type_name + in + _menhir_goto_constr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_constr_name_ _startpos_type_name_ _v _menhir_s _tok _menhir_initp - | _ -> _menhir_fail () - and _menhir_run_1635 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> + and _menhir_run_0115 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1636 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1636 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined4_, - _startpos__1_inlined4_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_806 _1_inlined2 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1636 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1636 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1636 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1636 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1636 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1636 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1636 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1636 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1636 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1636 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1636 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLONCOLON -> ( + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UIDENT _v_1 -> + let _menhir_stack = + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COLONCOLON (_menhir_stack, _endpos_0) + in + _menhir_run_0117 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 _menhir_initp + | Lex_menhir_token.LIDENT _v_2 -> + let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let ( _startpos_type_name_, + type_name, + _endpos_meth_, + _startpos_meth_, + meth ) = + (_startpos, _v, _endpos_4, _startpos_3, _v_2) + in + let _v = + _menhir_action_438 _endpos_meth_ _startpos_meth_ + _startpos_type_name_ meth type_name + in + _menhir_goto_simple_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_meth_ _startpos_type_name_ _v + _menhir_s _tok _menhir_initp + | Lex_menhir_token.LBRACE -> ( + let _menhir_stack = + MenhirCell1_type_name + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_stack = + MenhirCell0_COLONCOLON (_menhir_stack, _endpos_0) + in + let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos_5, _endpos_6) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v_7 -> + _menhir_run_0120 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_7 MenhirState0119 _menhir_initp + | Lex_menhir_token.DOTDOT -> ( + let _menhir_s = MenhirState0119 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_DOTDOT + (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0466 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _v_24 = _menhir_action_148 () in + _menhir_run_0481 _menhir_stack _menhir_lexbuf + _menhir_lexer _v_24 _tok _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | _ -> _eRR () - and _menhir_run_1607 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - as - 'stack) -> + and _menhir_run_0113 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_AMPER -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_AMPER (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_name_, name = (_endpos, _v) in + let _v = _menhir_action_574 _endpos_name_ _startpos__1_ name in + _menhir_goto_type_name _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_name_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0057 : type ttv_stack ttv_result. + ttv_stack -> + _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1608 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1608 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_794 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1608 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1608 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1608 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1608 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1608 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1608 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1608 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1608 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1608 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1608 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_qual_ident_ty + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1608 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACKET -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0058 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE + | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> + let _v = _menhir_action_322 () in + _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_type___RBRACKET__ + _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1578 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN + and _menhir_run_0051 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_AMPER -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_AMPER (_menhir_stack, _menhir_s, _startpos__1_, _)) + = + _menhir_stack + in + let _endpos_lid_, _startpos_lid_, lid = (_endpos, _startpos, _v) in + let _v = _menhir_action_551 _endpos_lid_ _startpos_lid_ lid in + _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_lid_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_run_0326 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + let _v = _menhir_action_085 () in + _menhir_goto_foreach_binder _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_goto_foreach_binder : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0325 -> + _menhir_run_0347 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0331 -> + _menhir_run_0333 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0347 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR as 'stack) -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let x = _v in + let _v = _menhir_action_225 x in + _menhir_goto_non_empty_list_commas_rev_foreach_binder_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_goto_non_empty_list_commas_rev_foreach_binder_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon _menhir_cell0_FOR + as + 'stack) -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1579 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1579 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_830 _1_inlined1 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1579 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1579 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1579 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1579 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1579 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1579 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1579 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1579 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1579 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1579 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_foreach_binder_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0330, _endpos) + in + _menhir_run_0326 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0331 _menhir_initp + | Lex_menhir_token.LIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0330, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _v_2 = + let _endpos_name_, _startpos_name_, name = + (_endpos_1, _startpos, _v_0) + in + _menhir_action_084 _endpos_name_ _startpos_name_ name + in + _menhir_run_0333 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 _tok _menhir_initp + | Lex_menhir_token.IN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0334 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.IN -> + let _ = _menhir_action_286 () in + _menhir_run_0334 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0333 : type ttv_stack ttv_result. + ( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_foreach_binder_, + ttv_result ) + _menhir_cell1_COMMA -> + _ -> + _ -> + _ -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_foreach_binder_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_226 x xs in + _menhir_goto_non_empty_list_commas_rev_foreach_binder_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0212 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_map_syntax_key + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1579 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0199 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0212 _menhir_initp + | Lex_menhir_token.COLON -> + let _v_0 = _menhir_action_290 () in + _menhir_run_0213 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0212 _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1550 : - type ttv_stack. - (( ( ( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_FOR, - _menhir_box_structure ) - _menhir_cell1_type_, - _menhir_box_structure ) - _menhir_cell1_WITH - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN + and _menhir_run_0199 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_map_syntax_key as 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + let x = () in + let _v = _menhir_action_291 x in + _menhir_goto_option_QUESTION_ _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _tok _menhir_initp + + and _menhir_goto_option_QUESTION_ : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_map_syntax_key as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0212 -> + _menhir_run_0213 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | MenhirState0198 -> + _menhir_run_0200 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0213 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_map_syntax_key as 'stack) -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_QUESTION_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0214 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0200 : type ttv_stack ttv_result. + (( ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_map_syntax_key + as + 'stack) -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1551 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1551 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_WITH (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, self_ty, _, _)) = - _menhir_stack - in - let (MenhirCell0_FOR (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_818 _2_inlined1 _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers self_ty x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1551 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1551 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1551 _menhir_initp - | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1551 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1551 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1551 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1551 _menhir_initp - | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1551 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1551 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1551 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1551 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1518 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_option_QUESTION_ (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0201 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR () + + and _menhir_run_0198 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, + ttv_result ) + _menhir_cell1_COMMA as 'stack) -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_map_syntax_key + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.QUESTION -> + _menhir_run_0199 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0198 _menhir_initp + | Lex_menhir_token.COLON -> + let _v_0 = _menhir_action_290 () in + _menhir_run_0200 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0198 _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0187 : type ttv_stack ttv_result. + ttv_stack -> + _ -> + _ -> + _ -> + _ -> + _ -> + (ttv_stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_176 _1 in + _menhir_goto_map_syntax_key _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + + and _menhir_run_0286 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0286 in let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1519 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1519 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined2)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined4_, - _startpos__1_inlined4_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_902 _1_inlined2 _2_inlined1 _endpos__1_inlined4_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined4_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1519 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1519 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1519 _menhir_initp + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1519 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1519 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1519 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1519 _menhir_initp + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1519 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1519 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1519 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1519 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1490 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_EXCLAMATION - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - as - 'stack) -> + and _menhir_run_0280 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_INFIX4 (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0280 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0284 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_INFIX3 (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0284 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0288 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_INFIX2 (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0288 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0290 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_INFIX1 (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0290 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0292 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_CARET (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0292 in let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1491 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1491 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_EXCLAMATION (_menhir_stack, _, _)) = - _menhir_stack - in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_890 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1491 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1491 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1491 _menhir_initp + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1491 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1491 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1491 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1491 _menhir_initp + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1491 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1491 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1491 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1491 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1461 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_parameter_ - _menhir_cell0_RPAREN - as - 'stack) -> - _ -> - _ -> + and _menhir_run_0296 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_BARBAR (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0296 in let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1462 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1462 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_parameter_ - (_menhir_stack, _, _1_inlined1)) = - _menhir_stack - in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined3_, - _startpos__1_inlined3_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_926 _1_inlined1 _2_inlined1 _endpos__1_inlined3_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined3_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1462 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1462 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1462 _menhir_initp + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1462 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1462 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1462 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1462 _menhir_initp + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FALSE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1462 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1462 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1462 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1462 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0298 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_BAR (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0298 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () - and _menhir_run_1433 : - type ttv_stack. - (( ( ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_IMPL, - _menhir_box_structure ) - _menhir_cell1_optional_type_parameters, - _menhir_box_structure ) - _menhir_cell1_qual_ident_ty - _menhir_cell0_LIDENT - _menhir_cell0_LPAREN, - _menhir_box_structure ) - _menhir_cell1_RPAREN - as - 'stack) -> + and _menhir_run_0300 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_AMPERAMPER (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0300 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0294 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_infix_expr as 'stack) -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> let _startpos = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell1_AMPER (_menhir_stack, _menhir_s, _startpos, _endpos) + in + let _menhir_s = MenhirState0294 in let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.UIDENT _v_1 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState1434 _menhir_initp - | Lex_menhir_token.TRY -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.TRUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.STRUCT -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1344 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.STRING _v_2 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1434 _menhir_initp - | Lex_menhir_token.RETURN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0072 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell0_LIDENT - ( _menhir_stack, - name_inlined1, - _startpos_name_inlined1_, - _endpos_name_inlined1_ )) = - _menhir_stack - in - let (MenhirCell1_qual_ident_ty - (_menhir_stack, _, name, _startpos_name_, _endpos_name_)) = - _menhir_stack - in - let (MenhirCell1_optional_type_parameters - (_menhir_stack, _, quantifiers)) = - _menhir_stack - in - let (MenhirCell1_IMPL (_menhir_stack, _, _startpos__2_)) = - _menhir_stack - in - let (MenhirCell1_PUB - (_menhir_stack, _menhir_s, _startpos_x_, _endpos_x_)) = - _menhir_stack - in - let ( x, - _endpos__2_inlined1_, - _2_inlined1, - _endpos__4_, - _endpos__1_inlined2_, - _startpos__1_inlined2_ ) = - ((), _endpos, _v, _endpos_3, _endpos_0, _startpos) - in - let _v = - _menhir_action_914 _2_inlined1 _endpos__1_inlined2_ - _endpos__2_inlined1_ _endpos__4_ _endpos_name_ - _endpos_name_inlined1_ _endpos_x_ _startpos__1_inlined2_ - _startpos__2_ _startpos_name_ _startpos_name_inlined1_ - _startpos_x_ name name_inlined1 quantifiers x - in - _menhir_goto_structure_item _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.RAISE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.PLUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_4 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0245 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState1434 _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v_5 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 - MenhirState1434 _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v_6 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 - MenhirState1434 _menhir_initp + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.MINUS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.MATCH -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.LOOP -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.LIDENT _v_7 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0247 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 - MenhirState1434 _menhir_initp - | Lex_menhir_token.LET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0248 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.LBRACKET -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp | Lex_menhir_token.LBRACE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.INTERP _v_8 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 - MenhirState1434 _menhir_initp - | Lex_menhir_token.INT _v_9 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 - MenhirState1434 _menhir_initp - | Lex_menhir_token.IF -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.GUARD -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0481 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.FOR -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FN -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0572 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.FLOAT _v_10 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 - MenhirState1434 _menhir_initp + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR () + + and _menhir_run_0584 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_IF as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.ENUM -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_1376 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.ELLIPSIS -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0581 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.CONTINUE -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0582 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | Lex_menhir_token.CHAR _v_11 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 - MenhirState1434 _menhir_initp - | Lex_menhir_token.BYTES _v_12 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 - MenhirState1434 _menhir_initp - | Lex_menhir_token.BYTE _v_13 -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) - in - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 - MenhirState1434 _menhir_initp - | Lex_menhir_token.BREAK -> - let _menhir_stack = - MenhirCell1_return_type (_menhir_stack, _menhir_s, _v, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos_0) + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in - _menhir_run_0584 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1434 _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0584 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0584 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0584 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0584 _menhir_initp + | Lex_menhir_token.CARET -> + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.BARBAR -> + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.BAR -> + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0584 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0523 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_GUARD as 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0523 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0523 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0523 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0523 _menhir_initp + | Lex_menhir_token.ELSE -> ( + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0523 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) + in + let _menhir_s = MenhirState0524 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0523 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_GUARD + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_cond_, cond = (_endpos, _v) in + let _v = _menhir_action_101 _endpos_cond_ _startpos__1_ cond in + _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0504 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_GUARD, + ttv_result ) + _menhir_cell1_LET, + ttv_result ) + _menhir_cell1_pattern + _menhir_cell0_EQUAL + as + 'stack) -> + _ -> + _ -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0504 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0504 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0504 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0504 _menhir_initp + | Lex_menhir_token.ELSE -> ( + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _menhir_s = MenhirState0504 in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _menhir_stack = + MenhirCell1_ELSE (_menhir_stack, _menhir_s, _startpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LBRACE -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_LBRACE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0506 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | Lex_menhir_token.RBRACE -> + _menhir_reduce_156 _menhir_stack _menhir_lexbuf + _menhir_lexer _menhir_s _menhir_initp + | _ -> _eRR ()) + | _ -> _eRR ()) + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0504 _menhir_initp + | Lex_menhir_token.RBRACE | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pattern (_menhir_stack, _, pat, _, _)) = + _menhir_stack + in + let (MenhirCell1_LET (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_GUARD + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _endpos_expr_, expr = (_endpos, _v) in + let _v = + _menhir_action_103 _endpos_expr_ _startpos__1_ expr pat + in + _menhir_goto_guard_statement _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1305 : - type ttv_stack. - (ttv_stack, _menhir_box_structure) _menhir_cell1_THIN_ARROW -> - _ -> - _ -> - _ -> - _ -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s)) = _menhir_stack in - let _endpos_t_, t = (_endpos, _v) in - let _v = _menhir_action_484 t in - _menhir_goto_option___anonymous_5_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_t_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_5_ : - type ttv_stack. - ttv_stack -> - _ -> - _ -> - _ -> - _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + and _menhir_run_0364 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_FOR, + ttv_result ) + _menhir_cell1_for_binders, + ttv_result ) + _menhir_cell1_SEMI + as + 'stack) -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState1327 -> - _menhir_run_1328 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1324 -> - _menhir_run_1325 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1319 -> - _menhir_run_1320 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | MenhirState1303 -> - _menhir_run_1306 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0577 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_THIN_ARROW -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s)) = _menhir_stack in - let t = _v in - let _v = _menhir_action_486 t in - _menhir_goto_option___anonymous_6_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_6_ : - type ttv_stack ttv_result. + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0364 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0364 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0364 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0364 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0364 _menhir_initp + | Lex_menhir_token.SEMI _ -> + let x = _v in + let _v = _menhir_action_327 x in + _menhir_goto_option_infix_expr_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0314 : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0740 -> - _menhir_run_0741 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0731 -> - _menhir_run_0732 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0645 -> - _menhir_run_0646 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0575 -> - _menhir_run_0578 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0069 : - type ttv_stack ttv_result. - (ttv_stack, ttv_result) _menhir_cell1_THIN_ARROW -> - _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_THIN_ARROW (_menhir_stack, _menhir_s)) = _menhir_stack in - let t = _v in - let _v = _menhir_action_472 t in - _menhir_goto_option___anonymous_15_ _menhir_stack _menhir_lexbuf - _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_goto_option___anonymous_15_ : - type ttv_stack ttv_result. + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0314 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0314 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0314 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0314 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0314 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_361 _1 in + _menhir_goto_pipe_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_pipe_expr : type ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> - _ -> - _ -> - ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok - _menhir_initp -> - match _menhir_s with - | MenhirState0915 -> - _menhir_run_0916 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0839 -> - _menhir_run_0840 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0830 -> - _menhir_run_0831 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | MenhirState0032 -> - _menhir_run_0070 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _tok _menhir_initp - | _ -> _menhir_fail () - - and _menhir_run_0068 : - type ttv_stack ttv_result. - ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_COMMA, - ttv_result ) - _menhir_cell1_non_empty_list_commas_type__ - _menhir_cell0_RPAREN -> - _ -> - _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell0_RPAREN (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_type__ (_menhir_stack, _, ts)) = - _menhir_stack - in - let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_type_ (_menhir_stack, _, t, _, _)) = _menhir_stack in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_rty_, rty = (_endpos, _v) in - let _v = _menhir_action_947 _endpos_rty_ _startpos__1_ rty t ts in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rty_ - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_0062 : - type ttv_stack ttv_result. - ( ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_type_, - ttv_result ) - _menhir_cell1_RPAREN -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PIPE -> ( + let _menhir_stack = + MenhirCell1_pipe_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_PIPE (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0276 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_059 _1 in + _menhir_goto_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0305 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_loop_label_colon + _menhir_cell0_WHILE + as + 'stack) -> + _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let _endpos_t2_, t2 = (_endpos, _v) in - let _v = _menhir_action_478 t2 in - _menhir_goto_option___anonymous_19_ _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos_t2_ _v _tok _menhir_initp - - and _menhir_run_0058 : - type ttv_stack ttv_result. - ( (ttv_stack, ttv_result) _menhir_cell1_LPAREN, - ttv_result ) - _menhir_cell1_RPAREN -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0110 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0305 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0305 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0305 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0305 _menhir_initp + | Lex_menhir_token.CARET -> + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.BARBAR -> + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.BAR -> + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0305 _menhir_initp + | _ -> _eRR () + + and _menhir_run_0301 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_AMPERAMPER + as + 'stack) -> + _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_RPAREN (_menhir_stack, _, _)) = _menhir_stack in - let (MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_rty_, rty = (_endpos, _v) in - let _v = _menhir_action_948 _endpos_rty_ _startpos__1_ rty in - _menhir_goto_type_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rty_ - _startpos__1_ _v _menhir_s _tok _menhir_initp + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0301 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0301 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0301 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0301 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0301 _menhir_initp + | Lex_menhir_token.BARBAR | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_AMPERAMPER + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_119 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_0043 : - type ttv_stack ttv_result. - ttv_stack -> + and _menhir_run_0299 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_BAR + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - (ttv_stack, ttv_result) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> ttv_result = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.QUESTION -> - let _menhir_stack = - MenhirCell1_type_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - _menhir_run_0044 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_initp - | Lex_menhir_token.EXCLAMATION -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, MenhirState0043, _startpos_0, _endpos_1) - in - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0045 _menhir_initp - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, MenhirState0043, _startpos_0, _endpos_1) - in - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState0045 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_3 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, MenhirState0043, _startpos_0, _endpos_1) - in - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 - MenhirState0045 _menhir_initp - | Lex_menhir_token.LPAREN -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, MenhirState0043, _startpos_0, _endpos_1) - in - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState0045 _menhir_initp - | Lex_menhir_token.LIDENT _v_4 -> - let _menhir_stack = - MenhirCell1_type_ - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell1_EXCLAMATION - (_menhir_stack, MenhirState0043, _startpos_0, _endpos_1) - in - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState0045 _menhir_initp - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE - | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL - | Lex_menhir_token.EXCLAMATION | Lex_menhir_token.LBRACE - | Lex_menhir_token.QUESTION | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> - let _endpos__2_, _startpos__2_, t1 = (_endpos_1, _startpos_0, _v) in - let _v = _menhir_action_559 _endpos__2_ _startpos__2_ t1 in - _menhir_goto_return_type _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos__2_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF - | Lex_menhir_token.EQUAL | Lex_menhir_token.LBRACE | Lex_menhir_token.RBRACE - | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN - | Lex_menhir_token.SEMI _ | Lex_menhir_token.WITH -> - let _endpos_t_, t = (_endpos, _v) in - let _v = _menhir_action_558 t in - _menhir_goto_return_type _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_t_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1735 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident -> - _ -> - _ -> - _ -> + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0299 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0299 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0299 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0299 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0299 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0299 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0299 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0299 _menhir_initp + | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_BAR + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_118 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0297 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_BARBAR + as + 'stack) -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_037 _endpos__1_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ params tycon - in - _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1732 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_STRUCT, - _menhir_box_structure ) - _menhir_cell1_luident -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_702 _endpos__1_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ params tycon - in - _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0297 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0297 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0297 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0297 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0297 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_BARBAR + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_120 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_goto_struct_header : - type ttv_stack. - ttv_stack -> + and _menhir_run_0295 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_AMPER + as + 'stack) -> _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_struct_header (_menhir_stack, _menhir_s, _v, _startpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> ( - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState2041, _endpos_1) - in - let _tok = _menhir_lexer _menhir_lexbuf in + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2042 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_2 = _menhir_action_032 () in - _menhir_run_2043 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _v_2 _tok _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.PUB -> - _menhir_run_1348 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2041 _menhir_initp - | Lex_menhir_token.PRIV -> - _menhir_run_1360 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2041 _menhir_initp - | Lex_menhir_token.MUTABLE -> - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2041 _menhir_initp - | Lex_menhir_token.LIDENT _ -> - let _v_3 = _menhir_action_465 () in - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _endpos _v_3 MenhirState2041 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0295 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0295 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0295 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0295 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0295 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0295 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_AMPER + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_116 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1722 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_luident -> + and _menhir_run_0293 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_CARET + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_956 _endpos__1_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ params tycon - in - _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos__1_ _v _menhir_s _tok _menhir_initp + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0293 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0293 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0293 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0293 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0293 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0293 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0293 _menhir_initp + | Lex_menhir_token.AMPERAMPER | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_CARET + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_117 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_goto_type_header : - type ttv_stack. - ttv_stack -> + and _menhir_run_0291 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_INFIX1 + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_header (_menhir_stack, _menhir_s, _v, _startpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2030 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState2030 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2030 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2030 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2030 _menhir_initp - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2030 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_3 = _menhir_action_032 () in - _menhir_run_2033 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_3 - _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1717 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_TYPEALIAS, - _menhir_box_structure ) - _menhir_cell1_luident -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0291 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0291 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0291 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0291 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0291 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.LBRACE | Lex_menhir_token.PIPE + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_INFIX1 + (_menhir_stack, _, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_113 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0289 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_INFIX2 + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_953 _endpos__1_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ params tycon - in - _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_goto_type_alias_header : - type ttv_stack. - ttv_stack -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0289 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0289 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0289 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0289 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_INFIX2 + (_menhir_stack, _, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_112 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0287 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_MINUS + as + 'stack) -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok - _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_alias_header (_menhir_stack, _menhir_s, _v, _startpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.EQUAL -> ( - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in - let _menhir_s = MenhirState2035 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1713 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_ENUM, - _menhir_box_structure ) - _menhir_cell1_luident -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0287 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0287 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_MINUS + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_115 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0285 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_INFIX3 + as + 'stack) -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_ENUM (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_038 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon - in - _menhir_goto_enum_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1710 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_STRUCT, - _menhir_box_structure ) - _menhir_cell1_luident -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_STRUCT (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_703 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon - in - _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0285 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.INFIX3 _ + | Lex_menhir_token.LBRACE | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_INFIX3 + (_menhir_stack, _, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_111 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1700 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_luident -> + and _menhir_run_0281 : type ttv_stack ttv_result. + ( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_INFIX4 -> _ -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_957 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon - in - _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos__1_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell1_INFIX4 + (_menhir_stack, _, _1, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_110 _1 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1695 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPEALIAS, - _menhir_box_structure ) - _menhir_cell1_luident -> + and _menhir_run_0279 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_infix_expr, + ttv_result ) + _menhir_cell1_PLUS + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell0_TYPEALIAS (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let params = _v in - let _v = - _menhir_action_954 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr params tycon - in - _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__1_ _v _menhir_s _tok _menhir_initp + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0279 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0279 _menhir_initp + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.BAR | Lex_menhir_token.BARBAR + | Lex_menhir_token.CARET | Lex_menhir_token.CATCH + | Lex_menhir_token.COLON | Lex_menhir_token.COMMA + | Lex_menhir_token.ELSE | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.INFIX1 _ + | Lex_menhir_token.INFIX2 _ | Lex_menhir_token.LBRACE + | Lex_menhir_token.MINUS | Lex_menhir_token.PIPE + | Lex_menhir_token.PLUS | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell1_PLUS + (_menhir_stack, _, _startpos__1_, _endpos__1_)) = + _menhir_stack + in + let (MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_114 _endpos__1_ _endpos_rhs_ _startpos__1_ + _startpos_lhs_ lhs rhs + in + _menhir_goto_infix_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1419 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT, - _menhir_box_structure ) - _menhir_cell1_luident -> + and _menhir_run_0277 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_pipe_expr _menhir_cell0_PIPE + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let params = _v in - let _v = _menhir_action_701 _endpos_tycon_ _startpos_tycon_ params tycon in - _menhir_goto_struct_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.PLUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0278 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0286 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.INFIX4 _v_0 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0280 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 + MenhirState0277 _menhir_initp + | Lex_menhir_token.INFIX3 _v_1 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 + MenhirState0277 _menhir_initp + | Lex_menhir_token.INFIX2 _v_2 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0288 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 + MenhirState0277 _menhir_initp + | Lex_menhir_token.INFIX1 _v_3 -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0290 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 + MenhirState0277 _menhir_initp + | Lex_menhir_token.CARET -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0292 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.BARBAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0296 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.BAR -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0298 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.AMPERAMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0300 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_infix_expr + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0294 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0277 _menhir_initp + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EOF + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.LBRACE + | Lex_menhir_token.PIPE | Lex_menhir_token.RBRACE + | Lex_menhir_token.RBRACKET | Lex_menhir_token.RPAREN + | Lex_menhir_token.SEMI _ -> + let (MenhirCell0_PIPE (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_pipe_expr + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = + _menhir_action_360 _endpos_rhs_ _startpos_lhs_ lhs rhs + in + _menhir_goto_pipe_expr _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1272 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, - _menhir_box_structure ) - _menhir_cell1_luident -> + and _menhir_run_0163 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let params = _v in - let _v = _menhir_action_955 _endpos_tycon_ _startpos_tycon_ params tycon in - _menhir_goto_type_header _menhir_stack _menhir_lexbuf _menhir_lexer _endpos - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1266 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPEALIAS, - _menhir_box_structure ) - _menhir_cell1_luident -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.BAR -> ( + let _menhir_stack = + MenhirCell1_range_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_BAR (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0164 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.EQUAL + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_346 _1 in + _menhir_goto_or_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_or_pattern : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok _menhir_initp -> - let (MenhirCell1_luident - (_menhir_stack, _, tycon, _startpos_tycon_, _endpos_tycon_)) = - _menhir_stack - in - let (MenhirCell1_TYPEALIAS (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let params = _v in - let _v = _menhir_action_952 _endpos_tycon_ _startpos_tycon_ params tycon in - _menhir_goto_type_alias_header _menhir_stack _menhir_lexbuf _menhir_lexer - _startpos__2_ _v _menhir_s _tok _menhir_initp - - and _menhir_run_1734 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_ENUM - as - 'stack) -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0662 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0169 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0164 -> + _menhir_run_0165 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _v _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0169 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1734 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1734 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1731 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_STRUCT - as - 'stack) -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_359 _1 in + _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos__1_ _startpos__1_ _v _menhir_s _tok _menhir_initp + + and _menhir_goto_pattern : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1731 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1731 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1724 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TRAIT - as - 'stack) -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match _menhir_s with + | MenhirState0662 -> + _menhir_run_0510 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0666 -> + _menhir_run_0510 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0641 -> + _menhir_run_0510 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0519 -> + _menhir_run_0510 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0506 -> + _menhir_run_0510 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0501 -> + _menhir_run_0502 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0484 -> + _menhir_run_0493 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0248 -> + _menhir_run_0249 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0554 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0545 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0542 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0320 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0271 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0267 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0245 -> + _menhir_run_0246 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0136 -> + _menhir_run_0243 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0241 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0138 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0236 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0232 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0227 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0223 -> + _menhir_run_0225 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0214 -> + _menhir_run_0215 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0201 -> + _menhir_run_0202 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0145 -> + _menhir_run_0183 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0177 -> + _menhir_run_0173 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0159 -> + _menhir_run_0173 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | MenhirState0162 -> + _menhir_run_0166 _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos _startpos _v _menhir_s _tok _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0510 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> - _menhir_run_1275 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1724 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_479 () in - _menhir_run_1725 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1724 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1275 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_luident as 'stack) -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _menhir_initp -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell1_COLON (_menhir_stack, _menhir_s, _endpos) in - let _menhir_s = MenhirState1275 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.IF -> ( + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_IF (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0511 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.FAT_ARROW -> + let _v = _menhir_action_316 () in + _menhir_goto_option___anonymous_8_ _menhir_stack _menhir_lexbuf + _menhir_lexer _v _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1721 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE + and _menhir_run_0167 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_pattern -> _ -> _ -> _ -> ttv_result + = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_initp -> + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.LIDENT _v -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_pattern + (_menhir_stack, _menhir_s, p, _startpos_p_, _)) = + _menhir_stack + in + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = + _menhir_action_358 _endpos_name_ _startpos_name_ _startpos_p_ name + p + in + _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_name_ _startpos_p_ _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0502 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_GUARD, + ttv_result ) + _menhir_cell1_LET as 'stack) -> _ -> @@ -212018,234 +73502,668 @@ include struct _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1721 _menhir_initp - | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF | Lex_menhir_token.LIDENT _ - | Lex_menhir_token.LPAREN | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.SEMI _ | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE -> - let _menhir_s = MenhirState1721 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0503 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_run_1720 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION -> + and _menhir_run_0493 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LET as 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok - _menhir_initp -> - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_PRIV - (_menhir_stack, _menhir_s, _startpos__1_, _endpos__1_)) = - _menhir_stack - in - let _endpos_tycon_, _startpos_tycon_, tycon = (_endpos, _startpos, _v) in - let _v = - _menhir_action_959 _endpos__1_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ tycon - in - _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_EQUAL (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0494 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP + | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos _menhir_s _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0496 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () - and _menhir_goto_type_header_bang : - type ttv_stack. - ttv_stack -> + and _menhir_run_0249 : type ttv_stack ttv_result. + (( (ttv_stack, ttv_result) _menhir_cell1_non_empty_list_commas_rev_pattern_, + ttv_result ) + _menhir_cell1_COMMA + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> - (ttv_stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_type_header_bang (_menhir_stack, _menhir_s, _v, _startpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0034 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2006 _menhir_initp - | Lex_menhir_token.UIDENT _v_0 -> - _menhir_run_0035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState2006 _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v_1 -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 - MenhirState2006 _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2006 _menhir_initp - | Lex_menhir_token.LIDENT _v_2 -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState2006 _menhir_initp - | Lex_menhir_token.LBRACE -> ( - let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_LBRACE - (_menhir_stack, MenhirState2006, _startpos_3, _endpos) - in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_4 -> - _menhir_run_1379 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 - MenhirState2007 _menhir_initp - | Lex_menhir_token.RBRACE -> ( - let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = - MenhirCell1_RBRACE (_menhir_stack, MenhirState2007, _endpos_5) - in - let _tok = _menhir_lexer _menhir_lexbuf in + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> match (_tok : MenhirBasics.token) with - | Lex_menhir_token.DERIVE -> - _menhir_run_2009 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState2008 _menhir_initp - | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ -> - let _v_6 = _menhir_action_032 () in - _menhir_run_2023 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_5 _v_6 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR ()) - | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF | Lex_menhir_token.SEMI _ - -> - let _menhir_s = MenhirState2006 in - let _v = _menhir_action_500 () in - _menhir_goto_option_type__ _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _v _menhir_s _tok _menhir_initp - | _ -> _eRR () + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.IF | Lex_menhir_token.RPAREN -> + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_pattern_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let x = _v in + let _v = _menhir_action_238 x xs in + _menhir_goto_non_empty_list_commas_rev_pattern_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1716 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_PRIV - _menhir_cell0_TYPEALIAS - as - 'stack) -> + and _menhir_goto_non_empty_list_commas_rev_pattern_ : + type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_pattern_ + (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0248 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0248 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0248 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.LIDENT _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0248 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.INT _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0248 _menhir_initp + | Lex_menhir_token.FLOAT _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0248 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.CHAR _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0248 _menhir_initp + | Lex_menhir_token.BYTES _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0248 _menhir_initp + | Lex_menhir_token.BYTE _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0248 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0247, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0248 _menhir_initp + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0250 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () + + and _menhir_run_0246 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1716 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _menhir_s = MenhirState1716 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1712 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_ENUM - as - 'stack) -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.FAT_ARROW + | Lex_menhir_token.IF | Lex_menhir_token.RPAREN -> + let x = _v in + let _v = _menhir_action_237 x in + _menhir_goto_non_empty_list_commas_rev_pattern_ _menhir_stack + _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () + + and _menhir_run_0243 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1712 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1712 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - and _menhir_run_1709 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_STRUCT - as - 'stack) -> + _ -> + _ -> + _ -> + ('stack, ttv_result) _menhir_state -> + _ -> + _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RPAREN -> + let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let (MenhirCell1_LPAREN + (_menhir_stack, _menhir_s, _startpos__1_, _)) = + _menhir_stack + in + let _2, _endpos__3_ = (_v, _endpos_0) in + let _v = _menhir_action_455 _2 in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | Lex_menhir_token.COMMA -> ( + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COMMA (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0245 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLON -> ( + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_COLON (_menhir_stack, _endpos) + in + let _menhir_s = MenhirState0253 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0037 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0038 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0039 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0045 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0046 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0050 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0225 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1709 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1709 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> + let _1 = _v in + let _v = _menhir_action_006 _1 in + _menhir_goto_array_sub_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1702 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TRAIT + and _menhir_run_0215 : type ttv_stack ttv_result. + (( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_map_syntax_key, + ttv_result ) + _menhir_cell1_option_QUESTION_ + _menhir_cell0_COLON as 'stack) -> _ -> @@ -212253,102 +74171,273 @@ include struct _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> - _menhir_run_1275 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1702 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_479 () in - _menhir_run_1703 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1702 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1699 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPE - as - 'stack) -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_option_QUESTION_ (_menhir_stack, _, question)) + = + _menhir_stack + in + let (MenhirCell1_map_syntax_key + ( _menhir_stack, + _menhir_s, + key, + _startpos_key_, + _endpos_key_ )) = + _menhir_stack + in + let _endpos_pat_, pat = (_endpos, _v) in + let _v = + _menhir_action_231 _endpos_key_ _endpos_pat_ _startpos_key_ + key pat question + in + _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ : + type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LBRACE as 'stack) -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1699 _menhir_initp - | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF | Lex_menhir_token.LIDENT _ - | Lex_menhir_token.LPAREN | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.SEMI _ | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE -> - let _menhir_s = MenhirState1699 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0197 _menhir_initp + | Lex_menhir_token.STRING _v_0 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0197 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0141 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0197 _menhir_initp + | Lex_menhir_token.INT _v_1 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0197 _menhir_initp + | Lex_menhir_token.FLOAT _v_2 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0197 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0197 _menhir_initp + | Lex_menhir_token.CHAR _v_3 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0197 _menhir_initp + | Lex_menhir_token.BYTES _v_4 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0197 _menhir_initp + | Lex_menhir_token.BYTE _v_5 -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0196, _endpos) + in + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0197 _menhir_initp + | Lex_menhir_token.DOTDOT -> ( + let xs = _v in + let _v = _menhir_action_248 xs in + let _menhir_stack = + MenhirCell1_non_empty_list_commas_with_tail_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_DOTDOT (_menhir_stack, _startpos, _endpos) + in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> + _menhir_run_0171 _menhir_stack _menhir_lexbuf + _menhir_lexer MenhirState0191 _menhir_initp + | Lex_menhir_token.RBRACE -> + let _ = _menhir_action_286 () in + _menhir_run_0192 _menhir_stack _menhir_lexbuf + _menhir_lexer _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0203 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RBRACE -> + let _menhir_stack = + MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, _v) + in + let _ = _menhir_action_286 () in + _menhir_run_0203 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _menhir_fail () - and _menhir_run_1698 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPE, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION -> + and _menhir_run_0202 : type ttv_stack ttv_result. + (( ( ( ( (ttv_stack, ttv_result) _menhir_cell1_LBRACE, + ttv_result ) + _menhir_cell1_non_empty_list_commas_rev_map_elem_pat_, + ttv_result ) + _menhir_cell1_COMMA, + ttv_result ) + _menhir_cell1_map_syntax_key, + ttv_result ) + _menhir_cell1_option_QUESTION_ + _menhir_cell0_COLON + as + 'stack) -> _ -> _ -> _ -> _ -> _ -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok - _menhir_initp -> - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell0_TYPE (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_pub_attr (_menhir_stack, _, attr, _endpos_attr_)) = - _menhir_stack - in - let (MenhirCell1_PUB (_menhir_stack, _menhir_s, _startpos__1_, _)) = - _menhir_stack - in - let _endpos_tycon_, _startpos_tycon_, tycon = (_endpos, _startpos, _v) in - let _v = - _menhir_action_960 _endpos_attr_ _endpos_tycon_ _startpos__1_ - _startpos_tycon_ attr tycon - in - _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _startpos__1_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_option_QUESTION_ (_menhir_stack, _, question)) + = + _menhir_stack + in + let (MenhirCell1_map_syntax_key + (_menhir_stack, _, key, _startpos_key_, _endpos_key_)) = + _menhir_stack + in + let (MenhirCell1_COMMA (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_non_empty_list_commas_rev_map_elem_pat_ + (_menhir_stack, _menhir_s, xs)) = + _menhir_stack + in + let _endpos_pat_, pat = (_endpos, _v) in + let _v = + _menhir_action_232 _endpos_key_ _endpos_pat_ _startpos_key_ + key pat question xs + in + _menhir_goto_non_empty_list_commas_rev_map_elem_pat_ + _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1694 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_PUB, - _menhir_box_structure ) - _menhir_cell1_pub_attr - _menhir_cell0_TYPEALIAS + and _menhir_run_0183 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_COLON as 'stack) -> _ -> @@ -212356,224 +74445,382 @@ include struct _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1694 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _menhir_s = MenhirState1694 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACE -> + let (MenhirCell0_COLON (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + ( _menhir_stack, + _menhir_s, + name, + _startpos_name_, + _endpos_name_ )) = + _menhir_stack + in + let _endpos_p_, p = (_endpos, _v) in + let _v = + _menhir_action_077 _endpos_name_ _endpos_p_ _startpos_name_ + name p + in + _menhir_goto_fields_pat_single _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1418 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT as 'stack) -> + and _menhir_run_0173 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1418 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _menhir_s = MenhirState1418 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let pat = _v in + let _v = _menhir_action_035 pat in + _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1377 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_ENUM as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> + and _menhir_goto_constr_pat_argument : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v_2 -> - let _menhir_stack = - MenhirCell1_luident - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1379 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 - MenhirState1378 _menhir_initp - | Lex_menhir_token.RBRACE -> - let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_ENUM (_menhir_stack, _menhir_s, _)) = - _menhir_stack - in - let _endpos_tycon_, _startpos_tycon_, tycon, _endpos__5_ = - (_endpos, _startpos, _v, _endpos_3) - in - let _v = _menhir_action_114 _endpos_tycon_ _startpos_tycon_ tycon in - _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__5_ _v _menhir_s _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1345 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_STRUCT as 'stack) -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + let _menhir_stack = + MenhirCell1_constr_pat_argument (_menhir_stack, _menhir_s, _v) + in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.COMMA -> ( + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.UIDENT _v_0 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_0 MenhirState0177 _menhir_initp + | Lex_menhir_token.TRUE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.STRING _v_1 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_1 MenhirState0177 _menhir_initp + | Lex_menhir_token.POST_LABEL _v_2 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0160 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_2 MenhirState0177 _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v_3 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_3 MenhirState0177 _menhir_initp + | Lex_menhir_token.MINUS -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.LPAREN -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.LIDENT _v_4 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0161 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_4 MenhirState0177 _menhir_initp + | Lex_menhir_token.LBRACKET -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.LBRACE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.INT _v_5 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_5 MenhirState0177 _menhir_initp + | Lex_menhir_token.FLOAT _v_6 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_6 MenhirState0177 _menhir_initp + | Lex_menhir_token.FALSE -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.DOTDOT -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0170 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.CHAR _v_7 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_7 MenhirState0177 _menhir_initp + | Lex_menhir_token.BYTES _v_8 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_8 MenhirState0177 _menhir_initp + | Lex_menhir_token.BYTE _v_9 -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v_9 MenhirState0177 _menhir_initp + | Lex_menhir_token.AMPER -> + let _menhir_stack = + MenhirCell1_COMMA (_menhir_stack, MenhirState0176, _endpos) + in + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0177 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = + let x = () in + _menhir_action_287 x + in + _menhir_run_0179 _menhir_stack _menhir_lexbuf _menhir_lexer + _tok _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0179 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0160 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACE -> ( - let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in - let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.RBRACE -> - let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - let (MenhirCell1_STRUCT (_menhir_stack, _menhir_s, _)) = - _menhir_stack - in - let _endpos_tycon_, _startpos_tycon_, tycon, _endpos__5_ = - (_endpos, _startpos, _v, _endpos_2) - in - let _v = _menhir_action_112 _endpos_tycon_ _startpos_tycon_ tycon in - _menhir_goto_local_type_decl _menhir_stack _menhir_lexbuf - _menhir_lexer _endpos__5_ _v _menhir_s _tok _menhir_initp - | Lex_menhir_token.PUB -> - let _menhir_stack = - MenhirCell1_luident - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1348 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1346 _menhir_initp - | Lex_menhir_token.PRIV -> - let _menhir_stack = - MenhirCell1_luident - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1360 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1346 _menhir_initp - | Lex_menhir_token.MUTABLE -> - let _menhir_stack = - MenhirCell1_luident - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - _menhir_run_1355 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1346 _menhir_initp - | Lex_menhir_token.LIDENT _ -> - let _menhir_stack = - MenhirCell1_luident - (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _menhir_stack = - MenhirCell0_LBRACE (_menhir_stack, _startpos_0, _endpos_1) - in - let _v_3 = _menhir_action_465 () in - _menhir_run_1366 _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos_1 _endpos_1 _v_3 MenhirState1346 _tok _menhir_initp - | _ -> _eRR ()) - | _ -> _eRR () - - and _menhir_run_1296 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET as 'stack) -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + let _endpos_id_, _startpos_id_, id = (_endpos, _startpos, _v) in + let _v = _menhir_action_034 _endpos_id_ _startpos_id_ id in + _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + + and _menhir_run_0161 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _v -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.EQUAL -> ( + let _menhir_stack = + MenhirCell1_LIDENT + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in + let _menhir_s = MenhirState0162 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.COLONCOLON -> + let _endpos_i_, _startpos_i_, i = (_endpos, _startpos, _v) in + let _v = _menhir_action_173 i in + _menhir_goto_luident _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_i_ _startpos_i_ _v _menhir_s _tok _menhir_initp + | Lex_menhir_token.AS | Lex_menhir_token.BAR | Lex_menhir_token.COMMA + | Lex_menhir_token.RANGE_EXCLUSIVE | Lex_menhir_token.RANGE_INCLUSIVE + | Lex_menhir_token.RPAREN -> + let _endpos_name_, _startpos_name_, name = + (_endpos, _startpos, _v) + in + let _v = _menhir_action_453 _endpos_name_ _startpos_name_ name in + _menhir_goto_simple_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos_name_ _startpos_name_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + and _menhir_run_0170 : type ttv_stack ttv_result. + ttv_stack -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> _ -> + (ttv_stack, ttv_result) _menhir_state -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _menhir_s -> + fun _menhir_initp -> + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + MenhirCell1_DOTDOT (_menhir_stack, _menhir_s, _startpos, _endpos) in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1297 in let _tok = _menhir_lexer _menhir_lexbuf in match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_178 _endpos_name_ _startpos_name_ name in - _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () + | Lex_menhir_token.COMMA -> + _menhir_run_0171 _menhir_stack _menhir_lexbuf _menhir_lexer + MenhirState0170 _menhir_initp + | Lex_menhir_token.RPAREN -> + let _ = _menhir_action_286 () in + _menhir_run_0172 _menhir_stack _menhir_lexbuf _menhir_lexer _tok + _menhir_initp + | _ -> _eRR () - and _menhir_run_1291 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_LBRACKET, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_tvar_binder__ - _menhir_cell0_COMMA + and _menhir_run_0166 : type ttv_stack ttv_result. + ((ttv_stack, ttv_result) _menhir_cell1_LIDENT _menhir_cell0_EQUAL as 'stack) -> _ -> @@ -212581,353 +74828,435 @@ include struct _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> ( - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _endpos) in - let _menhir_s = MenhirState1292 in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.UIDENT _v -> - _menhir_run_1276 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0036 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0042 _menhir_stack _menhir_lexbuf _menhir_lexer _v - _menhir_s _menhir_initp - | _ -> _eRR ()) - | Lex_menhir_token.COMMA | Lex_menhir_token.RBRACKET -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_id_tvar_binder__ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_180 _endpos_name_ _startpos_name_ name xs in - _menhir_goto_non_empty_list_commas_rev_id_tvar_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1274 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_TRAIT as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.COLON -> - _menhir_run_1275 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1274 _menhir_initp - | Lex_menhir_token.LBRACE -> - let _v_0 = _menhir_action_479 () in - _menhir_run_1284 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 - MenhirState1274 _tok _menhir_initp - | _ -> _eRR () - - and _menhir_run_1271 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE as 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> + ('stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1271 _menhir_initp - | Lex_menhir_token.DERIVE | Lex_menhir_token.EOF | Lex_menhir_token.LIDENT _ - | Lex_menhir_token.LPAREN | Lex_menhir_token.PACKAGE_NAME _ - | Lex_menhir_token.SEMI _ | Lex_menhir_token.UIDENT _ - | Lex_menhir_token.UNDERSCORE -> - let _menhir_s = MenhirState1271 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.AS -> + let _menhir_stack = + MenhirCell1_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + _menhir_run_0167 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_initp + | Lex_menhir_token.COMMA | Lex_menhir_token.RPAREN -> + let (MenhirCell0_EQUAL (_menhir_stack, _)) = _menhir_stack in + let (MenhirCell1_LIDENT + ( _menhir_stack, + _menhir_s, + name, + _startpos_name_, + _endpos_name_ )) = + _menhir_stack + in + let pat = _v in + let _v = + _menhir_action_033 _endpos_name_ _startpos_name_ name pat + in + _menhir_goto_constr_pat_argument _menhir_stack _menhir_lexbuf + _menhir_lexer _v _menhir_s _tok _menhir_initp + | _ -> _eRR () - and _menhir_run_1270 : - type ttv_stack. - ( (ttv_stack, _menhir_box_structure) _menhir_cell1_TYPE, - _menhir_box_structure ) - _menhir_cell1_EXCLAMATION -> - _ -> + and _menhir_run_0165 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_range_pattern _menhir_cell0_BAR -> _ -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok - _menhir_initp -> - let (MenhirCell1_EXCLAMATION (_menhir_stack, _, _, _)) = _menhir_stack in - let (MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__2_)) = - _menhir_stack - in - let _endpos_tycon_, _startpos_tycon_, tycon = (_endpos, _startpos, _v) in - let _v = _menhir_action_958 _endpos_tycon_ _startpos_tycon_ tycon in - _menhir_goto_type_header_bang _menhir_stack _menhir_lexbuf _menhir_lexer - _endpos _startpos__2_ _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_BAR (_menhir_stack, _, _)) = _menhir_stack in + let (MenhirCell1_range_pattern + (_menhir_stack, _menhir_s, pat1, _startpos_pat1_, _)) = + _menhir_stack + in + let _endpos_pat2_, pat2 = (_endpos, _v) in + let _v = _menhir_action_345 _endpos_pat2_ _startpos_pat1_ pat1 pat2 in + _menhir_goto_or_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_pat2_ _startpos_pat1_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1265 : - type ttv_stack. - (( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET - as - 'stack) -> - _ -> - _ -> - _ -> - _ -> - _ -> - ('stack, _menhir_box_structure) _menhir_state -> - _ -> - _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_182 _endpos_name_ _startpos_name_ name in - _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp - - and _menhir_run_1262 : - type ttv_stack. - ( ( (ttv_stack, _menhir_box_structure) _menhir_cell1_luident, - _menhir_box_structure ) - _menhir_cell1_LBRACKET, - _menhir_box_structure ) - _menhir_cell1_non_empty_list_commas_rev_id_type_decl_binder__ - _menhir_cell0_COMMA -> - _ -> + and _menhir_run_0156 : type ttv_stack ttv_result. + (ttv_stack, ttv_result) _menhir_cell1_simple_pattern + _menhir_cell0_RANGE_INCLUSIVE -> _ -> _ -> _ -> _ -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok - _menhir_initp -> - let (MenhirCell0_COMMA (_menhir_stack, _)) = _menhir_stack in - let (MenhirCell1_non_empty_list_commas_rev_id_type_decl_binder__ - (_menhir_stack, _menhir_s, xs)) = - _menhir_stack - in - let _endpos_name_, _startpos_name_, name = (_endpos, _startpos, _v) in - let _v = _menhir_action_184 _endpos_name_ _startpos_name_ name xs in - _menhir_goto_non_empty_list_commas_rev_id_type_decl_binder__ _menhir_stack - _menhir_lexbuf _menhir_lexer _v _menhir_s _tok _menhir_initp + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _v -> + fun _tok -> + fun _menhir_initp -> + let (MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _, _)) = + _menhir_stack + in + let (MenhirCell1_simple_pattern + (_menhir_stack, _menhir_s, lhs, _startpos_lhs_, _)) = + _menhir_stack + in + let _endpos_rhs_, rhs = (_endpos, _v) in + let _v = _menhir_action_382 _endpos_rhs_ _startpos_lhs_ lhs rhs in + _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf _menhir_lexer + _endpos_rhs_ _startpos_lhs_ _v _menhir_s _tok _menhir_initp - and _menhir_run_1256 : - type ttv_stack. - ((ttv_stack, _menhir_box_structure) _menhir_cell1_TYPEALIAS as 'stack) -> + and _menhir_run_0154 : type ttv_stack ttv_result. + ttv_stack -> _ -> _ -> _ -> _ -> _ -> - ('stack, _menhir_box_structure) _menhir_state -> + (ttv_stack, ttv_result) _menhir_state -> _ -> _ -> - _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s - _tok _menhir_initp -> - let _menhir_stack = - MenhirCell1_luident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) - in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.LBRACKET -> - _menhir_run_1257 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1256 _menhir_initp - | Lex_menhir_token.EQUAL -> - let _menhir_s = MenhirState1256 in - let _v = _menhir_action_487 () in - _menhir_goto_option_delimited_LBRACKET_non_empty_list_commas_id_type_decl_binder___RBRACKET__ - _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok - _menhir_initp - | _ -> _eRR () - - let rec _menhir_run_0000 : - type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_expression = - fun _menhir_stack _menhir_lexbuf _menhir_lexer -> - let _menhir_s = MenhirState0000 in - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _menhir_initp = _endpos in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.WHILE -> - _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UNDERSCORE -> - _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.UIDENT _v -> - _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.TRY -> - _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.TRUE -> - _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.STRING _v -> - _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.PLUS -> - _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.PACKAGE_NAME _v -> - _menhir_run_0007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_STRING _v -> - _menhir_run_0010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MULTILINE_INTERP _v -> - _menhir_run_0011 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.MINUS -> - _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.MATCH -> - _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LPAREN -> - _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LOOP -> - _menhir_run_0021 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LIDENT _v -> - _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACKET -> - _menhir_run_0022 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.LBRACE -> - _menhir_run_0024 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.INTERP _v -> - _menhir_run_0027 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.INT _v -> - _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.IF -> - _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FOR -> - _menhir_run_0073 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FN -> - _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.FLOAT _v -> - _menhir_run_0077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.FALSE -> - _menhir_run_0078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s - _menhir_initp - | Lex_menhir_token.CHAR _v -> - _menhir_run_0079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTES _v -> - _menhir_run_0080 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | Lex_menhir_token.BYTE _v -> - _menhir_run_0081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s - _menhir_initp - | _ -> _eRR () - - let rec _menhir_run_1254 : - type ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_structure = - fun _menhir_stack _menhir_lexbuf _menhir_lexer -> - let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in - let _tok = _menhir_lexer _menhir_lexbuf in - match (_tok : MenhirBasics.token) with - | Lex_menhir_token.TYPEALIAS -> - _menhir_run_1255 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.TYPE -> - _menhir_run_1268 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.TRAIT -> - _menhir_run_1273 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.TEST -> - _menhir_run_1335 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.STRUCT -> - _menhir_run_1417 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.PUB -> - _menhir_run_1420 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.PRIV -> - _menhir_run_1714 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.LET -> - _menhir_run_1736 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.IMPL -> - _menhir_run_1740 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.FN -> - _menhir_run_1975 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.EXTERN -> - _menhir_run_1984 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.EOF -> - let _v = _menhir_action_704 () in - _menhir_goto_structure _menhir_stack _v - | Lex_menhir_token.ENUM -> - _menhir_run_1996 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | Lex_menhir_token.CONST -> - _menhir_run_1999 _menhir_stack _menhir_lexbuf _menhir_lexer - MenhirState1254 _endpos - | _ -> _eRR () + ttv_result = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + fun _endpos -> + fun _startpos -> + fun _v -> + fun _menhir_s -> + fun _tok -> + fun _menhir_initp -> + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.RANGE_INCLUSIVE -> ( + let _menhir_stack = + MenhirCell1_simple_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_RANGE_INCLUSIVE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0155 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.RANGE_EXCLUSIVE -> ( + let _menhir_stack = + MenhirCell1_simple_pattern + (_menhir_stack, _menhir_s, _v, _startpos, _endpos) + in + let _startpos = _menhir_lexbuf.Lexing.lex_start_p in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_stack = + MenhirCell0_RANGE_EXCLUSIVE (_menhir_stack, _startpos, _endpos) + in + let _menhir_s = MenhirState0181 in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0129 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0130 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0131 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0132 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0133 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0136 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0137 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0138 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0139 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0146 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0147 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0148 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0149 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0150 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0151 _menhir_stack _menhir_lexbuf _menhir_lexer + _v _menhir_s _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_s _menhir_initp + | _ -> _eRR ()) + | Lex_menhir_token.AMPER | Lex_menhir_token.AMPERAMPER + | Lex_menhir_token.AS | Lex_menhir_token.BAR + | Lex_menhir_token.BARBAR | Lex_menhir_token.CARET + | Lex_menhir_token.CATCH | Lex_menhir_token.COLON + | Lex_menhir_token.COMMA | Lex_menhir_token.ELSE + | Lex_menhir_token.EOF | Lex_menhir_token.EQUAL + | Lex_menhir_token.FAT_ARROW | Lex_menhir_token.IF + | Lex_menhir_token.INFIX1 _ | Lex_menhir_token.INFIX2 _ + | Lex_menhir_token.INFIX3 _ | Lex_menhir_token.INFIX4 _ + | Lex_menhir_token.LBRACE | Lex_menhir_token.MINUS + | Lex_menhir_token.PIPE | Lex_menhir_token.PLUS + | Lex_menhir_token.RBRACE | Lex_menhir_token.RBRACKET + | Lex_menhir_token.RPAREN | Lex_menhir_token.SEMI _ -> + let _endpos__1_, _startpos__1_, _1 = (_endpos, _startpos, _v) in + let _v = _menhir_action_383 _1 in + _menhir_goto_range_pattern _menhir_stack _menhir_lexbuf + _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok + _menhir_initp + | _ -> _eRR () + + let rec _menhir_run_0000 : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_expression = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + let _menhir_s = MenhirState0000 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_initp = _endpos in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.UNDERSCORE -> + _menhir_run_0001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.UIDENT _v -> + _menhir_run_0002 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.TRY -> + _menhir_run_0003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.TRUE -> + _menhir_run_0004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.STRING _v -> + _menhir_run_0005 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.POST_LABEL _v -> + _menhir_run_0006 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.PLUS -> + _menhir_run_0008 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.PACKAGE_NAME _v -> + _menhir_run_0009 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_STRING _v -> + _menhir_run_0012 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MULTILINE_INTERP _v -> + _menhir_run_0013 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.MINUS -> + _menhir_run_0014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.MATCH -> + _menhir_run_0016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LPAREN -> + _menhir_run_0015 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LIDENT _v -> + _menhir_run_0017 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.LBRACKET -> + _menhir_run_0025 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LBRACE -> + _menhir_run_0026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.INTERP _v -> + _menhir_run_0028 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.INT _v -> + _menhir_run_0029 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.IF -> + _menhir_run_0030 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_0031 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.FLOAT _v -> + _menhir_run_0097 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.FALSE -> + _menhir_run_0098 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.CHAR _v -> + _menhir_run_0099 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTES _v -> + _menhir_run_0100 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.BYTE _v -> + _menhir_run_0101 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_0102 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.AMPER -> + _menhir_run_0112 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.FOR | Lex_menhir_token.LOOP | Lex_menhir_token.WHILE -> + _menhir_reduce_172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos + _menhir_s _tok _menhir_initp + | _ -> _eRR () + + let rec _menhir_run_0672 : type ttv_stack. + ttv_stack -> _ -> _ -> _menhir_box_structure = + fun _menhir_stack -> + fun _menhir_lexbuf -> + fun _menhir_lexer -> + let _menhir_s = MenhirState0672 in + let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in + let _menhir_initp = _endpos in + let _tok = _menhir_lexer _menhir_lexbuf in + match (_tok : MenhirBasics.token) with + | Lex_menhir_token.TYPEALIAS -> + _menhir_run_0673 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.TYPE -> + _menhir_run_0687 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.TRAITALIAS -> + _menhir_run_0692 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.TRAIT -> + _menhir_run_0696 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.TEST -> + _menhir_run_0749 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.STRUCT -> + _menhir_run_0845 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.PUB -> + _menhir_run_0848 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.PRIV -> + _menhir_run_0939 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.LET -> + _menhir_run_1014 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.IMPL -> + _menhir_run_1018 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.FN -> + _menhir_run_1035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.EXTERN -> + _menhir_run_1041 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.ENUM -> + _menhir_run_1053 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.CONST -> + _menhir_run_1056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.ATTRIBUTE _v -> + _menhir_run_1060 _menhir_stack _menhir_lexbuf _menhir_lexer _v + _menhir_s _menhir_initp + | Lex_menhir_token.ASYNC -> + _menhir_run_1061 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s + _menhir_initp + | Lex_menhir_token.EOF -> + let _v = _menhir_action_158 () in + _menhir_goto_list_semis_structure_item_ _menhir_stack _v _tok + | _ -> _eRR () end let structure _menhir_lexer _menhir_lexbuf = let _menhir_stack = () in let (MenhirBox_structure v) = - _menhir_run_1254 _menhir_stack _menhir_lexbuf _menhir_lexer + _menhir_run_0672 _menhir_stack _menhir_lexbuf _menhir_lexer in v diff --git a/src/parsing_parser.mly b/src/parsing_parser.mly deleted file mode 100644 index af995a7..0000000 --- a/src/parsing_parser.mly +++ /dev/null @@ -1,1301 +0,0 @@ -%{ -(* Copyright International Digital Economy Academy, all rights reserved *) -[%%use -Parsing_util.( - ( i - , enter_next_block - , aloc - , label_to_expr - , label_to_pat - , make_field_def - , make_field_pat - , make_uminus - , make_uplus - , make_Pexpr_array - , make_Pexpr_constant - , make_Pexpr_ident - , make_interps - , make_Pexpr_interp - , make_Pexpr_record - , make_Pexpr_tuple - , make_Ppat_alias - , make_Ppat_constr - , make_Ppat_constant - , make_Ppat_tuple - , make_Ptype_option - , make_Ptype_tuple ))] -%} - -%token CHAR -%token INT -%token BYTE -%token BYTES -%token FLOAT -%token STRING -%token MULTILINE_STRING -%token MULTILINE_INTERP -%token INTERP -%token LIDENT -%token UIDENT -%token LABEL -%token POST_LABEL -%token COMMENT -%token NEWLINE -%token INFIX1 -%token INFIX2 -%token INFIX3 -%token INFIX4 -%token AUGMENTED_ASSIGNMENT - -%token EOF -%token FALSE -%token TRUE -%token PUB "pub" -%token PRIV "priv" -%token READONLY "readonly" -%token IMPORT "import" -%token EXTERN "extern" -%token BREAK "break" -%token CONTINUE "continue" -%token STRUCT "struct" -%token ENUM "enum" -%token TRAIT "trait" -%token DERIVE "derive" -%token IMPL "impl" -%token WITH "with" -%token RAISE "raise" -%token THROW "throw" -%token TRY "try" -%token CATCH "catch" -// %token EXCEPT "except" -%token TYPEALIAS "typealias" -%token EQUAL "=" - -%token LPAREN "(" -%token RPAREN ")" - -%token COMMA "," -%token MINUS "-" -%token QUESTION "?" -%token EXCLAMATION "!" - -%token DOT_LIDENT -%token DOT_UIDENT -%token DOT_INT -%token COLONCOLON "::" -%token COLON ":" -%token SEMI -%token LBRACKET "[" -%token PLUS "+" -%token RBRACKET "]" - -%token UNDERSCORE "_" -%token BAR "|" - -%token LBRACE "{" -%token RBRACE "}" - -%token AMPERAMPER "&&" -%token AMPER "&" -%token CARET "^" -%token BARBAR "||" -%token PACKAGE_NAME -/* Keywords */ - -%token AS "as" -%token PIPE "|>" -%token ELSE "else" -%token FN "fn" -%token IF "if" -%token LET "let" -%token CONST "const" -%token MATCH "match" -%token MUTABLE "mut" -%token TYPE "type" -%token FAT_ARROW "=>" -%token THIN_ARROW "->" -%token WHILE "while" -%token RETURN "return" -%token DOTDOT ".." -%token RANGE_INCLUSIVE "..=" -%token RANGE_EXCLUSIVE "..<" -%token ELLIPSIS "..." -%token TEST "test" -%token LOOP "loop" -%token GUARD "guard" - -%token FOR "for" -%token IN "in" - -%right BARBAR -%right AMPERAMPER - -%nonassoc RANGE_EXCLUSIVE RANGE_INCLUSIVE - -%left BAR -%left CARET -%left AMPER - -// x.f(...) should be [Pexpr_dot_apply], not [Pexpr_apply(Pexpr_field, ...)] -// these two precedences are used to resolve this. -%nonassoc prec_field -%nonassoc LPAREN -%left INFIX1 // > < == != <= >= -%left INFIX2 // << >> -%left PLUS MINUS -%left INFIX3 // * / % -%left INFIX4 // not used -%nonassoc prec_type -%nonassoc prec_apply_non_ident_fn -%nonassoc "!" -%nonassoc "?" -%start structure -%start expression - - -%type expression -%type structure -%type statement -%% - -non_empty_list_rev(X): - | x = X { [x] } - | xs = non_empty_list_rev(X) x = X { x::xs } - -non_empty_list(X): - | xs = non_empty_list_rev(X) { List.rev xs } - -non_empty_list_commas_rev(X): - | x = X { [x] } - | xs=non_empty_list_commas_rev(X) "," x=X { x::xs} - -non_empty_list_commas_no_trailing(X): - | xs = non_empty_list_commas_rev(X) { List.rev xs } - -non_empty_list_commas( X): - | xs = non_empty_list_commas_rev(X) ; ioption(",") {List.rev xs} - -non_empty_list_commas_with_tail (X): - | xs = non_empty_list_commas_rev(X); "," {List.rev xs} - -%inline list_commas( X): - | {[]} - | non_empty_list_commas(X) {$1} - -%inline list_commas_no_trailing(X): - | { [] } - | non_empty_list_commas_no_trailing(X) { $1 } - -non_empty_list_commas_with_trailing_info(X): - | xs = non_empty_list_commas_rev(X); comma=ioption(",") { (List.rev xs, Option.is_some comma) } - -%inline list_commas_with_trailing_info(X): - | {([], false)} - | non_empty_list_commas_with_trailing_info(X) { $1 } - -non_empty_list_semi_rev_aux(X): - | x = X { [x] } - | xs=non_empty_list_semi_rev_aux(X) ; SEMI ; x=X { x::xs} - -%inline non_empty_list_semis_rev(X): - | xs = non_empty_list_semi_rev_aux(X) ; ioption(SEMI) {xs} - -%inline none_empty_list_semis_rev_with_trailing_info(X): - | xs = non_empty_list_semi_rev_aux(X) ; semi=ioption(SEMI) { (xs, Option.is_some semi) } - -non_empty_list_semis(X): - | non_empty_list_semis_rev(X) {List.rev $1 } - -%inline list_semis_rev(X): - | {[]} - | non_empty_list_semis_rev(X) {$1} - -%inline list_semis(X): - | {[]} - | non_empty_list_semis(X){$1} - -%inline id(x): x {$1} -%inline annot: ":" t=type_ {t} -%inline opt_annot: ioption(annot) {$1} - -fn_label: - | LABEL { { Parsing_syntax.label_name = $1; loc_ = i $sloc } } -; - -parameter: - (* binder : Type *) - | param_binder=binder param_annot=opt_annot { - { Parsing_syntax.param_binder; param_annot; param_kind = Positional } - } - (* Deprecated syntax. ~binder : Type *) - | label=fn_label param_annot=opt_annot { - let param_binder : Parsing_syntax.binder = - { binder_name = label.Parsing_syntax.label_name; loc_ = Rloc.trim_first_char label.loc_ } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - } - (* Deprecated syntax. ~binder : Type = expr *) - | label=fn_label param_annot=opt_annot "=" default=expr { - let param_binder : Parsing_syntax.binder = - { binder_name = label.Parsing_syntax.label_name; loc_ = Rloc.trim_first_char label.loc_ } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Optional { default } } - } - (* Deprecated syntax. ~binder? : Type = expr *) - | label=fn_label "?" param_annot=opt_annot { - let param_binder : Parsing_syntax.binder = - { binder_name = label.Parsing_syntax.label_name; loc_ = Rloc.trim_first_char label.loc_ } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - } - (* binder~ : Type *) - | binder_name=POST_LABEL param_annot=opt_annot { - let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i $loc(binder_name)) } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Labelled } - } - (* binder~ : Type = expr *) - | binder_name=POST_LABEL param_annot=opt_annot "=" default=expr { - let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = Rloc.trim_last_char (i $loc(binder_name)) } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Optional { default } } - } - (* binder? : Type = expr *) - | binder_name=LIDENT "?" param_annot=opt_annot { - let param_binder : Parsing_syntax.binder = - { binder_name; loc_ = i $loc(binder_name) } - in - { Parsing_syntax.param_binder; param_annot; param_kind = Question_optional } - } -; - -%inline parameters : delimited("(",list_commas(parameter), ")") {$1} - -type_parameters: - | delimited("[",non_empty_list_commas(id(tvar_binder)), "]") { $1 } - -optional_type_parameters: - | params = option(type_parameters) { - match params with - | None -> [] - | Some params -> params - } -optional_type_parameters_no_constraints: - | params = option(delimited("[",non_empty_list_commas(id(type_decl_binder)), "]")) { - match params with - | None -> [] - | Some params -> params - } -optional_type_arguments: - | params = option(delimited("[" ,non_empty_list_commas(type_), "]")) { - match params with - | None -> [] - | Some params -> params - } -fun_binder: - | type_name=type_name "::" func_name=LIDENT { - let binder : Parsing_syntax.binder = - { binder_name = func_name; loc_ = i ($loc(func_name)) } - in - (Some type_name, binder) - } - | binder { (None, $1) } -fun_header: - pub=ioption("pub") "fn" - fun_binder=fun_binder - has_error=optional_bang - quants=optional_type_parameters - ps=option(parameters) - ts=option("->" t=return_type{t}) - { - let type_name, f = fun_binder in - { Parsing_syntax.type_name; name = f; has_error; quantifiers = quants; - decl_params = ps; params_loc_=(i $loc(ps)); return_type = ts; is_pub = pub <> None; doc_ = Docstring.empty } - } - -local_type_decl: - | "struct" tycon=luident "{" fs=list_semis(record_decl_field) "}" { - ({ local_tycon = tycon; local_tycon_loc_ = i $loc(tycon); local_components = Ptd_record fs }: Parsing_syntax.local_type_decl) } - | "enum" tycon=luident "{" cs=list_semis(enum_constructor) "}" { - ({ local_tycon = tycon; local_tycon_loc_ = i $loc(tycon); local_components = Ptd_variant cs }: Parsing_syntax.local_type_decl) } - -extern_fun_header: - pub=ioption("pub") - "extern" language=STRING "fn" - fun_binder=fun_binder - has_error=optional_bang - quants=optional_type_parameters - ps=option(parameters) - ts=option("->" t=return_type{t}) - { - let type_name, f = fun_binder in - language, { Parsing_syntax.type_name; name = f; has_error; quantifiers = quants; - decl_params = ps; params_loc_=(i $loc(ps)); return_type = ts; is_pub = pub <> None; doc_ = Docstring.empty } - } - -%inline block_expr: "{" ls=list_semis_rev(statement) "}" {Parsing_compact.compact_rev ls (i $sloc)} - -%inline block_expr_with_local_types: "{" ts=list_semis(local_type_decl) ls=list_semis_rev(statement) "}" - { (ts, Parsing_compact.compact_rev ls (if ts = [] then i $sloc else i $loc(ls))) } - -expression : expr EOF { $1 } - -val_header : - | pub=ioption("pub") "let" binder=binder t=opt_annot { false, pub <> None, binder, t} - | pub=ioption("pub") "const" binder_name=UIDENT t=opt_annot { - true, pub <> None, { Parsing_syntax.binder_name; loc_ = i $loc(binder_name) }, t - } - -structure : list_semis(structure_item) EOF {$1} -structure_item: - | type_header=type_header deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef { tycon; tycon_loc_; params; components = Ptd_abstract; type_vis; doc_ = Docstring.empty; deriving_; loc_ = aloc $sloc; } - } - | type_header=type_header ty=type_ deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef { tycon; tycon_loc_; params; components = Ptd_newtype ty; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc } - } - | type_header=type_header_bang ty=option(type_) deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_ = type_header in - let exception_decl: Parsing_syntax.exception_decl = - match ty with | None -> No_payload | Some ty -> Single_payload ty - in - Ptop_typedef { tycon; tycon_loc_; params = []; components = Ptd_error exception_decl; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc } - } - | type_header=type_header_bang "{" cs=list_semis(enum_constructor) "}" deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_ = type_header in - let exception_decl: Parsing_syntax.exception_decl = Enum_payload cs in - Ptop_typedef { tycon; tycon_loc_; params = []; components = Ptd_error exception_decl; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc } - } - | type_header=type_alias_header "=" ty=type_ deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_, params = type_header in - Ptop_typedef { tycon; tycon_loc_; params; components = Ptd_alias ty; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc } - } - | struct_header=struct_header "{" fs=list_semis(record_decl_field) "}" deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_, params = struct_header in - Ptop_typedef { tycon; tycon_loc_; params; components = Ptd_record fs; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc} - } - | enum_header=enum_header "{" cs=list_semis(enum_constructor) "}" deriving_=deriving_directive_list { - enter_next_block (); - let type_vis, tycon, tycon_loc_, params = enum_header in - Ptop_typedef { tycon; tycon_loc_; params; components = Ptd_variant cs; type_vis; doc_ = Docstring.empty ; deriving_; loc_ = aloc $sloc} - } - | val_header=val_header "=" expr = expr { - enter_next_block (); - let is_constant, is_pub, binder, ty = val_header in - Ptop_letdef { binder; ty; expr; is_pub; is_constant; loc_ = aloc $sloc; doc_ = Docstring.empty } - } - | t=fun_header "=" mname=STRING fname=STRING { - enter_next_block (); - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = t ; - decl_body = Decl_stubs (Import {module_name = mname; func_name = fname }); - } - } - | t=fun_header "=" s=STRING { - enter_next_block (); - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = t ; - decl_body = Decl_stubs (Embedded { language = None; code = Code_string s }); - } - } - | t=fun_header "=" xs=non_empty_list(MULTILINE_STRING) { - enter_next_block (); - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = t ; - decl_body = Decl_stubs (Embedded { language = None; code = Code_multiline_string xs }); - } - } - | t=extern_fun_header "=" s=STRING { - enter_next_block (); - let language, decl = t in - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = decl ; - decl_body = Decl_stubs (Embedded { language = Some language; code = Code_string s }) - } - } - | t=extern_fun_header "=" xs=non_empty_list(MULTILINE_STRING) { - enter_next_block (); - let language, decl = t in - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = decl ; - decl_body = Decl_stubs (Embedded { language = Some language; code = Code_multiline_string xs }); - } - } - | t=fun_header body=block_expr_with_local_types { - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_funcdef { - loc_ = (aloc $sloc); - fun_decl = t; - decl_body = Decl_body { expr=body; local_types }; - } - } - | vis=visibility "trait" name=luident - supers=option(COLON separated_nonempty_list(PLUS, tvar_constraint) { $2 }) - "{" methods=list_semis(trait_method_decl) "}" { - let trait_name : Parsing_syntax.binder = { binder_name = name; loc_ = i ($loc(name)) } in - enter_next_block (); - let supers = - match supers with None -> [] | Some supers -> supers - in - Parsing_syntax.Ptop_trait { - trait_name; - trait_supers = supers; - trait_methods = methods; - trait_vis = vis; - trait_loc_ = (aloc $sloc); - trait_doc_ = Docstring.empty; - } - } - | "test" name=option(loced_string) params=option(parameters) body=block_expr_with_local_types { - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_test { - expr = body; - name; - params; - local_types; - loc_ = (aloc $sloc); - } - } - | pub=ioption("pub") - "impl" - quantifiers=optional_type_parameters - trait=type_name - "for" self_ty=type_ - "with" - method_name=binder - has_error=optional_bang - params=parameters ret_ty=ioption("->" return_type { $2 }) - body=block_expr_with_local_types - { - let header_loc_ = i ($startpos($2), $endpos(ret_ty)) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { self_ty = Some self_ty - ; trait - ; method_name - ; has_error - ; quantifiers - ; params - ; ret_ty - ; body - ; is_pub = Option.is_some pub - ; local_types - ; header_loc_ - ; loc_ = aloc $sloc - ; doc_ = Docstring.empty - } - } - | pub=ioption("pub") - "impl" - quantifiers=optional_type_parameters - trait=type_name - "with" - method_name=binder - has_error=optional_bang - params=parameters ret_ty=ioption("->" return_type { $2 }) - body=block_expr_with_local_types - { - let header_loc_ = i ($startpos($2), $endpos(ret_ty)) in - enter_next_block (); - let local_types, body = body in - Parsing_syntax.Ptop_impl - { self_ty = None - ; trait - ; method_name - ; has_error - ; quantifiers - ; params - ; ret_ty - ; body - ; is_pub = Option.is_some pub - ; local_types - ; header_loc_ - ; loc_ = aloc $sloc - ; doc_ = Docstring.empty - } - } - /* - | pub=ioption("pub") - "impl" - quantifiers=optional_type_parameters - trait=type_name - "for" self_ty=type_ - { - Parsing_syntax.Ptop_impl_relation - { self_ty; trait; quantifiers; is_pub = Option.is_some pub; loc_ = i $sloc } - } - */ - -%inline visibility: - | /* empty */ { Parsing_syntax.Vis_default } - | "priv" { Parsing_syntax.Vis_priv { loc_ = i $sloc } } - | "pub" attr=pub_attr { Parsing_syntax.Vis_pub { attr; loc_ = i $sloc } } -pub_attr: - | /* empty */ { None } - | "(" "readonly" ")" { Some "readonly" } - | "(" attr=LIDENT ")" { Some attr } -type_header: vis=visibility "type" tycon=luident params=optional_type_parameters_no_constraints { - vis, tycon, i $loc(tycon), params -} -type_header_bang: vis=visibility "type" "!" tycon=luident { - vis, tycon, i $loc(tycon) -} -type_alias_header: vis=visibility "typealias" tycon=luident params=optional_type_parameters_no_constraints { - vis, tycon, i $loc(tycon), params -} -struct_header: vis=visibility "struct" tycon=luident params=optional_type_parameters_no_constraints { - vis, tycon, i $loc(tycon), params -} -enum_header: vis=visibility "enum" tycon=luident params=optional_type_parameters_no_constraints { - vis, tycon, i $loc(tycon), params -} - -deriving_directive: - | type_name=type_name { - ({ type_name_ = type_name; loc_ = i $sloc; args = [] } : Parsing_syntax.deriving_directive) - } - | type_name=type_name "(" args=list_commas(argument) ")" { - ({ type_name_ = type_name; loc_ = i $sloc; args } : Parsing_syntax.deriving_directive) - } - -deriving_directive_list: - | /* nothing */ { [] } - | "derive" "(" list_commas(deriving_directive) ")" { $3 } - -trait_method_decl: - name=binder - has_error=optional_bang - quantifiers=optional_type_parameters - "(" - params=list_commas(trait_method_param) - ")" - return_type=option("->" t=return_type{t}) - { - Parsing_syntax.Trait_method { - name; - has_error; - quantifiers; - params; - return_type; - loc_ = i $sloc; - } - } - -trait_method_param: - | typ=type_ { - { Parsing_syntax.tmparam_typ = typ; tmparam_label = None } - } - (* Deprecated. ~label : Type *) - | label_name=LABEL ":" typ=type_ { - let label = { Parsing_syntax.label_name; loc_ = Rloc.trim_first_char (i $loc(label_name)) } in - { Parsing_syntax.tmparam_typ = typ; tmparam_label = Some label } - } - (* label~ : Type *) - | label_name=POST_LABEL ":" typ=type_ { - let label = { Parsing_syntax.label_name; loc_ = Rloc.trim_last_char (i $loc(label_name)) } in - { Parsing_syntax.tmparam_typ = typ; tmparam_label = Some label } - } - -luident: - | i=LIDENT - | i=UIDENT { i } - -qual_ident: - | i=LIDENT { Lident(i) } - | ps=PACKAGE_NAME id=DOT_LIDENT { Ldot({ pkg = ps; id}) } - -qual_ident_simple_expr: - /* This precedence declaration is used to disambiguate between: - - 1. f(g?(...)) (error to result) - 2. f(l?=...) (forward optional argument) - - To disambiguate the two, we need to look at the token after "?" (LPAREN or EQUAL). - But Menhir has only one token lookahead, so if reduction is needed on `g`/`l`, - Menhir will complain for shift/reduce conflict. - - To solve this problem, here we: - - add a specialized rule for the case of `LIDENT QUESTION LPAREN ... RPAREN`. - Since no reduction is needed on the first LIDENT, this rule will not conflict with forwarding optional argument - - make sure the general rule SIMPLE_EXPR QUESTION LPAREN ... RPAREN does not conflict with the specialized rule. - This is done via the precedence declaration here. - We assign higher precedence to shifting QUESTION than the LIDENT -> qual_ident -> simple_expr reduction chain, - so that Menhir knows that the specialized rule has higher precedence. - */ - | i=LIDENT %prec prec_apply_non_ident_fn { Lident(i) } - | ps=PACKAGE_NAME id=DOT_LIDENT { Ldot({ pkg = ps; id}) } - -qual_ident_ty: - | i=luident { Lident(i) } - | ps=PACKAGE_NAME id=DOT_LIDENT - | ps=PACKAGE_NAME id=DOT_UIDENT { Ldot({ pkg = ps; id}) } - -%inline semi_expr_semi_opt: none_empty_list_semis_rev_with_trailing_info(statement) { - let ls, trailing = $1 in - (Parsing_compact.compact_rev ls (i $sloc), trailing) -} - -%inline optional_bang: - | "!" { true } - | { false } - -%inline fn_header: - | "fn" binder=binder has_error=optional_bang "{" { (binder, has_error) } - -%inline fn_header_no_binder: - | "fn" has_error=optional_bang "{" { has_error } - -statement: - | "let" pat=pattern ty_opt=opt_annot "=" expr=expr - { - let pat = - match ty_opt with - | None -> pat - | Some ty -> - Parsing_syntax.Ppat_constraint - { - pat; - ty; - loc_ = - Rloc.merge - (Parsing_syntax.loc_of_pattern pat) - (Parsing_syntax.loc_of_type_expression ty); - } in - Stmt_let {pat; expr; loc=(i $sloc); }} - | "let" "mut" binder=binder ty=opt_annot "=" expr=expr - { Stmt_letmut {binder; ty_opt=ty; expr; loc=(i $sloc)} } - | "fn" binder=binder has_error=optional_bang params=parameters ty_opt=option("->" t=return_type {t}) block = block_expr - { - (* FIXME: `func` should have explicit return type in the ast *) - let locb = i $sloc in - let func : Parsing_syntax.func = Lambda { parameters = params; params_loc_ = (i $loc(params));body = block; return_type = ty_opt; kind_ = Lambda; has_error } in - Parsing_compact.Stmt_func {binder; func; loc=locb} - } - | binder=fn_header cases=list_semis( pats=non_empty_list_commas(pattern) "=>" body=expr_statement { (pats, body) } ) "}" - { let (binder, has_error) = binder in - Parsing_compact.Stmt_func {binder; func = Match { cases; has_error; loc_ = i $loc(cases); fn_loc_ = i $loc(binder) }; loc=i $sloc} } - | guard_statement { $1 } - | expr_statement { Parsing_compact.Stmt_expr { expr = $1 } } - -guard_statement: - | "guard" cond=infix_expr - { Parsing_compact.Stmt_guard { cond; otherwise=None; loc=(i $sloc) } } - | "guard" cond=infix_expr "else" else_=block_expr - { Parsing_compact.Stmt_guard { cond; otherwise=Some else_; loc=(i $sloc) } } - | "guard" "let" pat=pattern "=" expr=infix_expr - { Parsing_compact.Stmt_guard_let { pat; expr; otherwise=None; loc=(i $sloc) } } - | "guard" "let" pat=pattern "=" expr=infix_expr "else" "{" cases=single_pattern_cases "}" - { Parsing_compact.Stmt_guard_let { pat; expr; otherwise=Some cases; loc=(i $sloc) } } - -%inline assignment_expr: - | lv = left_value "=" e=expr { - let loc_ = i $sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign { var; expr = e; augmented_by = None; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate { record; accessor; field = e; augmented_by = None; loc_ } - | `Array_access (array, index) -> - Pexpr_array_set {array; index; value=e; loc_} - } - -%inline augmented_assignment_expr: - | lv = left_value op=assignop e=expr { - let loc_ = i $sloc in - match lv with - | `Var var -> - Parsing_syntax.Pexpr_assign { var; expr = e; augmented_by = Some op; loc_ } - | `Field_access (record, accessor) -> - Parsing_syntax.Pexpr_mutate { record; accessor; field = e; augmented_by = Some op; loc_ } - | `Array_access (array, index) -> - Pexpr_array_augmented_set {op; array; index; value=e; loc_} - } - -%inline expr_statement: - | "break" arg=ioption(expr) { - Parsing_syntax.Pexpr_break { arg; loc_ = i $sloc } - } - | "continue" args=list_commas_no_trailing(expr) { - Parsing_syntax.Pexpr_continue { args; loc_ = i $sloc } - } - | "return" expr = option(expr) { Parsing_syntax.Pexpr_return { return_value = expr; loc_ = i $sloc } } - | "raise" expr = expr { Parsing_syntax.Pexpr_raise { err_value = expr; loc_ = i $sloc } } - | "..." { Parsing_syntax.Pexpr_hole { loc_ = i $sloc; kind = Todo } } - | augmented_assignment_expr - | assignment_expr - | expr { $1 } - -while_expr: - | "while" cond=infix_expr body=block_expr while_else=optional_else - { Parsing_syntax.Pexpr_while { loc_=(i $sloc); loop_cond = cond; loop_body = body; while_else } } - -single_pattern_cases: -| cases=list_semis(pat=pattern "=>" body=expr_statement { (pat, body) } ) { cases } - -%inline catch_keyword: - | "catch" "{" | "{" { false, i $sloc } - | "catch" "!" "{" { true, i $sloc } - -%inline else_keyword: - | "else" "{" { i $sloc } - -try_expr: - | "try" body=expr catch_keyword=catch_keyword catch=single_pattern_cases "}" - { let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try { loc_=(i $sloc); body; catch; catch_all; try_else = None; - else_loc_ = Rloc.no_location; try_loc_ = i $loc($1); catch_loc_ } } - | "try" body=expr catch_keyword=catch_keyword catch=single_pattern_cases "}" - else_loc_=else_keyword try_else=single_pattern_cases "}" - { let catch_all, catch_loc_ = catch_keyword in - Parsing_syntax.Pexpr_try { loc_=(i $sloc); body; catch; catch_all; try_else = Some try_else; - else_loc_; try_loc_ = i $loc($1); catch_loc_ } } - -if_expr: - | "if" b=infix_expr ifso=block_expr "else" ifnot=block_expr - | "if" b=infix_expr ifso=block_expr "else" ifnot=if_expr { Pexpr_if {loc_=(i $sloc); cond=b; ifso; ifnot = Some ifnot} } - | "if" b=infix_expr ifso=block_expr {Parsing_syntax.Pexpr_if {loc_=(i $sloc); cond = b; ifso; ifnot =None}} - -%inline match_header: - | "match" e=infix_expr "{" { e } - -match_expr: - | e=match_header mat=non_empty_list_semis( pattern "=>" expr_statement {($1,$3)}) "}" { - Pexpr_match {loc_=(i $sloc); expr = e ; cases = mat; match_loc_ = i $loc(e)} } - | e=match_header "}" { Parsing_syntax.Pexpr_match { loc_ = (i $sloc) ; expr = e ; cases = []; match_loc_ = i $loc(e)}} - -%inline loop_header: - | "loop" args=non_empty_list_commas_no_trailing(expr) "{" { args } - -loop_expr: - | args=loop_header - body=list_semis( - pats=non_empty_list_commas(pattern) "=>" body=expr_statement { - (pats, body) - } - ) - "}" { Parsing_syntax.Pexpr_loop { args; body; loc_ = i $sloc; loop_loc_ = i $loc(args) } } - -for_binders: - | binders=list_commas_no_trailing(b=binder "=" e=expr { (b, e) }) { binders } - -optional_else: - | "else" else_=block_expr { Some else_ } - | { None } - -for_expr: - | "for" binders = for_binders SEMI - condition = option(infix_expr) SEMI - continue_block = list_commas_no_trailing(b=binder "=" e=expr { (b, e) }) - body = block_expr - for_else = optional_else - { Parsing_syntax.Pexpr_for {loc_ = i $sloc; binders; condition; continue_block; body; for_else } } - | "for" binders = for_binders body = block_expr for_else=optional_else - { Parsing_syntax.Pexpr_for {loc_ = i $sloc; binders; condition = None; continue_block = []; body; for_else } } - -foreach_expr: - | "for" binders=non_empty_list_commas(foreach_binder) "in" expr=expr - body=block_expr - else_block=optional_else - { - Parsing_syntax.Pexpr_foreach { binders; expr; body; else_block; loc_ = i $sloc } - } - -foreach_binder : - | binder { Some $1 } - | "_" { None } - -expr: - | loop_expr - | for_expr - | foreach_expr - | while_expr - | try_expr - | if_expr - | match_expr - | pipe_expr {$1} - -pipe_expr: - | lhs=pipe_expr "|>" rhs=infix_expr { - Parsing_syntax.Pexpr_pipe { lhs; rhs; loc_ = i $sloc } - } - | infix_expr { $1 } - -infix_expr: - | lhs=infix_expr op=infixop rhs=infix_expr { - Pexpr_infix{ op ; lhs ; rhs ; loc_ = i($sloc)} - } - | postfix_expr { $1 } - -postfix_expr: - | expr=prefix_expr "as" trait=type_name { - Pexpr_as { expr; trait; loc_ = i $sloc } - } - | prefix_expr { $1 } - -prefix_expr: - | op=id(PLUS {"+"}) e=prefix_expr { make_uplus ~loc_:(i $sloc) op e } - | op=id(MINUS{"-"}) e=prefix_expr { make_uminus ~loc_:(i $sloc) op e } - | simple_expr { $1 } - -%inline left_value: - | var=var { `Var var } - | record=simple_expr acc=accessor { - `Field_access (record, acc) - } - | obj=simple_expr "[" ind=expr "]" { - `Array_access (obj, ind) - } - -%inline constr: - | name = UIDENT { - { Parsing_syntax.constr_name = { name; loc_ = i $loc(name) } - ; extra_info = No_extra_info - ; loc_=(i $loc) - } - } - | pkg=PACKAGE_NAME constr_name=DOT_UIDENT { - { Parsing_syntax.constr_name = { name = constr_name; loc_ = i $loc(constr_name) } - ; extra_info = Package pkg - ; loc_= i $sloc - } - } - /* TODO: two tokens or one token here? */ - | type_name=qual_ident_ty "::" constr_name=UIDENT { - { Parsing_syntax.constr_name = { name = constr_name; loc_ = i $loc(constr_name) } - ; extra_info = Type_name { name = type_name; loc_ = i $loc(type_name) } - ; loc_= i $sloc - } - } - -%inline apply_attr: - | { Parsing_syntax.No_attr } - | "!" { Parsing_syntax.Exclamation } - | "?" { Parsing_syntax.Question } - -simple_expr: - | "{" x=record_defn "}" { - let (fs, trailing) = x in - make_Pexpr_record ~loc_:(i $sloc) ~trailing None (fs) - } - | type_name=type_name COLONCOLON "{" x=list_commas_with_trailing_info(record_defn_single) "}" { - let (fs, trailing) = x in - let trailing = if trailing then Parsing_syntax.Trailing_comma else Parsing_syntax.Trailing_none in - make_Pexpr_record ~loc_:(i $sloc) ~trailing (Some type_name) fs - } - | type_name=ioption(terminated(type_name, COLONCOLON)) "{" ".." oe=expr "}" { - Pexpr_record_update { type_name; record=oe; fields=[]; loc_=i $sloc } - } - | type_name=ioption(terminated(type_name, COLONCOLON)) "{" ".." oe=expr "," fs=list_commas(record_defn_single) "}" { - Pexpr_record_update { type_name; record=oe; fields=fs; loc_=i $sloc } - } - | "{" x=semi_expr_semi_opt "}" { - match x with - | Parsing_syntax.Pexpr_ident { id = { var_name = Lident str; loc_ }; _ } as expr, trailing -> - let label = { Parsing_syntax.label_name = str; loc_ } in - let field = make_field_def ~loc_:(i $sloc) label expr true in - let trailing = if trailing then Parsing_syntax.Trailing_semi else Parsing_syntax.Trailing_none in - make_Pexpr_record ~loc_:(i $sloc) ~trailing None [field] - | expr, _ -> Pexpr_group { expr; group = Group_brace; loc_ = i $sloc } - } - | "{" elems=list_commas(map_expr_elem) "}" { - Parsing_syntax.Pexpr_map { elems; loc_ = i $sloc } - } - | "fn" has_error=optional_bang ps=parameters ty_opt=option("->" t=return_type {t}) f=block_expr - { Pexpr_function {loc_=i $sloc; func = Lambda {parameters = ps; has_error; params_loc_ = (i $loc(ps));body = f ; return_type = ty_opt; kind_ = Lambda }} } - | has_error=fn_header_no_binder cases=list_semis( pats=non_empty_list_commas(pattern) "=>" body=expr_statement { (pats, body) } ) "}" - { Pexpr_function {loc_=i $sloc; func = Match { cases; has_error; loc_ = i $loc(cases); fn_loc_ = i $loc(has_error) }} } - | e = atomic_expr {e} - | "_" { Pexpr_hole { loc_ = (i $sloc) ; kind = Incomplete } } - | var_name=qual_ident_simple_expr { make_Pexpr_ident ~loc_:(i $sloc) { var_name; loc_ = i $sloc } } - | c=constr { Parsing_syntax.Pexpr_constr {loc_ = (i $sloc); constr = c} } - | func=LIDENT "?" "(" args=list_commas(argument) ")" { - let func : Parsing_syntax.expr = - let loc_ = i $loc(func) in - Pexpr_ident { id = { var_name = Lident func; loc_ }; loc_ } - in - Pexpr_apply { func; args; loc_ = i $sloc; attr = Question } - } - | func=simple_expr attr=apply_attr "(" args=list_commas(argument) ")" { - Pexpr_apply { func; args; loc_ = i $sloc; attr } - } - | array=simple_expr "[" index=expr "]" { - Pexpr_array_get { array; index; loc_ = i $sloc } - } - | array=simple_expr "[" start_index = ioption(expr) ":" end_index = ioption(expr) "]" { - Pexpr_array_get_slice { array; start_index; end_index; loc_ = i $sloc; index_loc_ = (i ($startpos($2), $endpos($6))) } - } - | self=simple_expr meth=DOT_LIDENT attr=apply_attr "(" args=list_commas(argument) ")" { - let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i ($loc(meth)) } - in - Pexpr_dot_apply { self; method_name; args; return_self = false; attr; loc_ = (i $sloc) }; - } - | self=simple_expr ".." meth=LIDENT attr=apply_attr "(" args=list_commas(argument) ")" { - let method_name : Parsing_syntax.label = - { label_name = meth; loc_ = i ($loc(meth)) } - in - Pexpr_dot_apply { self; method_name; args; return_self = true; attr; loc_ = (i $sloc) }; - } - | record=simple_expr accessor=accessor %prec prec_field { - Pexpr_field { record; accessor; loc_ = (i $sloc) }} - | type_name=qual_ident_ty "::" meth=LIDENT { - let type_name : Parsing_syntax.type_name = - { name = type_name; loc_ = i ($loc(type_name)) } - in - let method_name: Parsing_syntax.label = - { label_name = meth; loc_ = i ($loc(meth)) } in - Pexpr_method { type_name; method_name; loc_ = i $sloc } - } - | "(" bs=list_commas(expr) ")" { - match bs with - | [] -> Pexpr_unit {loc_ = i $sloc; faked = false} - | [expr] -> Pexpr_group { expr; group = Group_paren; loc_ = i $sloc } - | _ -> make_Pexpr_tuple ~loc_:(i $sloc) bs - } - | "(" expr=expr ty=annot ")" - { Parsing_syntax.Pexpr_constraint {loc_=(i $sloc); expr; ty} } - | "[" es = list_commas(spreadable_elem) "]" { (make_Pexpr_array ~loc_:(i $sloc) es) } - -%inline label: - name = LIDENT { { Parsing_syntax.label_name = name; loc_=(i $loc) } } -%inline accessor: - | name = DOT_LIDENT { - if name = "_" - then Parsing_syntax.Newtype - else Parsing_syntax.Label { label_name = name; loc_ = (i $loc) } - } - | index = DOT_INT { Parsing_syntax.Index { tuple_index = index; loc_ = (i $loc) } } -%inline binder: - name = LIDENT { { Parsing_syntax.binder_name = name; loc_=(i $loc) } } -%inline tvar_binder: - | name = luident { - { Parsing_syntax.tvar_name = name; tvar_constraints = []; loc_=(i $loc) } - } - | name = luident COLON constraints = separated_nonempty_list(PLUS, tvar_constraint) { - { Parsing_syntax.tvar_name = name; tvar_constraints = constraints; loc_ = (i $loc(name)) } - } -%inline type_decl_binder: - | name = luident { { Parsing_syntax.tvar_name = Some name; loc_=(i $loc) } } - | "_" { { Parsing_syntax.tvar_name = None; loc_ = (i $loc) } } -%inline tvar_constraint: - | qual_ident_ty { { Parsing_syntax.tvc_trait = $1; loc_ = i $sloc } } - /* special case for Error? */ - | id=UIDENT "?" { { Parsing_syntax.tvc_trait = Lident (id ^ "?"); loc_ = i $sloc } } -%inline var: - name = qual_ident { { Parsing_syntax.var_name = name; loc_=(i $loc) } } -%inline type_name: - name = qual_ident_ty { { Parsing_syntax.name; loc_ = i $loc } } - -%inline multiline_string: - | MULTILINE_STRING { Parsing_syntax.Multiline_string $1 } - | MULTILINE_INTERP { Parsing_syntax.Multiline_interp (make_interps $1) } - -%inline atomic_expr: - | simple_constant { make_Pexpr_constant ~loc_:(i $sloc) $1 } - | non_empty_list(multiline_string) { - Parsing_syntax.Pexpr_multiline_string { loc_=(i $sloc); elems=($1) } - } - | INTERP { (make_Pexpr_interp ~loc_:(i $sloc) ($1)) } - -%inline simple_constant: - | TRUE { Parsing_syntax.Const_bool true } - | FALSE { Parsing_syntax.Const_bool false } - | BYTE { Parsing_syntax.Const_byte $1 } - | BYTES { Parsing_syntax.Const_bytes $1 } - | CHAR { Parsing_syntax.Const_char $1 } - | INT { Parsing_util.make_int $1 } - | FLOAT { Parsing_util.make_float $1 } - | STRING { Parsing_syntax.Const_string $1 } - -%inline map_syntax_key: - | simple_constant { $1 } - | MINUS INT { Parsing_util.make_int ("-" ^ $2) } - | MINUS FLOAT { Parsing_syntax.Const_double ("-" ^ $2) } - -%inline loced_string: - | STRING { {Rloc.v = $1; loc_ = i $sloc}} - -%inline assignop: - | AUGMENTED_ASSIGNMENT { {Parsing_syntax.var_name = Lident $1; loc_ = i $sloc} } - -%inline infixop: - | INFIX4 - | INFIX3 - | INFIX2 - | INFIX1 { {Parsing_syntax.var_name = Lident $1; loc_ = i $sloc} } - | PLUS { {Parsing_syntax.var_name = Lident "+"; loc_ = i $sloc} } - | MINUS { {Parsing_syntax.var_name = Lident "-"; loc_ = i $sloc} } - | AMPER { {Parsing_syntax.var_name = Lident "&"; loc_ = i $sloc} } - | CARET { {Parsing_syntax.var_name = Lident "^"; loc_ = i $sloc} } - | BAR { {Parsing_syntax.var_name = Lident "|"; loc_ = i $sloc} } - | AMPERAMPER { {Parsing_syntax.var_name = Lident "&&"; loc_ = i $sloc} } - | BARBAR { {Parsing_syntax.var_name = Lident "||"; loc_ = i $sloc} } - | RANGE_EXCLUSIVE { {Parsing_syntax.var_name = Lident "..<"; loc_ = i $sloc} } - | RANGE_INCLUSIVE { {Parsing_syntax.var_name = Lident "..="; loc_ = i $sloc} } - -%inline optional_question: - | "?" { Some(i $sloc) } - | /* empty */ { None } - -argument: - (* label=expr *) - | label=label is_question=optional_question "=" arg_value=expr { - let arg_kind = - match is_question with - | Some question_loc -> Parsing_syntax.Labelled_option { label; question_loc } - | None -> Labelled label - in - { Parsing_syntax.arg_value; arg_kind } - } - (* Deprecated syntax. `~label` or `~label?` *) - | label=fn_label is_question=optional_question { - let arg_value = Parsing_util.label_to_expr ~loc_:(Rloc.trim_first_char (i $loc(label))) label in - let arg_kind = - match is_question with - | Some question_loc -> Parsing_syntax.Labelled_option_pun { label; question_loc } - | None -> Labelled_pun label - in - { Parsing_syntax.arg_value; arg_kind } - } - (* expr *) - | arg_value=expr { { Parsing_syntax.arg_value; arg_kind = Positional } } - (* label~ *) - | label=POST_LABEL { - let label = { Parsing_syntax.label_name = label; loc_ = i $loc(label) } in - let arg_value = Parsing_util.label_to_expr ~loc_:(Rloc.trim_last_char (i $loc(label))) label in - { Parsing_syntax.arg_value; arg_kind = Labelled_pun label } - } - (* label? *) - | id=LIDENT "?" { - let loc_ = i $loc(id) in - let label = { Parsing_syntax.label_name = id; loc_ } in - let arg_value = make_Pexpr_ident ~loc_ { var_name = Lident id; loc_ } in - { Parsing_syntax.arg_value; arg_kind = Labelled_option_pun { label; question_loc = i $loc($2) }} - } - - -%inline spreadable_elem: - | expr=expr { Parsing_syntax.Elem_regular expr } - | ".." expr=expr { Parsing_syntax.Elem_spread {expr; loc_=(i $sloc)} } - -%inline map_expr_elem: - | key=map_syntax_key ":" expr=expr { - Parsing_syntax.Map_expr_elem - { key - ; expr - ; key_loc_ = i $loc(key) - ; loc_ = i $sloc - } - } - -pattern: - | p=pattern "as" b=binder { (make_Ppat_alias ~loc_:(i $sloc) (p, b)) } - | or_pattern { $1 } - -or_pattern: - | pat1=range_pattern "|" pat2=or_pattern { Parsing_syntax.Ppat_or {loc_=(i $sloc); pat1 ; pat2 } } - | range_pattern { $1 } - -range_pattern: - | lhs=simple_pattern "..<" rhs=simple_pattern { - Parsing_syntax.Ppat_range { lhs; rhs; inclusive = false; loc_ = i $sloc } - } - | lhs=simple_pattern "..=" rhs=simple_pattern { - Parsing_syntax.Ppat_range { lhs; rhs; inclusive = true; loc_ = i $sloc } - } - | simple_pattern { $1 } - -simple_pattern: - | TRUE { (make_Ppat_constant ~loc_:(i $sloc) (Const_bool true)) } - | FALSE { (make_Ppat_constant ~loc_:(i $sloc) (Const_bool false)) } - | CHAR { make_Ppat_constant ~loc_:(i $sloc) (Const_char $1) } - | INT { (make_Ppat_constant ~loc_:(i $sloc) (Parsing_util.make_int $1)) } - | FLOAT { (make_Ppat_constant ~loc_:(i $sloc) (Const_double $1)) } - | "-" INT { (make_Ppat_constant ~loc_:(i $sloc) (Parsing_util.make_int ("-" ^ $2))) } - | "-" FLOAT { (make_Ppat_constant ~loc_:(i $sloc) (Const_double ("-" ^ $2))) } - | STRING { (make_Ppat_constant ~loc_:(i $sloc) (Const_string $1)) } - | UNDERSCORE { Ppat_any {loc_ = i $sloc } } - | b=binder { Ppat_var b } - | constr=constr ps=option("(" t=constr_pat_arguments ")" {t}){ - let (args, is_open) = - match ps with - | None -> (None, false) - | Some (args, is_open) -> (Some args, is_open) - in - make_Ppat_constr ~loc_:(i $sloc) (constr, args, is_open) - } - | "(" pattern ")" { $2 } - | "(" p = pattern "," ps=non_empty_list_commas(pattern) ")" {make_Ppat_tuple ~loc_:(i $sloc) (p::ps)} - | "(" pat=pattern ty=annot ")" { Parsing_syntax.Ppat_constraint {loc_=(i $sloc); pat; ty } } - | "[" pats=array_sub_patterns "]" { Ppat_array { loc_=(i $sloc); pats} } - | "{" "}" { Parsing_syntax.Ppat_record { fields = []; is_closed = true; loc_ = i $sloc } } - | "{" p=non_empty_fields_pat "}" { let (fps, is_closed) = p in (Parsing_syntax.Ppat_record { fields=fps; is_closed; loc_=(i $sloc) }) } - | "{" elems=non_empty_map_elems_pat "}" { Parsing_syntax.Ppat_map { elems; loc_ = i $sloc } } - -%inline dotdot_with_binder: - | ".." b=option("as" b=binder { b }) { b } - -array_sub_patterns: - | { Closed([]) } - | b=dotdot_with_binder ioption(",") { Open([], [], b) } - | ps=non_empty_list_commas(pattern) { Closed(ps) } - | b=dotdot_with_binder "," ps=non_empty_list_commas(pattern) { Open([], ps, b) }// .. a,b,c - | ps=non_empty_list_commas_with_tail(pattern) b=dotdot_with_binder ioption(",") { Open(ps, [], b) }//a,b,c .. | a,b,c .., - | ps1=non_empty_list_commas_with_tail(pattern) b=dotdot_with_binder "," ps2=non_empty_list_commas(pattern) { Open(ps1, ps2, b) } - -return_type: - | t=type_ %prec prec_type { (t, No_error_typ) } - | t1=type_ "!" { (t1, Default_error_typ { loc_ = i $loc($2) }) } - | t1=type_ "!" t2=type_ { (t1, Error_typ {ty = t2}) } - -type_: - | ty=type_ "?" { make_Ptype_option ~loc_:(i $sloc) ~constr_loc:(i $loc($2)) ty } - | "(" t=type_ "," ts=non_empty_list_commas(type_) ")" { (make_Ptype_tuple ~loc_:(i $sloc) (t::ts)) } - | "(" t=type_ "," ts=non_empty_list_commas(type_) ")" "->" rty=return_type { - let (ty_res, ty_err) = rty in - Ptype_arrow{loc_ = i $sloc ; ty_arg = t::ts ; ty_res; ty_err } - } - | "(" ")" "->" rty=return_type { let (ty_res, ty_err) = rty in Ptype_arrow{loc_ = i $sloc ; ty_arg = [] ; ty_res; ty_err}} - | "(" t=type_ ")" rty=option("->" t2=return_type {t2}) - { - match rty with - | None -> t - | Some rty -> - let (ty_res, ty_err) = rty in - Ptype_arrow{loc_=i($sloc); ty_arg=[t]; ty_res; ty_err} - } - // | "(" type_ ")" { $2 } - | id=qual_ident_ty params=optional_type_arguments { - Ptype_name {loc_ = (i $sloc) ; constr_id = {lid=id;loc_=(i $loc(id))} ; tys = params} } - | "_" { Parsing_syntax.Ptype_any {loc_ = i $sloc } } - - -record_decl_field: - | field_vis=visibility mutflag=option("mut") name=LIDENT ":" ty=type_ { - {Parsing_syntax.field_name = {Parsing_syntax.label = name; loc_ = i $loc(name)}; field_ty = ty; field_mut = mutflag <> None; field_vis; field_loc_ = i $sloc;} - } - -constructor_param: - | mut=option("mut") ty=type_ { - { Parsing_syntax.cparam_typ = ty; cparam_mut = Option.is_some mut; cparam_label = None } - } - (* Deprecated syntax. mut ~label : Type *) - | mut=option("mut") label_name=LABEL ":" typ=type_ { - let label : Parsing_syntax.label = { label_name; loc_ = Rloc.trim_first_char (i $loc(label_name)) } in - { Parsing_syntax.cparam_typ = typ; cparam_mut = Option.is_some mut; cparam_label = Some label } - } - (* mut label~ : Type *) - | mut=option("mut") label_name=POST_LABEL ":" typ=type_ { - let label : Parsing_syntax.label = { label_name; loc_ = Rloc.trim_last_char (i $loc(label_name)) } in - { Parsing_syntax.cparam_typ = typ; cparam_mut = Option.is_some mut; cparam_label = Some label } - } - -enum_constructor: - | id=UIDENT opt=option("(" ts=non_empty_list_commas(constructor_param)")" { ts }) { - let constr_name : Parsing_syntax.constr_name = { name = id; loc_ = i $loc(id) } in - {Parsing_syntax.constr_name; constr_args = opt; constr_loc_ = i $sloc;} - } - -record_defn: - /* ending comma is required for single field {a,} for resolving the ambiguity between record punning {a} and block {a} */ - | l=label_pun "," x=list_commas_with_trailing_info(record_defn_single) { - let (fs, trailing) = x in - let trailing = - if fs = [] || trailing then Parsing_syntax.Trailing_comma else Parsing_syntax.Trailing_none - in - (l::fs, trailing) - } - | l=labeled_expr comma=option(",") { - ([l], if Option.is_some comma then Parsing_syntax.Trailing_comma else Parsing_syntax.Trailing_none) - } - /* rule out {r1: r1 r2} */ - | l=labeled_expr "," x=non_empty_list_commas_with_trailing_info(record_defn_single) { - match x with - | (fs, true) -> (l::fs, Parsing_syntax.Trailing_comma) - | (fs, false) -> (l::fs, Parsing_syntax.Trailing_none) - } - -record_defn_single: - | labeled_expr - | label_pun {$1} - -%inline labeled_expr: - | l=label ":" e=expr {make_field_def ~loc_:(i $sloc) l e false} -%inline label_pun: - | l=label {make_field_def ~loc_:(i $sloc) l (label_to_expr ~loc_:(i $sloc) l) true} - -(* A field pattern list is a nonempty list of label-pattern pairs or punnings, optionally - followed with an underscore, separated-or-terminated with commas. *) -non_empty_fields_pat: - | fps=non_empty_list_commas(fields_pat_single) { fps, true } - | fps=non_empty_list_commas_with_tail(fields_pat_single) ".." ioption(",") { fps, false } - -fields_pat_single: - | fpat_labeled_pattern - | fpat_label_pun {$1} - -%inline fpat_labeled_pattern: - | l=label ":" p=pattern {make_field_pat ~loc_:(i $sloc) l p false} - -%inline fpat_label_pun: - | l=label {make_field_pat ~loc_:(i $sloc) l (label_to_pat ~loc_:(i $sloc) l) true} - -non_empty_map_elems_pat: - | non_empty_list_commas(map_elem_pat) { $1 } - -%inline map_elem_pat: - | key=map_syntax_key question=ioption("?") ":" pat=pattern { - Parsing_syntax.Map_pat_elem - { key - ; pat - ; match_absent = Option.is_some question - ; key_loc_ = i $loc(key) - ; loc_ = i $sloc - } - } - -constr_pat_arguments: - | constr_pat_argument ioption(",") { ([ $1 ], false) } - | ".." ioption(",") { ([], true) } - | arg=constr_pat_argument "," rest=constr_pat_arguments { - let (args, is_open) = rest in - (arg :: args, is_open) - } - -constr_pat_argument: - (* label=pattern *) - | label=label "=" pat=pattern { - Parsing_syntax.Constr_pat_arg { pat; kind = Labelled label } - } - (* Deprecated syntax. ~label *) - | label=fn_label { - let pat = Parsing_util.label_to_pat ~loc_:(Rloc.trim_first_char (i $sloc)) label in - Parsing_syntax.Constr_pat_arg { pat; kind = Labelled_pun label } - } - (* label~ *) - | id=POST_LABEL { - let loc_ = i $loc(id) in - let label = { Parsing_syntax.label_name = id; loc_ } in - let pat = Parsing_util.label_to_pat ~loc_:(Rloc.trim_last_char loc_) label in - Parsing_syntax.Constr_pat_arg { pat; kind = Labelled_pun label } - } - (* pattern *) - | pat=pattern { Parsing_syntax.Constr_pat_arg { pat; kind = Positional } } diff --git a/src/parsing_partial_info.ml b/src/parsing_partial_info.ml index dd8b853..41d310b 100644 --- a/src/parsing_partial_info.ml +++ b/src/parsing_partial_info.ml @@ -15,9 +15,11 @@ type 'a t = Ok of 'a | Partial of 'a * Diagnostics.report list -let take_info (x : 'a t) ~(diagnostics : Diagnostics.t) : 'a = - match x with - | Ok a -> a - | Partial (a, err) -> - List.iter (fun info -> Diagnostics.add_error diagnostics info) err; - a +let take_info (x : 'a t) ~(diagnostics : Diagnostics.t) = + (match x with + | Ok a -> a + | Partial (a, err) -> + Basic_lst.iter err ~f:(fun info -> + Diagnostics.add_error diagnostics info); + a + : 'a) diff --git a/src/parsing_segment.ml b/src/parsing_segment.ml index a38d468..f603445 100644 --- a/src/parsing_segment.ml +++ b/src/parsing_segment.ml @@ -59,91 +59,55 @@ let reset t = t.cur <- t.start let from ~start ~len (vec : Vec_token.t) = { cur = start; tokens = Vec.unsafe_internal_array vec; start; len } -let rec next ?(comment = false) tokens : triple = - if tokens.cur = tokens.start + tokens.len then - let _, _, posb = tokens.tokens.(tokens.cur - 1) in - (EOF, posb, posb) - else - let ((tok, _, _) as triple) = tokens.tokens.(tokens.cur) in - tokens.cur <- tokens.cur + 1; - match tok with - | NEWLINE -> next ~comment tokens - | COMMENT _ when not comment -> next ~comment tokens - | _ -> triple +let rec next ?(comment = false) tokens = + (if tokens.cur = tokens.start + tokens.len then + let _, _, posb = tokens.tokens.(tokens.cur - 1) in + (EOF, posb, posb) + else + let ((tok, _, _) as triple) = tokens.tokens.(tokens.cur) in + tokens.cur <- tokens.cur + 1; + match tok with + | NEWLINE -> next ~comment tokens + | COMMENT _ when not comment -> next ~comment tokens + | _ -> triple + : triple) -let rec next_with_lexbuf_update tokens (lexbuf : Lexing.lexbuf) : - Menhir_token.token = - if tokens.cur = tokens.start + tokens.len then ( - let _, posa, posb = tokens.tokens.(tokens.cur - 1) in - lexbuf.lex_start_p <- posa; - lexbuf.lex_curr_p <- posb; - EOF) - else - let tok, posa, posb = tokens.tokens.(tokens.cur) in - tokens.cur <- tokens.cur + 1; - match tok with - | COMMENT _ | NEWLINE -> next_with_lexbuf_update tokens lexbuf - | _ -> - lexbuf.lex_start_p <- posa; - lexbuf.lex_curr_p <- posb; - tok +let rec next_with_lexbuf_update tokens (lexbuf : Lexing.lexbuf) = + (if tokens.cur = tokens.start + tokens.len then ( + let _, posa, posb = tokens.tokens.(tokens.cur - 1) in + lexbuf.lex_start_p <- posa; + lexbuf.lex_curr_p <- posb; + EOF) + else + let tok, posa, posb = tokens.tokens.(tokens.cur) in + tokens.cur <- tokens.cur + 1; + match tok with + | COMMENT _ | NEWLINE -> next_with_lexbuf_update tokens lexbuf + | _ -> + lexbuf.lex_start_p <- posa; + lexbuf.lex_curr_p <- posb; + tok + : Menhir_token.token) -let peek ?(comment = false) tokens : triple = - let prv = tokens.cur in - let triple = next ~comment tokens in - tokens.cur <- prv; - triple +let peek ?(comment = false) tokens = + (let prv = tokens.cur in + let triple = next ~comment tokens in + tokens.cur <- prv; + triple + : triple) let skip ?(comment = false) tokens = ignore (next ~comment tokens) -let peek_nth tokens n : triple = - let prv = tokens.cur in - let rec loop nth = - let triple = next ~comment:false tokens in - if nth = 0 then triple else loop (nth - 1) - in - let triple = loop n in - tokens.cur <- prv; - triple - -let toplevel_segments ?(start = 0) (tokens : Vec_token.t) : t list = - let rec get_slice_points index (topmost_related_comment : int option) acc = - let tok, loca, _ = Vec.get tokens index in - let left_aligned = loca.pos_cnum = loca.pos_bol in - match tok with - | PUB | PRIV | TYPE | STRUCT | ENUM | FN | LET | CONST | TRAIT | TEST | IMPL - | EXTERN | TYPEALIAS - when left_aligned -> - let point = - match topmost_related_comment with - | Some top_index -> top_index - | None -> index - in - get_slice_points (index + 1) None (point :: acc) - | EOF -> List.rev (index :: acc) - | COMMENT _ -> - let topmost_related_comment = - match topmost_related_comment with - | None when left_aligned -> Some index - | Some _ when not left_aligned -> None - | _ -> topmost_related_comment - in - let next = - if index + 2 < Vec.length tokens then index + 2 else index + 1 - in - get_slice_points next topmost_related_comment acc - | _ -> get_slice_points (index + 1) None acc - in - let rec slice ps = - match ps with - | l :: (r :: _ as remain) -> - if r - l > 0 then - let seg = from ~start:l ~len:(r - l) tokens in - seg :: slice remain - else slice remain - | _ -> [] - in - get_slice_points start None [ start ] |> slice +let peek_nth tokens n = + (let prv = tokens.cur in + let rec loop nth = + let triple = next ~comment:false tokens in + if nth = 0 then triple else loop (nth - 1) + in + let triple = loop n in + tokens.cur <- prv; + triple + : triple) let next_segment_head t = let rec go i = diff --git a/src/parsing_syntax.ml b/src/parsing_syntax.ml index bdf85fa..e80f0f9 100644 --- a/src/parsing_syntax.ml +++ b/src/parsing_syntax.ml @@ -149,6 +149,14 @@ include struct let _ = sexp_of_docstring end +type attribute = Attribute.t + +include struct + let _ = fun (_ : attribute) -> () + let sexp_of_attribute = (Attribute.sexp_of_t : attribute -> S.t) + let _ = sexp_of_attribute +end + type constrid_loc = { lid : Basic_longident.t; loc_ : location; [@sexp_drop_if hide_loc] @@ -178,39 +186,28 @@ include struct let _ = sexp_of_constrid_loc end -type label = { - label_name : string; - loc_ : location; [@sexp_drop_if hide_loc] [@ceh.ignore] -} +type label = { label_name : string; loc_ : location [@sexp_drop_if hide_loc] } include struct let _ = fun (_ : label) -> () - let equal_label = - (fun a__031_ b__032_ -> - if Stdlib.( == ) a__031_ b__032_ then true - else Stdlib.( = ) (a__031_.label_name : string) b__032_.label_name - : label -> label -> bool) - - let _ = equal_label - let sexp_of_label = - (let (drop_if__037_ : location -> Stdlib.Bool.t) = hide_loc in - fun { label_name = label_name__034_; loc_ = loc___038_ } -> - let bnds__033_ = ([] : _ Stdlib.List.t) in - let bnds__033_ = - if drop_if__037_ loc___038_ then bnds__033_ + (let (drop_if__035_ : location -> Stdlib.Bool.t) = hide_loc in + fun { label_name = label_name__032_; loc_ = loc___036_ } -> + let bnds__031_ = ([] : _ Stdlib.List.t) in + let bnds__031_ = + if drop_if__035_ loc___036_ then bnds__031_ else - let arg__040_ = sexp_of_location loc___038_ in - let bnd__039_ = S.List [ S.Atom "loc_"; arg__040_ ] in - (bnd__039_ :: bnds__033_ : _ Stdlib.List.t) + let arg__038_ = sexp_of_location loc___036_ in + let bnd__037_ = S.List [ S.Atom "loc_"; arg__038_ ] in + (bnd__037_ :: bnds__031_ : _ Stdlib.List.t) in - let bnds__033_ = - let arg__035_ = Moon_sexp_conv.sexp_of_string label_name__034_ in - (S.List [ S.Atom "label_name"; arg__035_ ] :: bnds__033_ + let bnds__031_ = + let arg__033_ = Moon_sexp_conv.sexp_of_string label_name__032_ in + (S.List [ S.Atom "label_name"; arg__033_ ] :: bnds__031_ : _ Stdlib.List.t) in - S.List bnds__033_ + S.List bnds__031_ : label -> S.t) let _ = sexp_of_label @@ -225,26 +222,26 @@ include struct let _ = fun (_ : accessor) -> () let sexp_of_accessor = - (let (drop_if__047_ : location -> Stdlib.Bool.t) = hide_loc in + (let (drop_if__045_ : location -> Stdlib.Bool.t) = hide_loc in function - | Label arg0__041_ -> - let res0__042_ = sexp_of_label arg0__041_ in - S.List [ S.Atom "Label"; res0__042_ ] - | Index { tuple_index = tuple_index__044_; loc_ = loc___048_ } -> - let bnds__043_ = ([] : _ Stdlib.List.t) in - let bnds__043_ = - if drop_if__047_ loc___048_ then bnds__043_ + | Label arg0__039_ -> + let res0__040_ = sexp_of_label arg0__039_ in + S.List [ S.Atom "Label"; res0__040_ ] + | Index { tuple_index = tuple_index__042_; loc_ = loc___046_ } -> + let bnds__041_ = ([] : _ Stdlib.List.t) in + let bnds__041_ = + if drop_if__045_ loc___046_ then bnds__041_ else - let arg__050_ = sexp_of_location loc___048_ in - let bnd__049_ = S.List [ S.Atom "loc_"; arg__050_ ] in - (bnd__049_ :: bnds__043_ : _ Stdlib.List.t) + let arg__048_ = sexp_of_location loc___046_ in + let bnd__047_ = S.List [ S.Atom "loc_"; arg__048_ ] in + (bnd__047_ :: bnds__041_ : _ Stdlib.List.t) in - let bnds__043_ = - let arg__045_ = Moon_sexp_conv.sexp_of_int tuple_index__044_ in - (S.List [ S.Atom "tuple_index"; arg__045_ ] :: bnds__043_ + let bnds__041_ = + let arg__043_ = Moon_sexp_conv.sexp_of_int tuple_index__042_ in + (S.List [ S.Atom "tuple_index"; arg__043_ ] :: bnds__041_ : _ Stdlib.List.t) in - S.List (S.Atom "Index" :: bnds__043_) + S.List (S.Atom "Index" :: bnds__041_) | Newtype -> S.Atom "Newtype" : accessor -> S.t) @@ -257,47 +254,60 @@ include struct let _ = fun (_ : constr_name) -> () let sexp_of_constr_name = - (let (drop_if__055_ : location -> Stdlib.Bool.t) = hide_loc in - fun { name = name__052_; loc_ = loc___056_ } -> - let bnds__051_ = ([] : _ Stdlib.List.t) in - let bnds__051_ = - if drop_if__055_ loc___056_ then bnds__051_ + (let (drop_if__053_ : location -> Stdlib.Bool.t) = hide_loc in + fun { name = name__050_; loc_ = loc___054_ } -> + let bnds__049_ = ([] : _ Stdlib.List.t) in + let bnds__049_ = + if drop_if__053_ loc___054_ then bnds__049_ else - let arg__058_ = sexp_of_location loc___056_ in - let bnd__057_ = S.List [ S.Atom "loc_"; arg__058_ ] in - (bnd__057_ :: bnds__051_ : _ Stdlib.List.t) + let arg__056_ = sexp_of_location loc___054_ in + let bnd__055_ = S.List [ S.Atom "loc_"; arg__056_ ] in + (bnd__055_ :: bnds__049_ : _ Stdlib.List.t) in - let bnds__051_ = - let arg__053_ = Moon_sexp_conv.sexp_of_string name__052_ in - (S.List [ S.Atom "name"; arg__053_ ] :: bnds__051_ : _ Stdlib.List.t) + let bnds__049_ = + let arg__051_ = Moon_sexp_conv.sexp_of_string name__050_ in + (S.List [ S.Atom "name"; arg__051_ ] :: bnds__049_ : _ Stdlib.List.t) in - S.List bnds__051_ + S.List bnds__049_ : constr_name -> S.t) let _ = sexp_of_constr_name end -type type_name = { name : longident; loc_ : location [@sexp_drop_if hide_loc] } +type type_name = { + name : longident; + is_object : bool; [@sexp_drop_if fun x -> not x] + loc_ : location; [@sexp_drop_if hide_loc] +} include struct let _ = fun (_ : type_name) -> () let sexp_of_type_name = - (let (drop_if__063_ : location -> Stdlib.Bool.t) = hide_loc in - fun { name = name__060_; loc_ = loc___064_ } -> - let bnds__059_ = ([] : _ Stdlib.List.t) in - let bnds__059_ = - if drop_if__063_ loc___064_ then bnds__059_ + (let (drop_if__061_ : bool -> Stdlib.Bool.t) = fun x -> not x + and (drop_if__066_ : location -> Stdlib.Bool.t) = hide_loc in + fun { name = name__058_; is_object = is_object__062_; loc_ = loc___067_ } + -> + let bnds__057_ = ([] : _ Stdlib.List.t) in + let bnds__057_ = + if drop_if__066_ loc___067_ then bnds__057_ + else + let arg__069_ = sexp_of_location loc___067_ in + let bnd__068_ = S.List [ S.Atom "loc_"; arg__069_ ] in + (bnd__068_ :: bnds__057_ : _ Stdlib.List.t) + in + let bnds__057_ = + if drop_if__061_ is_object__062_ then bnds__057_ else - let arg__066_ = sexp_of_location loc___064_ in - let bnd__065_ = S.List [ S.Atom "loc_"; arg__066_ ] in - (bnd__065_ :: bnds__059_ : _ Stdlib.List.t) + let arg__064_ = Moon_sexp_conv.sexp_of_bool is_object__062_ in + let bnd__063_ = S.List [ S.Atom "is_object"; arg__064_ ] in + (bnd__063_ :: bnds__057_ : _ Stdlib.List.t) in - let bnds__059_ = - let arg__061_ = sexp_of_longident name__060_ in - (S.List [ S.Atom "name"; arg__061_ ] :: bnds__059_ : _ Stdlib.List.t) + let bnds__057_ = + let arg__059_ = sexp_of_longident name__058_ in + (S.List [ S.Atom "name"; arg__059_ ] :: bnds__057_ : _ Stdlib.List.t) in - S.List bnds__059_ + S.List bnds__057_ : type_name -> S.t) let _ = sexp_of_type_name @@ -313,12 +323,12 @@ include struct let sexp_of_constructor_extra_info = (function - | Type_name arg0__067_ -> - let res0__068_ = sexp_of_type_name arg0__067_ in - S.List [ S.Atom "Type_name"; res0__068_ ] - | Package arg0__069_ -> - let res0__070_ = Moon_sexp_conv.sexp_of_string arg0__069_ in - S.List [ S.Atom "Package"; res0__070_ ] + | Type_name arg0__070_ -> + let res0__071_ = sexp_of_type_name arg0__070_ in + S.List [ S.Atom "Type_name"; res0__071_ ] + | Package arg0__072_ -> + let res0__073_ = Moon_sexp_conv.sexp_of_string arg0__072_ in + S.List [ S.Atom "Package"; res0__073_ ] | No_extra_info -> S.Atom "No_extra_info" : constructor_extra_info -> S.t) @@ -335,31 +345,31 @@ include struct let _ = fun (_ : constructor) -> () let sexp_of_constructor = - (let (drop_if__077_ : location -> Stdlib.Bool.t) = hide_loc in + (let (drop_if__080_ : location -> Stdlib.Bool.t) = hide_loc in fun { - constr_name = constr_name__072_; - extra_info = extra_info__074_; - loc_ = loc___078_; + constr_name = constr_name__075_; + extra_info = extra_info__077_; + loc_ = loc___081_; } -> - let bnds__071_ = ([] : _ Stdlib.List.t) in - let bnds__071_ = - if drop_if__077_ loc___078_ then bnds__071_ + let bnds__074_ = ([] : _ Stdlib.List.t) in + let bnds__074_ = + if drop_if__080_ loc___081_ then bnds__074_ else - let arg__080_ = sexp_of_location loc___078_ in - let bnd__079_ = S.List [ S.Atom "loc_"; arg__080_ ] in - (bnd__079_ :: bnds__071_ : _ Stdlib.List.t) + let arg__083_ = sexp_of_location loc___081_ in + let bnd__082_ = S.List [ S.Atom "loc_"; arg__083_ ] in + (bnd__082_ :: bnds__074_ : _ Stdlib.List.t) in - let bnds__071_ = - let arg__075_ = sexp_of_constructor_extra_info extra_info__074_ in - (S.List [ S.Atom "extra_info"; arg__075_ ] :: bnds__071_ + let bnds__074_ = + let arg__078_ = sexp_of_constructor_extra_info extra_info__077_ in + (S.List [ S.Atom "extra_info"; arg__078_ ] :: bnds__074_ : _ Stdlib.List.t) in - let bnds__071_ = - let arg__073_ = sexp_of_constr_name constr_name__072_ in - (S.List [ S.Atom "constr_name"; arg__073_ ] :: bnds__071_ + let bnds__074_ = + let arg__076_ = sexp_of_constr_name constr_name__075_ in + (S.List [ S.Atom "constr_name"; arg__076_ ] :: bnds__074_ : _ Stdlib.List.t) in - S.List bnds__071_ + S.List bnds__074_ : constructor -> S.t) let _ = sexp_of_constructor @@ -371,22 +381,22 @@ include struct let _ = fun (_ : binder) -> () let sexp_of_binder = - (let (drop_if__085_ : location -> Stdlib.Bool.t) = hide_loc in - fun { binder_name = binder_name__082_; loc_ = loc___086_ } -> - let bnds__081_ = ([] : _ Stdlib.List.t) in - let bnds__081_ = - if drop_if__085_ loc___086_ then bnds__081_ + (let (drop_if__088_ : location -> Stdlib.Bool.t) = hide_loc in + fun { binder_name = binder_name__085_; loc_ = loc___089_ } -> + let bnds__084_ = ([] : _ Stdlib.List.t) in + let bnds__084_ = + if drop_if__088_ loc___089_ then bnds__084_ else - let arg__088_ = sexp_of_location loc___086_ in - let bnd__087_ = S.List [ S.Atom "loc_"; arg__088_ ] in - (bnd__087_ :: bnds__081_ : _ Stdlib.List.t) + let arg__091_ = sexp_of_location loc___089_ in + let bnd__090_ = S.List [ S.Atom "loc_"; arg__091_ ] in + (bnd__090_ :: bnds__084_ : _ Stdlib.List.t) in - let bnds__081_ = - let arg__083_ = Moon_sexp_conv.sexp_of_string binder_name__082_ in - (S.List [ S.Atom "binder_name"; arg__083_ ] :: bnds__081_ + let bnds__084_ = + let arg__086_ = Moon_sexp_conv.sexp_of_string binder_name__085_ in + (S.List [ S.Atom "binder_name"; arg__086_ ] :: bnds__084_ : _ Stdlib.List.t) in - S.List bnds__081_ + S.List bnds__084_ : binder -> S.t) let _ = sexp_of_binder @@ -401,22 +411,22 @@ include struct let _ = fun (_ : tvar_constraint) -> () let sexp_of_tvar_constraint = - (let (drop_if__093_ : location -> Stdlib.Bool.t) = hide_loc in - fun { tvc_trait = tvc_trait__090_; loc_ = loc___094_ } -> - let bnds__089_ = ([] : _ Stdlib.List.t) in - let bnds__089_ = - if drop_if__093_ loc___094_ then bnds__089_ + (let (drop_if__096_ : location -> Stdlib.Bool.t) = hide_loc in + fun { tvc_trait = tvc_trait__093_; loc_ = loc___097_ } -> + let bnds__092_ = ([] : _ Stdlib.List.t) in + let bnds__092_ = + if drop_if__096_ loc___097_ then bnds__092_ else - let arg__096_ = sexp_of_location loc___094_ in - let bnd__095_ = S.List [ S.Atom "loc_"; arg__096_ ] in - (bnd__095_ :: bnds__089_ : _ Stdlib.List.t) + let arg__099_ = sexp_of_location loc___097_ in + let bnd__098_ = S.List [ S.Atom "loc_"; arg__099_ ] in + (bnd__098_ :: bnds__092_ : _ Stdlib.List.t) in - let bnds__089_ = - let arg__091_ = sexp_of_longident tvc_trait__090_ in - (S.List [ S.Atom "tvc_trait"; arg__091_ ] :: bnds__089_ + let bnds__092_ = + let arg__094_ = sexp_of_longident tvc_trait__093_ in + (S.List [ S.Atom "tvc_trait"; arg__094_ ] :: bnds__092_ : _ Stdlib.List.t) in - S.List bnds__089_ + S.List bnds__092_ : tvar_constraint -> S.t) let _ = sexp_of_tvar_constraint @@ -431,25 +441,25 @@ include struct let _ = fun (_ : type_decl_binder) -> () let sexp_of_type_decl_binder = - (let (drop_if__101_ : location -> Stdlib.Bool.t) = hide_loc in - fun { tvar_name = tvar_name__098_; loc_ = loc___102_ } -> - let bnds__097_ = ([] : _ Stdlib.List.t) in - let bnds__097_ = - if drop_if__101_ loc___102_ then bnds__097_ + (let (drop_if__104_ : location -> Stdlib.Bool.t) = hide_loc in + fun { tvar_name = tvar_name__101_; loc_ = loc___105_ } -> + let bnds__100_ = ([] : _ Stdlib.List.t) in + let bnds__100_ = + if drop_if__104_ loc___105_ then bnds__100_ else - let arg__104_ = sexp_of_location loc___102_ in - let bnd__103_ = S.List [ S.Atom "loc_"; arg__104_ ] in - (bnd__103_ :: bnds__097_ : _ Stdlib.List.t) + let arg__107_ = sexp_of_location loc___105_ in + let bnd__106_ = S.List [ S.Atom "loc_"; arg__107_ ] in + (bnd__106_ :: bnds__100_ : _ Stdlib.List.t) in - let bnds__097_ = - let arg__099_ = + let bnds__100_ = + let arg__102_ = Moon_sexp_conv.sexp_of_option Moon_sexp_conv.sexp_of_string - tvar_name__098_ + tvar_name__101_ in - (S.List [ S.Atom "tvar_name"; arg__099_ ] :: bnds__097_ + (S.List [ S.Atom "tvar_name"; arg__102_ ] :: bnds__100_ : _ Stdlib.List.t) in - S.List bnds__097_ + S.List bnds__100_ : type_decl_binder -> S.t) let _ = sexp_of_type_decl_binder @@ -465,37 +475,37 @@ include struct let _ = fun (_ : tvar_binder) -> () let sexp_of_tvar_binder = - (let (drop_if__113_ : location -> Stdlib.Bool.t) = hide_loc in + (let (drop_if__116_ : location -> Stdlib.Bool.t) = hide_loc in fun { - tvar_name = tvar_name__106_; - tvar_constraints = tvar_constraints__109_; - loc_ = loc___114_; + tvar_name = tvar_name__109_; + tvar_constraints = tvar_constraints__112_; + loc_ = loc___117_; } -> - let bnds__105_ = ([] : _ Stdlib.List.t) in - let bnds__105_ = - if drop_if__113_ loc___114_ then bnds__105_ + let bnds__108_ = ([] : _ Stdlib.List.t) in + let bnds__108_ = + if drop_if__116_ loc___117_ then bnds__108_ else - let arg__116_ = sexp_of_location loc___114_ in - let bnd__115_ = S.List [ S.Atom "loc_"; arg__116_ ] in - (bnd__115_ :: bnds__105_ : _ Stdlib.List.t) + let arg__119_ = sexp_of_location loc___117_ in + let bnd__118_ = S.List [ S.Atom "loc_"; arg__119_ ] in + (bnd__118_ :: bnds__108_ : _ Stdlib.List.t) in - let bnds__105_ = - if match tvar_constraints__109_ with [] -> true | _ -> false then - bnds__105_ + let bnds__108_ = + if match tvar_constraints__112_ with [] -> true | _ -> false then + bnds__108_ else - let arg__111_ = + let arg__114_ = (Moon_sexp_conv.sexp_of_list sexp_of_tvar_constraint) - tvar_constraints__109_ + tvar_constraints__112_ in - let bnd__110_ = S.List [ S.Atom "tvar_constraints"; arg__111_ ] in - (bnd__110_ :: bnds__105_ : _ Stdlib.List.t) + let bnd__113_ = S.List [ S.Atom "tvar_constraints"; arg__114_ ] in + (bnd__113_ :: bnds__108_ : _ Stdlib.List.t) in - let bnds__105_ = - let arg__107_ = Moon_sexp_conv.sexp_of_string tvar_name__106_ in - (S.List [ S.Atom "tvar_name"; arg__107_ ] :: bnds__105_ + let bnds__108_ = + let arg__110_ = Moon_sexp_conv.sexp_of_string tvar_name__109_ in + (S.List [ S.Atom "tvar_name"; arg__110_ ] :: bnds__108_ : _ Stdlib.List.t) in - S.List bnds__105_ + S.List bnds__108_ : tvar_binder -> S.t) let _ = sexp_of_tvar_binder @@ -507,10 +517,10 @@ include struct let _ = fun (_ : test_name) -> () let sexp_of_test_name = - (fun x__117_ -> + (fun x__120_ -> Moon_sexp_conv.sexp_of_option (Rloc.sexp_of_loced sexp_of_string_literal) - x__117_ + x__120_ : test_name -> S.t) let _ = sexp_of_test_name @@ -546,22 +556,22 @@ include struct let _ = fun (_ : var) -> () let sexp_of_var = - (let (drop_if__122_ : location -> Stdlib.Bool.t) = hide_loc in - fun { var_name = var_name__119_; loc_ = loc___123_ } -> - let bnds__118_ = ([] : _ Stdlib.List.t) in - let bnds__118_ = - if drop_if__122_ loc___123_ then bnds__118_ + (let (drop_if__125_ : location -> Stdlib.Bool.t) = hide_loc in + fun { var_name = var_name__122_; loc_ = loc___126_ } -> + let bnds__121_ = ([] : _ Stdlib.List.t) in + let bnds__121_ = + if drop_if__125_ loc___126_ then bnds__121_ else - let arg__125_ = sexp_of_location loc___123_ in - let bnd__124_ = S.List [ S.Atom "loc_"; arg__125_ ] in - (bnd__124_ :: bnds__118_ : _ Stdlib.List.t) + let arg__128_ = sexp_of_location loc___126_ in + let bnd__127_ = S.List [ S.Atom "loc_"; arg__128_ ] in + (bnd__127_ :: bnds__121_ : _ Stdlib.List.t) in - let bnds__118_ = - let arg__120_ = sexp_of_longident var_name__119_ in - (S.List [ S.Atom "var_name"; arg__120_ ] :: bnds__118_ + let bnds__121_ = + let arg__123_ = sexp_of_longident var_name__122_ in + (S.List [ S.Atom "var_name"; arg__123_ ] :: bnds__121_ : _ Stdlib.List.t) in - S.List bnds__118_ + S.List bnds__121_ : var -> S.t) let _ = sexp_of_var @@ -591,40 +601,40 @@ include struct let sexp_of_argument_kind = (function | Positional -> S.Atom "Positional" - | Labelled arg0__126_ -> - let res0__127_ = sexp_of_label arg0__126_ in - S.List [ S.Atom "Labelled"; res0__127_ ] - | Labelled_pun arg0__128_ -> - let res0__129_ = sexp_of_label arg0__128_ in - S.List [ S.Atom "Labelled_pun"; res0__129_ ] + | Labelled arg0__129_ -> + let res0__130_ = sexp_of_label arg0__129_ in + S.List [ S.Atom "Labelled"; res0__130_ ] + | Labelled_pun arg0__131_ -> + let res0__132_ = sexp_of_label arg0__131_ in + S.List [ S.Atom "Labelled_pun"; res0__132_ ] | Labelled_option - { label = label__131_; question_loc = question_loc__133_ } -> - let bnds__130_ = ([] : _ Stdlib.List.t) in - let bnds__130_ = - let arg__134_ = sexp_of_location question_loc__133_ in - (S.List [ S.Atom "question_loc"; arg__134_ ] :: bnds__130_ + { label = label__134_; question_loc = question_loc__136_ } -> + let bnds__133_ = ([] : _ Stdlib.List.t) in + let bnds__133_ = + let arg__137_ = sexp_of_location question_loc__136_ in + (S.List [ S.Atom "question_loc"; arg__137_ ] :: bnds__133_ : _ Stdlib.List.t) in - let bnds__130_ = - let arg__132_ = sexp_of_label label__131_ in - (S.List [ S.Atom "label"; arg__132_ ] :: bnds__130_ + let bnds__133_ = + let arg__135_ = sexp_of_label label__134_ in + (S.List [ S.Atom "label"; arg__135_ ] :: bnds__133_ : _ Stdlib.List.t) in - S.List (S.Atom "Labelled_option" :: bnds__130_) + S.List (S.Atom "Labelled_option" :: bnds__133_) | Labelled_option_pun - { label = label__136_; question_loc = question_loc__138_ } -> - let bnds__135_ = ([] : _ Stdlib.List.t) in - let bnds__135_ = - let arg__139_ = sexp_of_location question_loc__138_ in - (S.List [ S.Atom "question_loc"; arg__139_ ] :: bnds__135_ + { label = label__139_; question_loc = question_loc__141_ } -> + let bnds__138_ = ([] : _ Stdlib.List.t) in + let bnds__138_ = + let arg__142_ = sexp_of_location question_loc__141_ in + (S.List [ S.Atom "question_loc"; arg__142_ ] :: bnds__138_ : _ Stdlib.List.t) in - let bnds__135_ = - let arg__137_ = sexp_of_label label__136_ in - (S.List [ S.Atom "label"; arg__137_ ] :: bnds__135_ + let bnds__138_ = + let arg__140_ = sexp_of_label label__139_ in + (S.List [ S.Atom "label"; arg__140_ ] :: bnds__138_ : _ Stdlib.List.t) in - S.List (S.Atom "Labelled_option_pun" :: bnds__135_) + S.List (S.Atom "Labelled_option_pun" :: bnds__138_) : argument_kind -> S.t) let _ = sexp_of_argument_kind @@ -649,7 +659,8 @@ include struct let sexp_of_group = (function - | Group_brace -> S.Atom "Group_brace" | Group_paren -> S.Atom "Group_paren" + | Group_brace -> S.Atom "Group_brace" + | Group_paren -> S.Atom "Group_paren" : group -> S.t) let _ = sexp_of_group @@ -670,7 +681,7 @@ include struct let _ = sexp_of_trailing_mark end -type apply_attr = No_attr | Exclamation | Question +type apply_attr = No_attr | Exclamation | Question | Double_exclamation include struct let _ = fun (_ : apply_attr) -> () @@ -680,6 +691,7 @@ include struct | No_attr -> S.Atom "No_attr" | Exclamation -> S.Atom "Exclamation" | Question -> S.Atom "Question" + | Double_exclamation -> S.Atom "Double_exclamation" : apply_attr -> S.t) let _ = sexp_of_apply_attr @@ -688,78 +700,104 @@ end include struct class ['a] iterbase = object - method visit_longident : 'a -> longident -> unit = fun _ _ -> () - method visit_label : 'a -> label -> unit = fun _ _ -> () - method visit_accessor : 'a -> accessor -> unit = fun _ _ -> () - method visit_constructor : 'a -> constructor -> unit = fun _ _ -> () - method visit_constr_name : 'a -> constr_name -> unit = fun _ _ -> () - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () + method visit_longident : 'a -> longident -> unit = fun _ -> fun _ -> () + method visit_label : 'a -> label -> unit = fun _ -> fun _ -> () + method visit_accessor : 'a -> accessor -> unit = fun _ -> fun _ -> () + + method visit_constructor : 'a -> constructor -> unit = + fun _ -> fun _ -> () + + method visit_constr_name : 'a -> constr_name -> unit = + fun _ -> fun _ -> () + + method visit_var : 'a -> var -> unit = fun _ -> fun _ -> () + method visit_binder : 'a -> binder -> unit = fun _ -> fun _ -> () method visit_tvar_constraint : 'a -> tvar_constraint -> unit = - fun _ _ -> () + fun _ -> fun _ -> () - method visit_tvar_binder : 'a -> tvar_binder -> unit = fun _ _ -> () + method visit_tvar_binder : 'a -> tvar_binder -> unit = + fun _ -> fun _ -> () method visit_type_decl_binder : 'a -> type_decl_binder -> unit = - fun _ _ -> () + fun _ -> fun _ -> () + + method visit_constrid_loc : 'a -> constrid_loc -> unit = + fun _ -> fun _ -> () + + method visit_argument_kind : 'a -> argument_kind -> unit = + fun _ -> fun _ -> () - method visit_constrid_loc : 'a -> constrid_loc -> unit = fun _ _ -> () - method visit_argument_kind : 'a -> argument_kind -> unit = fun _ _ -> () - method visit_fn_kind : 'a -> fn_kind -> unit = fun _ _ -> () - method visit_type_name : 'a -> type_name -> unit = fun _ _ -> () + method visit_fn_kind : 'a -> fn_kind -> unit = fun _ -> fun _ -> () + method visit_type_name : 'a -> type_name -> unit = fun _ -> fun _ -> () method private visit_string_literal : 'a -> string_literal -> unit = - fun _ _ -> () + fun _ -> fun _ -> () - method private visit_docstring : 'a -> docstring -> unit = fun _ _ -> () + method private visit_docstring : 'a -> docstring -> unit = + fun _ -> fun _ -> () + + method visit_attribute : 'a -> attribute -> unit = fun _ -> fun _ -> () method private visit_interp_source : 'a -> Literal.interp_source -> unit = - fun _ _ -> () + fun _ -> fun _ -> () - method private visit_hole : 'a -> hole -> unit = fun _ _ -> () + method private visit_hole : 'a -> hole -> unit = fun _ -> fun _ -> () end class ['a] mapbase = object - method visit_longident : 'a -> longident -> longident = fun _ e -> e - method visit_label : 'a -> label -> label = fun _ e -> e - method visit_accessor : 'a -> accessor -> accessor = fun _ e -> e - method visit_constructor : 'a -> constructor -> constructor = fun _ e -> e - method visit_constr_name : 'a -> constr_name -> constr_name = fun _ e -> e - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_binder : 'a -> binder -> binder = fun _ e -> e + method visit_longident : 'a -> longident -> longident = + fun _ -> fun e -> e + + method visit_label : 'a -> label -> label = fun _ -> fun e -> e + method visit_accessor : 'a -> accessor -> accessor = fun _ -> fun e -> e + + method visit_constructor : 'a -> constructor -> constructor = + fun _ -> fun e -> e + + method visit_constr_name : 'a -> constr_name -> constr_name = + fun _ -> fun e -> e + + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e method visit_tvar_constraint : 'a -> tvar_constraint -> tvar_constraint = - fun _ e -> e + fun _ -> fun e -> e method visit_type_decl_binder : 'a -> type_decl_binder -> type_decl_binder = - fun _ e -> e + fun _ -> fun e -> e - method visit_tvar_binder : 'a -> tvar_binder -> tvar_binder = fun _ e -> e + method visit_tvar_binder : 'a -> tvar_binder -> tvar_binder = + fun _ -> fun e -> e method visit_constrid_loc : 'a -> constrid_loc -> constrid_loc = - fun _ e -> e + fun _ -> fun e -> e method visit_argument_kind : 'a -> argument_kind -> argument_kind = - fun _ e -> e + fun _ -> fun e -> e + + method visit_fn_kind : 'a -> fn_kind -> fn_kind = fun _ -> fun e -> e - method visit_fn_kind : 'a -> fn_kind -> fn_kind = fun _ e -> e - method visit_type_name : 'a -> type_name -> type_name = fun _ e -> e + method visit_type_name : 'a -> type_name -> type_name = + fun _ -> fun e -> e - method private visit_string_literal - : 'a -> string_literal -> string_literal = - fun _ e -> e + method private visit_string_literal : + 'a -> string_literal -> string_literal = + fun _ -> fun e -> e method private visit_docstring : 'a -> docstring -> docstring = - fun _ e -> e + fun _ -> fun e -> e - method private visit_interp_source - : 'a -> Literal.interp_source -> Literal.interp_source = - fun _ e -> e + method visit_attribute : 'a -> attribute -> attribute = + fun _ -> fun e -> e - method private visit_hole : 'a -> hole -> hole = fun _ e -> e + method private visit_interp_source : + 'a -> Literal.interp_source -> Literal.interp_source = + fun _ -> fun e -> e + + method private visit_hole : 'a -> hole -> hole = fun _ -> fun e -> e end class ['a] sexpbase = @@ -767,73 +805,81 @@ include struct inherit [_] Sexp_visitors.sexp method visit_location : 'a -> location -> S.t = - fun _ x -> sexp_of_location x + fun _ -> fun x -> sexp_of_location x method visit_absolute_loc : 'a -> absolute_loc -> S.t = - fun _ x -> sexp_of_absolute_loc x + fun _ -> fun x -> sexp_of_absolute_loc x method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x + fun _ -> fun x -> sexp_of_constant x method visit_longident : 'a -> longident -> S.t = - fun _ x -> sexp_of_longident x + fun _ -> fun x -> sexp_of_longident x - method visit_label : 'a -> label -> S.t = fun _ x -> sexp_of_label x + method visit_label : 'a -> label -> S.t = + fun _ -> fun x -> sexp_of_label x method visit_accessor : 'a -> accessor -> S.t = - fun _ x -> sexp_of_accessor x + fun _ -> fun x -> sexp_of_accessor x method visit_constructor : 'a -> constructor -> S.t = - fun _ x -> sexp_of_constructor x + fun _ -> fun x -> sexp_of_constructor x method visit_constr_name : 'a -> constr_name -> S.t = - fun _ x -> sexp_of_constr_name x + fun _ -> fun x -> sexp_of_constr_name x + + method visit_var : 'a -> var -> S.t = fun _ -> fun x -> sexp_of_var x - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x + method visit_binder : 'a -> binder -> S.t = + fun _ -> fun x -> sexp_of_binder x method visit_tvar_constraint : 'a -> tvar_constraint -> S.t = - fun _ x -> sexp_of_tvar_constraint x + fun _ -> fun x -> sexp_of_tvar_constraint x method visit_tvar_binder : 'a -> tvar_binder -> S.t = - fun _ x -> sexp_of_tvar_binder x + fun _ -> fun x -> sexp_of_tvar_binder x method visit_type_decl_binder : 'a -> type_decl_binder -> S.t = - fun _ x -> sexp_of_type_decl_binder x + fun _ -> fun x -> sexp_of_type_decl_binder x method visit_constrid_loc : 'a -> constrid_loc -> S.t = - fun _ x -> sexp_of_constrid_loc x + fun _ -> fun x -> sexp_of_constrid_loc x method visit_argument_kind : 'a -> argument_kind -> S.t = - fun _ x -> sexp_of_argument_kind x + fun _ -> fun x -> sexp_of_argument_kind x - method visit_fn_kind : 'a -> fn_kind -> S.t = fun _ x -> sexp_of_fn_kind x + method visit_fn_kind : 'a -> fn_kind -> S.t = + fun _ -> fun x -> sexp_of_fn_kind x method visit_type_name : 'a -> type_name -> S.t = - fun _ x -> sexp_of_type_name x + fun _ -> fun x -> sexp_of_type_name x method visit_docstring : 'a -> docstring -> S.t = - fun _ x -> sexp_of_docstring x + fun _ -> fun x -> sexp_of_docstring x + + method visit_attribute : 'a -> attribute -> S.t = + fun _ -> fun x -> sexp_of_attribute x method visit_string_literal : 'a -> string_literal -> S.t = - fun _ x -> sexp_of_string_literal x + fun _ -> fun x -> sexp_of_string_literal x method visit_apply_attr : 'a -> apply_attr -> S.t = - fun _ x -> sexp_of_apply_attr x + fun _ -> fun x -> sexp_of_apply_attr x method private visit_test_name : 'a -> test_name -> S.t = - fun _ x -> sexp_of_test_name x + fun _ -> fun x -> sexp_of_test_name x method private visit_group : 'a -> group -> S.t = - fun _ x -> sexp_of_group x + fun _ -> fun x -> sexp_of_group x method private visit_trailing_mark : 'a -> trailing_mark -> S.t = - fun _ x -> sexp_of_trailing_mark x + fun _ -> fun x -> sexp_of_trailing_mark x method private visit_interp_source : 'a -> Literal.interp_source -> S.t = - fun _ x -> Literal.sexp_of_interp_source x + fun _ -> fun x -> Literal.sexp_of_interp_source x - method private visit_hole : 'a -> hole -> S.t = fun _ x -> sexp_of_hole x + method private visit_hole : 'a -> hole -> S.t = + fun _ -> fun x -> sexp_of_hole x end type expr = @@ -880,6 +926,7 @@ include struct loop_cond : expr; loop_body : expr; while_else : expr option; + label : label option; loc_ : location; } | Pexpr_function of { func : func; loc_ : location } @@ -899,10 +946,11 @@ include struct | Pexpr_guard_let of { pat : pattern; expr : expr; - otherwise : (pattern * expr) list option; + otherwise : case list option; body : expr; loc_ : location; } + | Pexpr_is of { expr : expr; pat : pattern; loc_ : location } | Pexpr_letfn of { name : binder; func : func; @@ -920,7 +968,7 @@ include struct body : expr; loc_ : location; } - | Pexpr_sequence of { expr1 : expr; expr2 : expr; loc_ : location } + | Pexpr_sequence of { exprs : expr list; last_expr : expr; loc_ : location } | Pexpr_tuple of { exprs : expr list; loc_ : location } | Pexpr_record of { type_name : type_name option; @@ -958,7 +1006,7 @@ include struct } | Pexpr_match of { expr : expr; - cases : (pattern * expr) list; + cases : case list; match_loc_ : location; loc_ : location; } @@ -980,11 +1028,20 @@ include struct | Pexpr_return of { return_value : expr option; loc_ : location } | Pexpr_raise of { err_value : expr; loc_ : location } | Pexpr_unit of { loc_ : location; faked : bool } - | Pexpr_break of { arg : expr option; loc_ : location } - | Pexpr_continue of { args : expr list; loc_ : location } + | Pexpr_break of { + arg : expr option; + label : label option; + loc_ : location; + } + | Pexpr_continue of { + args : expr list; + label : label option; + loc_ : location; + } | Pexpr_loop of { args : expr list; - body : (pattern list * expr) list; + body : multi_arg_case list; + label : label option; loop_loc_ : location; loc_ : location; } @@ -994,6 +1051,7 @@ include struct continue_block : (binder * expr) list; body : expr; for_else : expr option; + label : label option; loc_ : location; } | Pexpr_foreach of { @@ -1001,13 +1059,14 @@ include struct expr : expr; body : expr; else_block : expr option; + label : label option; loc_ : location; } | Pexpr_try of { body : expr; - catch : (pattern * expr) list; + catch : case list; catch_all : bool; - try_else : (pattern * expr) list option; + try_else : case list option; try_loc_ : location; catch_loc_ : location; else_loc_ : location; @@ -1027,17 +1086,12 @@ include struct and argument = { arg_value : expr; arg_kind : argument_kind } and parameters = parameter list - and parameter = { - param_binder : binder; - param_annot : typ option; - param_kind : parameter_kind; - } - - and parameter_kind = - | Positional - | Labelled - | Optional of { default : expr } - | Question_optional + and parameter = + | Discard_positional of { ty : typ option; loc_ : location } + | Positional of { binder : binder; ty : typ option } + | Labelled of { binder : binder; ty : typ option } + | Optional of { binder : binder; default : expr; ty : typ option } + | Question_optional of { binder : binder; ty : typ option } and func = | Lambda of { @@ -1046,15 +1100,25 @@ include struct body : expr; return_type : (typ * error_typ) option; kind_ : fn_kind; - has_error : bool; + has_error : location option; + is_async : bool; } | Match of { - cases : (pattern list * expr) list; - has_error : bool; + cases : multi_arg_case list; + has_error : location option; + is_async : bool; fn_loc_ : location; loc_ : location; } + and case = { pattern : pattern; guard : expr option; body : expr } + + and multi_arg_case = { + patterns : pattern list; + guard : expr option; + body : expr; + } + and spreadable_elem = | Elem_regular of expr | Elem_spread of { expr : expr; loc_ : location } @@ -1078,6 +1142,7 @@ include struct ty_arg : typ list; ty_res : typ; ty_err : error_typ; + is_async : bool; loc_ : location; } | Ptype_tuple of { tys : typ list; loc_ : location } @@ -1087,11 +1152,12 @@ include struct loc_ : location; } | Ptype_option of { ty : typ; loc_ : location; question_loc : location } + | Ptype_object of constrid_loc and pattern = | Ppat_alias of { pat : pattern; alias : binder; loc_ : location } | Ppat_any of { loc_ : location } - | Ppat_array of { pats : array_pattern; loc_ : location } + | Ppat_array of { pats : array_patterns; loc_ : location } | Ppat_constant of { c : constant; loc_ : location } | Ppat_constraint of { pat : pattern; ty : typ; loc_ : location } | Ppat_constr of { @@ -1108,7 +1174,11 @@ include struct is_closed : bool; loc_ : location; } - | Ppat_map of { elems : map_pat_elem list; loc_ : location } + | Ppat_map of { + elems : map_pat_elem list; + is_closed : bool; + loc_ : location; + } | Ppat_range of { lhs : pattern; rhs : pattern; @@ -1116,9 +1186,18 @@ include struct loc_ : location; } + and array_patterns = + | Closed of array_pattern list + | Open of array_pattern list * array_pattern list * binder option + and array_pattern = - | Closed of pattern list - | Open of pattern list * pattern list * binder option + | Pattern of pattern + | String_spread of string_literal + | String_spread_const of { + binder : binder; + pkg : string option; + loc_ : location; + } and field_def = | Field_def of { @@ -1157,6 +1236,7 @@ include struct and constr_decl = { constr_name : constr_name; constr_args : constr_param list option; + constr_tag : (string * location) option; constr_loc_ : location; } @@ -1177,6 +1257,7 @@ include struct and type_desc = | Ptd_abstract + | Ptd_extern | Ptd_newtype of typ | Ptd_error of exception_decl | Ptd_variant of constr_decl list @@ -1188,6 +1269,7 @@ include struct tycon_loc_ : location; params : type_decl_binder list; components : type_desc; + attrs : attribute list; mutable doc_ : docstring; type_vis : visibility; deriving_ : deriving_directive list; @@ -1196,8 +1278,9 @@ include struct and local_type_decl = { local_tycon : string; - local_tycon_loc_ : location; [@dead "local_type_decl.local_tycon_loc_"] + local_tycon_loc_ : location; local_components : type_desc; + deriving_ : deriving_directive list; } and deriving_directive = { @@ -1226,12 +1309,14 @@ include struct and fun_decl = { type_name : type_name option; name : binder; - has_error : bool; + has_error : location option; + is_async : bool; decl_params : parameters option; params_loc_ : location; quantifiers : tvar_binder list; return_type : (typ * error_typ) option; - is_pub : bool; + vis : visibility; + attrs : attribute list; mutable doc_ : docstring; } @@ -1253,6 +1338,7 @@ include struct trait_methods : trait_method_decl list; trait_vis : visibility; trait_loc_ : absolute_loc; + trait_attrs : attribute list; mutable trait_doc_ : docstring; } @@ -1269,6 +1355,8 @@ include struct params : parameters option; local_types : local_type_decl list; loc_ : absolute_loc; + attrs : attribute list; + mutable doc_ : docstring; } | Ptop_typedef of type_decl | Ptop_funcdef of { @@ -1280,12 +1368,21 @@ include struct binder : binder; ty : typ option; expr : expr; - is_pub : bool; + vis : visibility; is_constant : bool; loc_ : absolute_loc; + attrs : attribute list; mutable doc_ : docstring; } | Ptop_trait of trait_decl + | Ptop_trait_alias of { + binder : binder; + target : type_name; + vis : visibility; + loc_ : absolute_loc; + attrs : attribute list; + mutable doc_ : docstring; + } | Ptop_impl of { self_ty : typ option; trait : type_name; @@ -1294,11 +1391,11 @@ include struct quantifiers : tvar_binder list; params : parameters; ret_ty : (typ * error_typ) option; - body : expr; - is_pub : bool; - local_types : local_type_decl list; + body : decl_body; + vis : visibility; loc_ : absolute_loc; header_loc_ : location; + attrs : attribute list; mutable doc_ : docstring; } | Ptop_impl_relation of { @@ -1328,2601 +1425,3351 @@ include struct object (self : 'self) inherit [_] sexpbase - method visit_Pexpr_apply - : _ -> expr -> argument list -> apply_attr -> location -> S.t = - fun env _visitors_ffunc _visitors_fargs _visitors_fattr - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - self#visit_list self#visit_argument env _visitors_fargs - in - let _visitors_r2 = self#visit_apply_attr env _visitors_fattr in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_apply" - [ - ("func", _visitors_r0); - ("args", _visitors_r1); - ("attr", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_Pexpr_apply : + _ -> expr -> argument list -> apply_attr -> location -> S.t = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + self#visit_list self#visit_argument env _visitors_fargs + in + let _visitors_r2 = self#visit_apply_attr env _visitors_fattr in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_apply" + [ + ("func", _visitors_r0); + ("args", _visitors_r1); + ("attr", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Pexpr_infix : _ -> var -> expr -> expr -> location -> S.t = - fun env _visitors_fop _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_flhs in - let _visitors_r2 = self#visit_expr env _visitors_frhs in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_infix" - [ - ("op", _visitors_r0); - ("lhs", _visitors_r1); - ("rhs", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fop -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_flhs in + let _visitors_r2 = self#visit_expr env _visitors_frhs in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_infix" + [ + ("op", _visitors_r0); + ("lhs", _visitors_r1); + ("rhs", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Pexpr_unary : _ -> var -> expr -> location -> S.t = - fun env _visitors_fop _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_unary" - [ - ("op", _visitors_r0); - ("expr", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fop -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_unary" + [ + ("op", _visitors_r0); + ("expr", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Pexpr_array : _ -> expr list -> location -> S.t = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array" - [ ("exprs", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_array_spread - : _ -> spreadable_elem list -> location -> S.t = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_spreadable_elem env _visitors_felems - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array_spread" - [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array" + [ ("exprs", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Pexpr_array_spread : + _ -> spreadable_elem list -> location -> S.t = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_spreadable_elem env _visitors_felems + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array_spread" + [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_array_get : _ -> expr -> expr -> location -> S.t = - fun env _visitors_farray _visitors_findex _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array_get" - [ - ("array", _visitors_r0); - ("index", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pexpr_array_get_slice - : _ -> - expr -> - expr option -> - expr option -> - location -> - location -> - S.t = - fun env _visitors_farray _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = - self#visit_option self#visit_expr env _visitors_fstart_index - in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fend_index - in - let _visitors_r3 = self#visit_location env _visitors_findex_loc_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array_get_slice" - [ - ("array", _visitors_r0); - ("start_index", _visitors_r1); - ("end_index", _visitors_r2); - ("index_loc_", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Pexpr_array_set - : _ -> expr -> expr -> expr -> location -> S.t = - fun env _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = self#visit_expr env _visitors_fvalue in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array_set" - [ - ("array", _visitors_r0); - ("index", _visitors_r1); - ("value", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_array_augmented_set - : _ -> var -> expr -> expr -> expr -> location -> S.t = - fun env _visitors_fop _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_farray in - let _visitors_r2 = self#visit_expr env _visitors_findex in - let _visitors_r3 = self#visit_expr env _visitors_fvalue in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_array_augmented_set" - [ - ("op", _visitors_r0); - ("array", _visitors_r1); - ("index", _visitors_r2); - ("value", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array_get" + [ + ("array", _visitors_r0); + ("index", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_array_get_slice : + _ -> + expr -> + expr option -> + expr option -> + location -> + location -> + S.t = + fun env -> + fun _visitors_farray -> + fun _visitors_fstart_index -> + fun _visitors_fend_index -> + fun _visitors_findex_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_fstart_index + in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fend_index + in + let _visitors_r3 = + self#visit_location env _visitors_findex_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array_get_slice" + [ + ("array", _visitors_r0); + ("start_index", _visitors_r1); + ("end_index", _visitors_r2); + ("index_loc_", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Pexpr_array_set : + _ -> expr -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = self#visit_expr env _visitors_fvalue in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array_set" + [ + ("array", _visitors_r0); + ("index", _visitors_r1); + ("value", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_array_augmented_set : + _ -> var -> expr -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_fop -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_farray in + let _visitors_r2 = self#visit_expr env _visitors_findex in + let _visitors_r3 = self#visit_expr env _visitors_fvalue in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_array_augmented_set" + [ + ("op", _visitors_r0); + ("array", _visitors_r1); + ("index", _visitors_r2); + ("value", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_Pexpr_constant : _ -> constant -> location -> S.t = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_constant" - [ ("c", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_multiline_string - : _ -> multiline_string_elem list -> location -> S.t = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_multiline_string_elem env - _visitors_felems - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_multiline_string" - [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_constant" + [ ("c", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Pexpr_multiline_string : + _ -> multiline_string_elem list -> location -> S.t = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_multiline_string_elem env + _visitors_felems + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_multiline_string" + [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_interp : _ -> interp_elem list -> location -> S.t = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_interp_elem env _visitors_felems - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_interp" - [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_interp_elem env _visitors_felems + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_interp" + [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_constraint : _ -> expr -> typ -> location -> S.t = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_constraint" - [ - ("expr", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_constraint" + [ + ("expr", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Pexpr_constr : _ -> constructor -> location -> S.t = - fun env _visitors_fconstr _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_constr" - [ ("constr", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_while - : _ -> expr -> expr -> expr option -> location -> S.t = - fun env _visitors_floop_cond _visitors_floop_body - _visitors_fwhile_else _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fwhile_else - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_while" - [ - ("loop_cond", _visitors_r0); - ("loop_body", _visitors_r1); - ("while_else", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fconstr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constructor env _visitors_fconstr in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_constr" + [ ("constr", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Pexpr_while : + _ -> expr -> expr -> expr option -> label option -> location -> S.t + = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fwhile_else + in + let _visitors_r3 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_while" + [ + ("loop_cond", _visitors_r0); + ("loop_body", _visitors_r1); + ("while_else", _visitors_r2); + ("label", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_Pexpr_function : _ -> func -> location -> S.t = - fun env _visitors_ffunc _visitors_floc_ -> - let _visitors_r0 = self#visit_func env _visitors_ffunc in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_function" - [ ("func", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_ffunc -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_func env _visitors_ffunc in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_function" + [ ("func", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_ident : _ -> var -> location -> S.t = - fun env _visitors_fid _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_ident" - [ ("id", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_if - : _ -> expr -> expr -> expr option -> location -> S.t = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fifnot - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_if" - [ - ("cond", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_guard - : _ -> expr -> expr option -> expr -> location -> S.t = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - self#visit_option self#visit_expr env _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_guard" - [ - ("cond", _visitors_r0); - ("otherwise", _visitors_r1); - ("body", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_guard_let - : _ -> - pattern -> - expr -> - (pattern * expr) list option -> - expr -> - location -> - S.t = - fun env _visitors_fpat _visitors_fexpr _visitors_fotherwise - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - self#visit_option - (self#visit_list (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ])) - env _visitors_fotherwise - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_guard_let" - [ - ("pat", _visitors_r0); - ("expr", _visitors_r1); - ("otherwise", _visitors_r2); - ("body", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Pexpr_letfn - : _ -> binder -> func -> expr -> location -> S.t = - fun env _visitors_fname _visitors_ffunc _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_func env _visitors_ffunc in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_letfn" - [ - ("name", _visitors_r0); - ("func", _visitors_r1); - ("body", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_letrec - : _ -> (binder * func) list -> expr -> location -> S.t = - fun env _visitors_fbindings _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_func env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_letrec" - [ - ("bindings", _visitors_r0); - ("body", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fid -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_ident" + [ ("id", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Pexpr_if : + _ -> expr -> expr -> expr option -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fifnot + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_if" + [ + ("cond", _visitors_r0); + ("ifso", _visitors_r1); + ("ifnot", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_guard : + _ -> expr -> expr option -> expr -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_guard" + [ + ("cond", _visitors_r0); + ("otherwise", _visitors_r1); + ("body", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_guard_let : + _ -> pattern -> expr -> case list option -> expr -> location -> S.t + = + fun env -> + fun _visitors_fpat -> + fun _visitors_fexpr -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + self#visit_option + (self#visit_list self#visit_case) + env _visitors_fotherwise + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_guard_let" + [ + ("pat", _visitors_r0); + ("expr", _visitors_r1); + ("otherwise", _visitors_r2); + ("body", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Pexpr_is : _ -> expr -> pattern -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_is" + [ + ("expr", _visitors_r0); + ("pat", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_letfn : + _ -> binder -> func -> expr -> location -> S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_ffunc -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_func env _visitors_ffunc in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_letfn" + [ + ("name", _visitors_r0); + ("func", _visitors_r1); + ("body", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_letrec : + _ -> (binder * func) list -> expr -> location -> S.t = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_func env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_letrec" + [ + ("bindings", _visitors_r0); + ("body", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Pexpr_let : _ -> pattern -> expr -> expr -> location -> S.t = - fun env _visitors_fpattern _visitors_fexpr _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpattern in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_let" - [ - ("pattern", _visitors_r0); - ("expr", _visitors_r1); - ("body", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_sequence : _ -> expr -> expr -> location -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_sequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fpattern -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpattern in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_let" + [ + ("pattern", _visitors_r0); + ("expr", _visitors_r1); + ("body", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_sequence : _ -> expr list -> expr -> location -> S.t + = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_sequence" + [ + ("exprs", _visitors_r0); + ("last_expr", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Pexpr_tuple : _ -> expr list -> location -> S.t = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_tuple" - [ ("exprs", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_record - : _ -> - type_name option -> - field_def list -> - trailing_mark -> - location -> - S.t = - fun env _visitors_ftype_name _visitors_ffields _visitors_ftrailing - _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_type_name env _visitors_ftype_name - in - let _visitors_r1 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r2 = - self#visit_trailing_mark env _visitors_ftrailing - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_record" - [ - ("type_name", _visitors_r0); - ("fields", _visitors_r1); - ("trailing", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_record_update - : _ -> type_name option -> expr -> field_def list -> location -> S.t - = - fun env _visitors_ftype_name _visitors_frecord _visitors_ffields - _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_type_name env _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_record_update" - [ - ("type_name", _visitors_r0); - ("record", _visitors_r1); - ("fields", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_tuple" + [ ("exprs", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Pexpr_record : + _ -> + type_name option -> + field_def list -> + trailing_mark -> + location -> + S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_ftrailing -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r2 = + self#visit_trailing_mark env _visitors_ftrailing + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_record" + [ + ("type_name", _visitors_r0); + ("fields", _visitors_r1); + ("trailing", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_record_update : + _ -> type_name option -> expr -> field_def list -> location -> S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_record_update" + [ + ("type_name", _visitors_r0); + ("record", _visitors_r1); + ("fields", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Pexpr_field : _ -> expr -> accessor -> location -> S.t = - fun env _visitors_frecord _visitors_faccessor _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_field" - [ - ("record", _visitors_r0); - ("accessor", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_field" + [ + ("record", _visitors_r0); + ("accessor", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Pexpr_method : _ -> type_name -> label -> location -> S.t = - fun env _visitors_ftype_name _visitors_fmethod_name _visitors_floc_ -> - let _visitors_r0 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_method" - [ - ("type_name", _visitors_r0); - ("method_name", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pexpr_dot_apply - : _ -> - expr -> - label -> - argument list -> - bool -> - apply_attr -> - location -> - S.t = - fun env _visitors_fself _visitors_fmethod_name _visitors_fargs - _visitors_freturn_self _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fself in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = - self#visit_list self#visit_argument env _visitors_fargs - in - let _visitors_r3 = self#visit_bool env _visitors_freturn_self in - let _visitors_r4 = self#visit_apply_attr env _visitors_fattr in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_dot_apply" - [ - ("self", _visitors_r0); - ("method_name", _visitors_r1); - ("args", _visitors_r2); - ("return_self", _visitors_r3); - ("attr", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fmethod_name -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r1 = self#visit_label env _visitors_fmethod_name in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_method" + [ + ("type_name", _visitors_r0); + ("method_name", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_dot_apply : + _ -> + expr -> + label -> + argument list -> + bool -> + apply_attr -> + location -> + S.t = + fun env -> + fun _visitors_fself -> + fun _visitors_fmethod_name -> + fun _visitors_fargs -> + fun _visitors_freturn_self -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fself in + let _visitors_r1 = + self#visit_label env _visitors_fmethod_name + in + let _visitors_r2 = + self#visit_list self#visit_argument env _visitors_fargs + in + let _visitors_r3 = + self#visit_bool env _visitors_freturn_self + in + let _visitors_r4 = + self#visit_apply_attr env _visitors_fattr + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_dot_apply" + [ + ("self", _visitors_r0); + ("method_name", _visitors_r1); + ("args", _visitors_r2); + ("return_self", _visitors_r3); + ("attr", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_Pexpr_as : _ -> expr -> type_name -> location -> S.t = - fun env _visitors_fexpr _visitors_ftrait _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_as" - [ - ("expr", _visitors_r0); - ("trait", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pexpr_mutate - : _ -> expr -> accessor -> expr -> var option -> location -> S.t = - fun env _visitors_frecord _visitors_faccessor _visitors_ffield - _visitors_faugmented_by _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - self#visit_option self#visit_var env _visitors_faugmented_by - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_mutate" - [ - ("record", _visitors_r0); - ("accessor", _visitors_r1); - ("field", _visitors_r2); - ("augmented_by", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Pexpr_match - : _ -> expr -> (pattern * expr) list -> location -> location -> S.t - = - fun env _visitors_fexpr _visitors_fcases _visitors_fmatch_loc_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r2 = self#visit_location env _visitors_fmatch_loc_ in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_match" - [ - ("expr", _visitors_r0); - ("cases", _visitors_r1); - ("match_loc_", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_letmut - : _ -> binder -> typ option -> expr -> expr -> location -> S.t = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_letmut" - [ - ("binder", _visitors_r0); - ("ty", _visitors_r1); - ("expr", _visitors_r2); - ("body", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_as" + [ + ("expr", _visitors_r0); + ("trait", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_mutate : + _ -> expr -> accessor -> expr -> var option -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_ffield -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + self#visit_option self#visit_var env _visitors_faugmented_by + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_mutate" + [ + ("record", _visitors_r0); + ("accessor", _visitors_r1); + ("field", _visitors_r2); + ("augmented_by", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Pexpr_match : + _ -> expr -> case list -> location -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_list self#visit_case env _visitors_fcases + in + let _visitors_r2 = + self#visit_location env _visitors_fmatch_loc_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_match" + [ + ("expr", _visitors_r0); + ("cases", _visitors_r1); + ("match_loc_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Pexpr_letmut : + _ -> binder -> typ option -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_letmut" + [ + ("binder", _visitors_r0); + ("ty", _visitors_r1); + ("expr", _visitors_r2); + ("body", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_Pexpr_pipe : _ -> expr -> expr -> location -> S.t = - fun env _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_pipe" - [ - ("lhs", _visitors_r0); - ("rhs", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pexpr_assign - : _ -> var -> expr -> var option -> location -> S.t = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - self#visit_option self#visit_var env _visitors_faugmented_by - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_assign" - [ - ("var", _visitors_r0); - ("expr", _visitors_r1); - ("augmented_by", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_pipe" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_assign : + _ -> var -> expr -> var option -> location -> S.t = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + self#visit_option self#visit_var env _visitors_faugmented_by + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_assign" + [ + ("var", _visitors_r0); + ("expr", _visitors_r1); + ("augmented_by", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Pexpr_hole : _ -> location -> hole -> S.t = - fun env _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - let _visitors_r1 = self#visit_hole env _visitors_fkind in - self#visit_inline_record env "Pexpr_hole" - [ ("loc_", _visitors_r0); ("kind", _visitors_r1) ] + fun env -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + let _visitors_r1 = self#visit_hole env _visitors_fkind in + self#visit_inline_record env "Pexpr_hole" + [ ("loc_", _visitors_r0); ("kind", _visitors_r1) ] method visit_Pexpr_return : _ -> expr option -> location -> S.t = - fun env _visitors_freturn_value _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_freturn_value - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_return" - [ ("return_value", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_freturn_value -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_freturn_value + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_return" + [ ("return_value", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_raise : _ -> expr -> location -> S.t = - fun env _visitors_ferr_value _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferr_value in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_raise" - [ ("err_value", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_ferr_value -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferr_value in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_raise" + [ ("err_value", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_unit : _ -> location -> bool -> S.t = - fun env _visitors_floc_ _visitors_ffaked -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - let _visitors_r1 = self#visit_bool env _visitors_ffaked in - self#visit_inline_record env "Pexpr_unit" - [ ("loc_", _visitors_r0); ("faked", _visitors_r1) ] - - method visit_Pexpr_break : _ -> expr option -> location -> S.t = - fun env _visitors_farg _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_farg - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_break" - [ ("arg", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_continue : _ -> expr list -> location -> S.t = - fun env _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_continue" - [ ("args", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Pexpr_loop - : _ -> - expr list -> - (pattern list * expr) list -> - location -> - location -> - S.t = - fun env _visitors_fargs _visitors_fbody _visitors_floop_loc_ - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> + fun env -> + fun _visitors_floc_ -> + fun _visitors_ffaked -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + let _visitors_r1 = self#visit_bool env _visitors_ffaked in + self#visit_inline_record env "Pexpr_unit" + [ ("loc_", _visitors_r0); ("faked", _visitors_r1) ] + + method visit_Pexpr_break : + _ -> expr option -> label option -> location -> S.t = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_farg + in + let _visitors_r1 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_break" + [ + ("arg", _visitors_r0); + ("label", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_continue : + _ -> expr list -> label option -> location -> S.t = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r1 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_continue" + [ + ("args", _visitors_r0); + ("label", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_loop : + _ -> + expr list -> + multi_arg_case list -> + label option -> + location -> + location -> + S.t = + fun env -> + fun _visitors_fargs -> + fun _visitors_fbody -> + fun _visitors_flabel -> + fun _visitors_floop_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r1 = + self#visit_list self#visit_multi_arg_case env _visitors_fbody + in + let _visitors_r2 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r3 = + self#visit_location env _visitors_floop_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_loop" + [ + ("args", _visitors_r0); + ("body", _visitors_r1); + ("label", _visitors_r2); + ("loop_loc_", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Pexpr_for : + _ -> + (binder * expr) list -> + expr option -> + (binder * expr) list -> + expr -> + expr option -> + label option -> + location -> + S.t = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fcontinue_block -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbinders + in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_fcondition + in + let _visitors_r2 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fcontinue_block + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + self#visit_option self#visit_expr env _visitors_ffor_else + in + let _visitors_r5 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_for" + [ + ("binders", _visitors_r0); + ("condition", _visitors_r1); + ("continue_block", _visitors_r2); + ("body", _visitors_r3); + ("for_else", _visitors_r4); + ("label", _visitors_r5); + ("loc_", _visitors_r6); + ] + + method visit_Pexpr_foreach : + _ -> + binder option list -> + expr -> + expr -> + expr option -> + label option -> + location -> + S.t = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_flabel -> + fun _visitors_floc_ -> let _visitors_r0 = - self#visit_list self#visit_pattern env _visitors_c0 + self#visit_list + (self#visit_option self#visit_binder) + env _visitors_fbinders in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbody - in - let _visitors_r2 = self#visit_location env _visitors_floop_loc_ in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_loop" - [ - ("args", _visitors_r0); - ("body", _visitors_r1); - ("loop_loc_", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Pexpr_for - : _ -> - (binder * expr) list -> - expr option -> - (binder * expr) list -> - expr -> - expr option -> - location -> - S.t = - fun env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbinders - in - let _visitors_r1 = - self#visit_option self#visit_expr env _visitors_fcondition - in - let _visitors_r2 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcontinue_block - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - self#visit_option self#visit_expr env _visitors_ffor_else - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_for" - [ - ("binders", _visitors_r0); - ("condition", _visitors_r1); - ("continue_block", _visitors_r2); - ("body", _visitors_r3); - ("for_else", _visitors_r4); - ("loc_", _visitors_r5); - ] - - method visit_Pexpr_foreach - : _ -> - binder option list -> - expr -> - expr -> - expr option -> - location -> - S.t = - fun env _visitors_fbinders _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (self#visit_option self#visit_binder) - env _visitors_fbinders - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - self#visit_option self#visit_expr env _visitors_felse_block - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_foreach" - [ - ("binders", _visitors_r0); - ("expr", _visitors_r1); - ("body", _visitors_r2); - ("else_block", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Pexpr_try - : _ -> - expr -> - (pattern * expr) list -> - bool -> - (pattern * expr) list option -> - location -> - location -> - location -> - location -> - S.t = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_ftry_loc_ _visitors_fcatch_loc_ - _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcatch - in - let _visitors_r2 = self#visit_bool env _visitors_fcatch_all in - let _visitors_r3 = - self#visit_option - (self#visit_list (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ])) - env _visitors_ftry_else - in - let _visitors_r4 = self#visit_location env _visitors_ftry_loc_ in - let _visitors_r5 = self#visit_location env _visitors_fcatch_loc_ in - let _visitors_r6 = self#visit_location env _visitors_felse_loc_ in - let _visitors_r7 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_try" - [ - ("body", _visitors_r0); - ("catch", _visitors_r1); - ("catch_all", _visitors_r2); - ("try_else", _visitors_r3); - ("try_loc_", _visitors_r4); - ("catch_loc_", _visitors_r5); - ("else_loc_", _visitors_r6); - ("loc_", _visitors_r7); - ] + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + self#visit_option self#visit_expr env _visitors_felse_block + in + let _visitors_r4 = + self#visit_option self#visit_label env _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_foreach" + [ + ("binders", _visitors_r0); + ("expr", _visitors_r1); + ("body", _visitors_r2); + ("else_block", _visitors_r3); + ("label", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Pexpr_try : + _ -> + expr -> + case list -> + bool -> + case list option -> + location -> + location -> + location -> + location -> + S.t = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_ftry_loc_ -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = + self#visit_list self#visit_case env _visitors_fcatch + in + let _visitors_r2 = + self#visit_bool env _visitors_fcatch_all + in + let _visitors_r3 = + self#visit_option + (self#visit_list self#visit_case) + env _visitors_ftry_else + in + let _visitors_r4 = + self#visit_location env _visitors_ftry_loc_ + in + let _visitors_r5 = + self#visit_location env _visitors_fcatch_loc_ + in + let _visitors_r6 = + self#visit_location env _visitors_felse_loc_ + in + let _visitors_r7 = + self#visit_location env _visitors_floc_ + in + self#visit_inline_record env "Pexpr_try" + [ + ("body", _visitors_r0); + ("catch", _visitors_r1); + ("catch_all", _visitors_r2); + ("try_else", _visitors_r3); + ("try_loc_", _visitors_r4); + ("catch_loc_", _visitors_r5); + ("else_loc_", _visitors_r6); + ("loc_", _visitors_r7); + ] method visit_Pexpr_map : _ -> map_expr_elem list -> location -> S.t = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_map_expr_elem env _visitors_felems - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_map" - [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_map_expr_elem env _visitors_felems + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_map" + [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Pexpr_group : _ -> expr -> group -> location -> S.t = - fun env _visitors_fexpr _visitors_fgroup _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_group env _visitors_fgroup in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pexpr_group" - [ - ("expr", _visitors_r0); - ("group", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pexpr_static_assert - : _ -> static_assertion list -> expr -> S.t = - fun env _visitors_fasserts _visitors_fbody -> - let _visitors_r0 = - self#visit_list self#visit_static_assertion env _visitors_fasserts - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - self#visit_inline_record env "Pexpr_static_assert" - [ ("asserts", _visitors_r0); ("body", _visitors_r1) ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_fgroup -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_group env _visitors_fgroup in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pexpr_group" + [ + ("expr", _visitors_r0); + ("group", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Pexpr_static_assert : + _ -> static_assertion list -> expr -> S.t = + fun env -> + fun _visitors_fasserts -> + fun _visitors_fbody -> + let _visitors_r0 = + self#visit_list self#visit_static_assertion env + _visitors_fasserts + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + self#visit_inline_record env "Pexpr_static_assert" + [ ("asserts", _visitors_r0); ("body", _visitors_r1) ] method visit_expr : _ -> expr -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Pexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fattr _visitors_floc_ - | Pexpr_infix - { - op = _visitors_fop; - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_infix env _visitors_fop _visitors_flhs - _visitors_frhs _visitors_floc_ - | Pexpr_unary - { - op = _visitors_fop; - expr = _visitors_fexpr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr - _visitors_floc_ - | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ - | Pexpr_array_spread - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_array_spread env _visitors_felems - _visitors_floc_ - | Pexpr_array_get - { - array = _visitors_farray; - index = _visitors_findex; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get env _visitors_farray _visitors_findex - _visitors_floc_ - | Pexpr_array_get_slice - { - array = _visitors_farray; - start_index = _visitors_fstart_index; - end_index = _visitors_fend_index; - index_loc_ = _visitors_findex_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get_slice env _visitors_farray - _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ - | Pexpr_array_set - { - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_set env _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ - | Pexpr_array_augmented_set - { - op = _visitors_fop; - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_augmented_set env _visitors_fop - _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ - | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ - | Pexpr_multiline_string - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_multiline_string env _visitors_felems - _visitors_floc_ - | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ - | Pexpr_constraint - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty - _visitors_floc_ - | Pexpr_constr - { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ - | Pexpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_floc_ - | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ - | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ - | Pexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_floc_ - | Pexpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_floc_ - | Pexpr_guard_let - { - pat = _visitors_fpat; - expr = _visitors_fexpr; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr - _visitors_fotherwise _visitors_fbody _visitors_floc_ - | Pexpr_letfn - { - name = _visitors_fname; - func = _visitors_ffunc; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc - _visitors_fbody _visitors_floc_ - | Pexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_floc_ - | Pexpr_let - { - pattern = _visitors_fpattern; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr - _visitors_fbody _visitors_floc_ - | Pexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_floc_ - | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ - | Pexpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - trailing = _visitors_ftrailing; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record env _visitors_ftype_name - _visitors_ffields _visitors_ftrailing _visitors_floc_ - | Pexpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - fields = _visitors_ffields; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_ffields _visitors_floc_ - | Pexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_field env _visitors_frecord _visitors_faccessor - _visitors_floc_ - | Pexpr_method - { - type_name = _visitors_ftype_name; - method_name = _visitors_fmethod_name; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_method env _visitors_ftype_name - _visitors_fmethod_name _visitors_floc_ - | Pexpr_dot_apply - { - self = _visitors_fself; - method_name = _visitors_fmethod_name; - args = _visitors_fargs; - return_self = _visitors_freturn_self; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_dot_apply env _visitors_fself - _visitors_fmethod_name _visitors_fargs _visitors_freturn_self - _visitors_fattr _visitors_floc_ - | Pexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_floc_ - | Pexpr_mutate - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - field = _visitors_ffield; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_mutate env _visitors_frecord - _visitors_faccessor _visitors_ffield _visitors_faugmented_by - _visitors_floc_ - | Pexpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases - _visitors_fmatch_loc_ _visitors_floc_ - | Pexpr_letmut - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fbody _visitors_floc_ - | Pexpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs - _visitors_floc_ - | Pexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_floc_ - | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> - self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind - | Pexpr_return - { - return_value = _visitors_freturn_value; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_return env _visitors_freturn_value - _visitors_floc_ - | Pexpr_raise - { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ - | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } -> - self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked - | Pexpr_break { arg = _visitors_farg; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_break env _visitors_farg _visitors_floc_ - | Pexpr_continue { args = _visitors_fargs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_continue env _visitors_fargs _visitors_floc_ - | Pexpr_loop - { - args = _visitors_fargs; - body = _visitors_fbody; - loop_loc_ = _visitors_floop_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody - _visitors_floop_loc_ _visitors_floc_ - | Pexpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - continue_block = _visitors_fcontinue_block; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ - | Pexpr_foreach - { - binders = _visitors_fbinders; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_floc_ - | Pexpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - try_loc_ = _visitors_ftry_loc_; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ - | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_map env _visitors_felems _visitors_floc_ - | Pexpr_group - { - expr = _visitors_fexpr; - group = _visitors_fgroup; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup - _visitors_floc_ - | Pexpr_static_assert - { asserts = _visitors_fasserts; body = _visitors_fbody } -> - self#visit_Pexpr_static_assert env _visitors_fasserts - _visitors_fbody + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fattr _visitors_floc_ + | Pexpr_infix + { + op = _visitors_fop; + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_infix env _visitors_fop _visitors_flhs + _visitors_frhs _visitors_floc_ + | Pexpr_unary + { + op = _visitors_fop; + expr = _visitors_fexpr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr + _visitors_floc_ + | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ + | Pexpr_array_spread + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_array_spread env _visitors_felems + _visitors_floc_ + | Pexpr_array_get + { + array = _visitors_farray; + index = _visitors_findex; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get env _visitors_farray + _visitors_findex _visitors_floc_ + | Pexpr_array_get_slice + { + array = _visitors_farray; + start_index = _visitors_fstart_index; + end_index = _visitors_fend_index; + index_loc_ = _visitors_findex_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get_slice env _visitors_farray + _visitors_fstart_index _visitors_fend_index + _visitors_findex_loc_ _visitors_floc_ + | Pexpr_array_set + { + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_set env _visitors_farray + _visitors_findex _visitors_fvalue _visitors_floc_ + | Pexpr_array_augmented_set + { + op = _visitors_fop; + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_augmented_set env _visitors_fop + _visitors_farray _visitors_findex _visitors_fvalue + _visitors_floc_ + | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ + | Pexpr_multiline_string + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_multiline_string env _visitors_felems + _visitors_floc_ + | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ + | Pexpr_constraint + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty + _visitors_floc_ + | Pexpr_constr + { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ + | Pexpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_flabel + _visitors_floc_ + | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ + | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ + | Pexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_floc_ + | Pexpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_floc_ + | Pexpr_guard_let + { + pat = _visitors_fpat; + expr = _visitors_fexpr; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr + _visitors_fotherwise _visitors_fbody _visitors_floc_ + | Pexpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_is env _visitors_fexpr _visitors_fpat + _visitors_floc_ + | Pexpr_letfn + { + name = _visitors_fname; + func = _visitors_ffunc; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc + _visitors_fbody _visitors_floc_ + | Pexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_floc_ + | Pexpr_let + { + pattern = _visitors_fpattern; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr + _visitors_fbody _visitors_floc_ + | Pexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_floc_ + | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ + | Pexpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + trailing = _visitors_ftrailing; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record env _visitors_ftype_name + _visitors_ffields _visitors_ftrailing _visitors_floc_ + | Pexpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + fields = _visitors_ffields; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_ffields _visitors_floc_ + | Pexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_field env _visitors_frecord + _visitors_faccessor _visitors_floc_ + | Pexpr_method + { + type_name = _visitors_ftype_name; + method_name = _visitors_fmethod_name; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_method env _visitors_ftype_name + _visitors_fmethod_name _visitors_floc_ + | Pexpr_dot_apply + { + self = _visitors_fself; + method_name = _visitors_fmethod_name; + args = _visitors_fargs; + return_self = _visitors_freturn_self; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_dot_apply env _visitors_fself + _visitors_fmethod_name _visitors_fargs _visitors_freturn_self + _visitors_fattr _visitors_floc_ + | Pexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_floc_ + | Pexpr_mutate + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + field = _visitors_ffield; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_mutate env _visitors_frecord + _visitors_faccessor _visitors_ffield _visitors_faugmented_by + _visitors_floc_ + | Pexpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases + _visitors_fmatch_loc_ _visitors_floc_ + | Pexpr_letmut + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fbody _visitors_floc_ + | Pexpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Pexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_floc_ + | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> + self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind + | Pexpr_return + { + return_value = _visitors_freturn_value; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_return env _visitors_freturn_value + _visitors_floc_ + | Pexpr_raise + { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ + | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } + -> + self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked + | Pexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_break env _visitors_farg _visitors_flabel + _visitors_floc_ + | Pexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_continue env _visitors_fargs _visitors_flabel + _visitors_floc_ + | Pexpr_loop + { + args = _visitors_fargs; + body = _visitors_fbody; + label = _visitors_flabel; + loop_loc_ = _visitors_floop_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody + _visitors_flabel _visitors_floop_loc_ _visitors_floc_ + | Pexpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + continue_block = _visitors_fcontinue_block; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_for env _visitors_fbinders + _visitors_fcondition _visitors_fcontinue_block + _visitors_fbody _visitors_ffor_else _visitors_flabel + _visitors_floc_ + | Pexpr_foreach + { + binders = _visitors_fbinders; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr + _visitors_fbody _visitors_felse_block _visitors_flabel + _visitors_floc_ + | Pexpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + try_loc_ = _visitors_ftry_loc_; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ + _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ + | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_map env _visitors_felems _visitors_floc_ + | Pexpr_group + { + expr = _visitors_fexpr; + group = _visitors_fgroup; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup + _visitors_floc_ + | Pexpr_static_assert + { asserts = _visitors_fasserts; body = _visitors_fbody } -> + self#visit_Pexpr_static_assert env _visitors_fasserts + _visitors_fbody method visit_static_assertion : _ -> static_assertion -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in - let _visitors_r1 = - self#visit_longident env _visitors_this.assert_trait - in - let _visitors_r2 = - self#visit_location env _visitors_this.assert_loc - in - let _visitors_r3 = - self#visit_string env _visitors_this.assert_msg - in - self#visit_record env - [ - ("assert_type", _visitors_r0); - ("assert_trait", _visitors_r1); - ("assert_loc", _visitors_r2); - ("assert_msg", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in + let _visitors_r1 = + self#visit_longident env _visitors_this.assert_trait + in + let _visitors_r2 = + self#visit_location env _visitors_this.assert_loc + in + let _visitors_r3 = + self#visit_string env _visitors_this.assert_msg + in + self#visit_record env + [ + ("assert_type", _visitors_r0); + ("assert_trait", _visitors_r1); + ("assert_loc", _visitors_r2); + ("assert_msg", _visitors_r3); + ] method visit_argument : _ -> argument -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - self#visit_record env - [ ("arg_value", _visitors_r0); ("arg_kind", _visitors_r1) ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + self#visit_record env + [ ("arg_value", _visitors_r0); ("arg_kind", _visitors_r1) ] method visit_parameters : _ -> parameters -> S.t = fun env -> self#visit_list self#visit_parameter env - method visit_parameter : _ -> parameter -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.param_binder - in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_this.param_annot - in - let _visitors_r2 = - self#visit_parameter_kind env _visitors_this.param_kind - in - self#visit_record env - [ - ("param_binder", _visitors_r0); - ("param_annot", _visitors_r1); - ("param_kind", _visitors_r2); - ] - - method visit_Positional : _ -> S.t = - fun env -> self#visit_inline_tuple env "Positional" [] - - method visit_Labelled : _ -> S.t = - fun env -> self#visit_inline_tuple env "Labelled" [] - - method visit_Optional : _ -> expr -> S.t = - fun env _visitors_fdefault -> - let _visitors_r0 = self#visit_expr env _visitors_fdefault in - self#visit_inline_record env "Optional" - [ ("default", _visitors_r0) ] - - method visit_Question_optional : _ -> S.t = - fun env -> self#visit_inline_tuple env "Question_optional" [] - - method visit_parameter_kind : _ -> parameter_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional { default = _visitors_fdefault } -> - self#visit_Optional env _visitors_fdefault - | Question_optional -> self#visit_Question_optional env - - method visit_Lambda - : _ -> - parameters -> - location -> - expr -> - (typ * error_typ) option -> - fn_kind -> - bool -> - S.t = - fun env _visitors_fparameters _visitors_fparams_loc_ _visitors_fbody - _visitors_freturn_type _visitors_fkind_ _visitors_fhas_error -> - let _visitors_r0 = - self#visit_parameters env _visitors_fparameters - in - let _visitors_r1 = self#visit_location env _visitors_fparams_loc_ in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_freturn_type - in - let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in - let _visitors_r5 = self#visit_bool env _visitors_fhas_error in - self#visit_inline_record env "Lambda" - [ - ("parameters", _visitors_r0); - ("params_loc_", _visitors_r1); - ("body", _visitors_r2); - ("return_type", _visitors_r3); - ("kind_", _visitors_r4); - ("has_error", _visitors_r5); - ] + method visit_Discard_positional : _ -> typ option -> location -> S.t = + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_typ env _visitors_fty + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Discard_positional" + [ ("ty", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Positional : _ -> binder -> typ option -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fty + in + self#visit_inline_record env "Positional" + [ ("binder", _visitors_r0); ("ty", _visitors_r1) ] + + method visit_Labelled : _ -> binder -> typ option -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fty + in + self#visit_inline_record env "Labelled" + [ ("binder", _visitors_r0); ("ty", _visitors_r1) ] + + method visit_Optional : _ -> binder -> expr -> typ option -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fdefault -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fdefault in + let _visitors_r2 = + self#visit_option self#visit_typ env _visitors_fty + in + self#visit_inline_record env "Optional" + [ + ("binder", _visitors_r0); + ("default", _visitors_r1); + ("ty", _visitors_r2); + ] + + method visit_Question_optional : _ -> binder -> typ option -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fty + in + self#visit_inline_record env "Question_optional" + [ ("binder", _visitors_r0); ("ty", _visitors_r1) ] - method visit_Match - : _ -> - (pattern list * expr) list -> - bool -> - location -> - location -> - S.t = - fun env _visitors_fcases _visitors_fhas_error _visitors_ffn_loc_ - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_list self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fcases - in - let _visitors_r1 = self#visit_bool env _visitors_fhas_error in - let _visitors_r2 = self#visit_location env _visitors_ffn_loc_ in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Match" - [ - ("cases", _visitors_r0); - ("has_error", _visitors_r1); - ("fn_loc_", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_parameter : _ -> parameter -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Discard_positional { ty = _visitors_fty; loc_ = _visitors_floc_ } + -> + self#visit_Discard_positional env _visitors_fty _visitors_floc_ + | Positional { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Positional env _visitors_fbinder _visitors_fty + | Labelled { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Labelled env _visitors_fbinder _visitors_fty + | Optional + { + binder = _visitors_fbinder; + default = _visitors_fdefault; + ty = _visitors_fty; + } -> + self#visit_Optional env _visitors_fbinder _visitors_fdefault + _visitors_fty + | Question_optional + { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Question_optional env _visitors_fbinder + _visitors_fty + + method visit_Lambda : + _ -> + parameters -> + location -> + expr -> + (typ * error_typ) option -> + fn_kind -> + location option -> + bool -> + S.t = + fun env -> + fun _visitors_fparameters -> + fun _visitors_fparams_loc_ -> + fun _visitors_fbody -> + fun _visitors_freturn_type -> + fun _visitors_fkind_ -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + let _visitors_r0 = + self#visit_parameters env _visitors_fparameters + in + let _visitors_r1 = + self#visit_location env _visitors_fparams_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_freturn_type + in + let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in + let _visitors_r5 = + self#visit_option self#visit_location env + _visitors_fhas_error + in + let _visitors_r6 = self#visit_bool env _visitors_fis_async in + self#visit_inline_record env "Lambda" + [ + ("parameters", _visitors_r0); + ("params_loc_", _visitors_r1); + ("body", _visitors_r2); + ("return_type", _visitors_r3); + ("kind_", _visitors_r4); + ("has_error", _visitors_r5); + ("is_async", _visitors_r6); + ] + + method visit_Match : + _ -> + multi_arg_case list -> + location option -> + bool -> + location -> + location -> + S.t = + fun env -> + fun _visitors_fcases -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + fun _visitors_ffn_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_multi_arg_case env + _visitors_fcases + in + let _visitors_r1 = + self#visit_option self#visit_location env + _visitors_fhas_error + in + let _visitors_r2 = self#visit_bool env _visitors_fis_async in + let _visitors_r3 = + self#visit_location env _visitors_ffn_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Match" + [ + ("cases", _visitors_r0); + ("has_error", _visitors_r1); + ("is_async", _visitors_r2); + ("fn_loc_", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_func : _ -> func -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Lambda - { - parameters = _visitors_fparameters; - params_loc_ = _visitors_fparams_loc_; - body = _visitors_fbody; - return_type = _visitors_freturn_type; - kind_ = _visitors_fkind_; - has_error = _visitors_fhas_error; - } -> - self#visit_Lambda env _visitors_fparameters - _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type - _visitors_fkind_ _visitors_fhas_error - | Match - { - cases = _visitors_fcases; - has_error = _visitors_fhas_error; - fn_loc_ = _visitors_ffn_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Match env _visitors_fcases _visitors_fhas_error - _visitors_ffn_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Lambda + { + parameters = _visitors_fparameters; + params_loc_ = _visitors_fparams_loc_; + body = _visitors_fbody; + return_type = _visitors_freturn_type; + kind_ = _visitors_fkind_; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + } -> + self#visit_Lambda env _visitors_fparameters + _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type + _visitors_fkind_ _visitors_fhas_error _visitors_fis_async + | Match + { + cases = _visitors_fcases; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + fn_loc_ = _visitors_ffn_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Match env _visitors_fcases _visitors_fhas_error + _visitors_fis_async _visitors_ffn_loc_ _visitors_floc_ + + method visit_case : _ -> case -> S.t = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pattern env _visitors_this.pattern in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + self#visit_record env + [ + ("pattern", _visitors_r0); + ("guard", _visitors_r1); + ("body", _visitors_r2); + ] + + method visit_multi_arg_case : _ -> multi_arg_case -> S.t = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_list self#visit_pattern env _visitors_this.patterns + in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + self#visit_record env + [ + ("patterns", _visitors_r0); + ("guard", _visitors_r1); + ("body", _visitors_r2); + ] method visit_Elem_regular : _ -> expr -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - self#visit_inline_tuple env "Elem_regular" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + self#visit_inline_tuple env "Elem_regular" [ _visitors_r0 ] method visit_Elem_spread : _ -> expr -> location -> S.t = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Elem_spread" - [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Elem_spread" + [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] method visit_spreadable_elem : _ -> spreadable_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Elem_regular _visitors_c0 -> - self#visit_Elem_regular env _visitors_c0 - | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ - - method visit_Map_expr_elem - : _ -> constant -> expr -> location -> location -> S.t = - fun env _visitors_fkey _visitors_fexpr _visitors_fkey_loc_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fkey in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_location env _visitors_fkey_loc_ in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Map_expr_elem" - [ - ("key", _visitors_r0); - ("expr", _visitors_r1); - ("key_loc_", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + match _visitors_this with + | Elem_regular _visitors_c0 -> + self#visit_Elem_regular env _visitors_c0 + | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ + + method visit_Map_expr_elem : + _ -> constant -> expr -> location -> location -> S.t = + fun env -> + fun _visitors_fkey -> + fun _visitors_fexpr -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fkey in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + self#visit_location env _visitors_fkey_loc_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Map_expr_elem" + [ + ("key", _visitors_r0); + ("expr", _visitors_r1); + ("key_loc_", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_map_expr_elem : _ -> map_expr_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Map_expr_elem - { - key = _visitors_fkey; - expr = _visitors_fexpr; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr - _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_expr_elem + { + key = _visitors_fkey; + expr = _visitors_fexpr; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr + _visitors_fkey_loc_ _visitors_floc_ method visit_Error_typ : _ -> typ -> S.t = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - self#visit_inline_record env "Error_typ" [ ("ty", _visitors_r0) ] + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + self#visit_inline_record env "Error_typ" [ ("ty", _visitors_r0) ] method visit_Default_error_typ : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Default_error_typ" - [ ("loc_", _visitors_r0) ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Default_error_typ" + [ ("loc_", _visitors_r0) ] method visit_No_error_typ : _ -> S.t = fun env -> self#visit_inline_tuple env "No_error_typ" [] method visit_error_typ : _ -> error_typ -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Ptype_any : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ptype_any" [ ("loc_", _visitors_r0) ] - - method visit_Ptype_arrow - : _ -> typ list -> typ -> error_typ -> location -> S.t = - fun env _visitors_fty_arg _visitors_fty_res _visitors_fty_err - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_typ env _visitors_fty_arg - in - let _visitors_r1 = self#visit_typ env _visitors_fty_res in - let _visitors_r2 = self#visit_error_typ env _visitors_fty_err in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ptype_arrow" - [ - ("ty_arg", _visitors_r0); - ("ty_res", _visitors_r1); - ("ty_err", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ptype_any" [ ("loc_", _visitors_r0) ] + + method visit_Ptype_arrow : + _ -> typ list -> typ -> error_typ -> bool -> location -> S.t = + fun env -> + fun _visitors_fty_arg -> + fun _visitors_fty_res -> + fun _visitors_fty_err -> + fun _visitors_fis_async -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_typ env _visitors_fty_arg + in + let _visitors_r1 = self#visit_typ env _visitors_fty_res in + let _visitors_r2 = + self#visit_error_typ env _visitors_fty_err + in + let _visitors_r3 = self#visit_bool env _visitors_fis_async in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ptype_arrow" + [ + ("ty_arg", _visitors_r0); + ("ty_res", _visitors_r1); + ("ty_err", _visitors_r2); + ("is_async", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_Ptype_tuple : _ -> typ list -> location -> S.t = - fun env _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_typ env _visitors_ftys - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ptype_tuple" - [ ("tys", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Ptype_name - : _ -> constrid_loc -> typ list -> location -> S.t = - fun env _visitors_fconstr_id _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - self#visit_constrid_loc env _visitors_fconstr_id - in - let _visitors_r1 = - self#visit_list self#visit_typ env _visitors_ftys - in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ptype_name" - [ - ("constr_id", _visitors_r0); - ("tys", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_typ env _visitors_ftys + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ptype_tuple" + [ ("tys", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Ptype_name : + _ -> constrid_loc -> typ list -> location -> S.t = + fun env -> + fun _visitors_fconstr_id -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr_id + in + let _visitors_r1 = + self#visit_list self#visit_typ env _visitors_ftys + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ptype_name" + [ + ("constr_id", _visitors_r0); + ("tys", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Ptype_option : _ -> typ -> location -> location -> S.t = - fun env _visitors_fty _visitors_floc_ _visitors_fquestion_loc -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - let _visitors_r2 = - self#visit_location env _visitors_fquestion_loc - in - self#visit_inline_record env "Ptype_option" - [ - ("ty", _visitors_r0); - ("loc_", _visitors_r1); - ("question_loc", _visitors_r2); - ] + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fquestion_loc -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + let _visitors_r2 = + self#visit_location env _visitors_fquestion_loc + in + self#visit_inline_record env "Ptype_option" + [ + ("ty", _visitors_r0); + ("loc_", _visitors_r1); + ("question_loc", _visitors_r2); + ] + + method visit_Ptype_object : _ -> constrid_loc -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_constrid_loc env _visitors_c0 in + self#visit_inline_tuple env "Ptype_object" [ _visitors_r0 ] method visit_typ : _ -> typ -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ptype_any { loc_ = _visitors_floc_ } -> - self#visit_Ptype_any env _visitors_floc_ - | Ptype_arrow - { - ty_arg = _visitors_fty_arg; - ty_res = _visitors_fty_res; - ty_err = _visitors_fty_err; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res - _visitors_fty_err _visitors_floc_ - | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> - self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ - | Ptype_name - { - constr_id = _visitors_fconstr_id; - tys = _visitors_ftys; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys - _visitors_floc_ - | Ptype_option - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - question_loc = _visitors_fquestion_loc; - } -> - self#visit_Ptype_option env _visitors_fty _visitors_floc_ - _visitors_fquestion_loc + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptype_any { loc_ = _visitors_floc_ } -> + self#visit_Ptype_any env _visitors_floc_ + | Ptype_arrow + { + ty_arg = _visitors_fty_arg; + ty_res = _visitors_fty_res; + ty_err = _visitors_fty_err; + is_async = _visitors_fis_async; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res + _visitors_fty_err _visitors_fis_async _visitors_floc_ + | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> + self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ + | Ptype_name + { + constr_id = _visitors_fconstr_id; + tys = _visitors_ftys; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys + _visitors_floc_ + | Ptype_option + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + question_loc = _visitors_fquestion_loc; + } -> + self#visit_Ptype_option env _visitors_fty _visitors_floc_ + _visitors_fquestion_loc + | Ptype_object _visitors_c0 -> + self#visit_Ptype_object env _visitors_c0 method visit_Ppat_alias : _ -> pattern -> binder -> location -> S.t = - fun env _visitors_fpat _visitors_falias _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_alias" - [ - ("pat", _visitors_r0); - ("alias", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_alias" + [ + ("pat", _visitors_r0); + ("alias", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Ppat_any : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_any" [ ("loc_", _visitors_r0) ] - - method visit_Ppat_array : _ -> array_pattern -> location -> S.t = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_array" - [ ("pats", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_any" [ ("loc_", _visitors_r0) ] + + method visit_Ppat_array : _ -> array_patterns -> location -> S.t = + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_array_patterns env _visitors_fpats + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_array" + [ ("pats", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Ppat_constant : _ -> constant -> location -> S.t = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_constant" - [ ("c", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_constant" + [ ("c", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Ppat_constraint : _ -> pattern -> typ -> location -> S.t = - fun env _visitors_fpat _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_constraint" - [ - ("pat", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Ppat_constr - : _ -> - constructor -> - constr_pat_arg list option -> - bool -> - location -> - S.t = - fun env _visitors_fconstr _visitors_fargs _visitors_fis_open - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = - self#visit_option - (self#visit_list self#visit_constr_pat_arg) - env _visitors_fargs - in - let _visitors_r2 = self#visit_bool env _visitors_fis_open in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_constr" - [ - ("constr", _visitors_r0); - ("args", _visitors_r1); - ("is_open", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fpat -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_constraint" + [ + ("pat", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Ppat_constr : + _ -> + constructor -> + constr_pat_arg list option -> + bool -> + location -> + S.t = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_fis_open -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constructor env _visitors_fconstr + in + let _visitors_r1 = + self#visit_option + (self#visit_list self#visit_constr_pat_arg) + env _visitors_fargs + in + let _visitors_r2 = self#visit_bool env _visitors_fis_open in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_constr" + [ + ("constr", _visitors_r0); + ("args", _visitors_r1); + ("is_open", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Ppat_or : _ -> pattern -> pattern -> location -> S.t = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in - let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_or" - [ - ("pat1", _visitors_r0); - ("pat2", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in + let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_or" + [ + ("pat1", _visitors_r0); + ("pat2", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Ppat_tuple : _ -> pattern list -> location -> S.t = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_pattern env _visitors_fpats - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_tuple" - [ ("pats", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_pattern env _visitors_fpats + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_tuple" + [ ("pats", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Ppat_var : _ -> binder -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - self#visit_inline_tuple env "Ppat_var" [ _visitors_r0 ] - - method visit_Ppat_record - : _ -> field_pat list -> bool -> location -> S.t = - fun env _visitors_ffields _visitors_fis_closed _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_field_pat env _visitors_ffields - in - let _visitors_r1 = self#visit_bool env _visitors_fis_closed in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_record" - [ - ("fields", _visitors_r0); - ("is_closed", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Ppat_map : _ -> map_pat_elem list -> location -> S.t = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_map_pat_elem env _visitors_felems - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_map" - [ ("elems", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Ppat_range - : _ -> pattern -> pattern -> bool -> location -> S.t = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_flhs in - let _visitors_r1 = self#visit_pattern env _visitors_frhs in - let _visitors_r2 = self#visit_bool env _visitors_finclusive in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Ppat_range" - [ - ("lhs", _visitors_r0); - ("rhs", _visitors_r1); - ("inclusive", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + self#visit_inline_tuple env "Ppat_var" [ _visitors_r0 ] + + method visit_Ppat_record : + _ -> field_pat list -> bool -> location -> S.t = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_field_pat env _visitors_ffields + in + let _visitors_r1 = self#visit_bool env _visitors_fis_closed in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_record" + [ + ("fields", _visitors_r0); + ("is_closed", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Ppat_map : + _ -> map_pat_elem list -> bool -> location -> S.t = + fun env -> + fun _visitors_felems -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_map_pat_elem env _visitors_felems + in + let _visitors_r1 = self#visit_bool env _visitors_fis_closed in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_map" + [ + ("elems", _visitors_r0); + ("is_closed", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Ppat_range : + _ -> pattern -> pattern -> bool -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_flhs in + let _visitors_r1 = self#visit_pattern env _visitors_frhs in + let _visitors_r2 = self#visit_bool env _visitors_finclusive in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Ppat_range" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("inclusive", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_pattern : _ -> pattern -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ppat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_alias env _visitors_fpat _visitors_falias - _visitors_floc_ - | Ppat_any { loc_ = _visitors_floc_ } -> - self#visit_Ppat_any env _visitors_floc_ - | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_array env _visitors_fpats _visitors_floc_ - | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Ppat_constant env _visitors_fc _visitors_floc_ - | Ppat_constraint - { - pat = _visitors_fpat; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constraint env _visitors_fpat _visitors_fty - _visitors_floc_ - | Ppat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - is_open = _visitors_fis_open; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs - _visitors_fis_open _visitors_floc_ - | Ppat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_floc_ - | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ - | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 - | Ppat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_record env _visitors_ffields - _visitors_fis_closed _visitors_floc_ - | Ppat_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Ppat_map env _visitors_felems _visitors_floc_ - | Ppat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_floc_ - - method visit_Closed : _ -> pattern list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_pattern env _visitors_c0 - in - self#visit_inline_tuple env "Closed" [ _visitors_r0 ] - - method visit_Open - : _ -> pattern list -> pattern list -> binder option -> S.t = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = - self#visit_list self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = - self#visit_list self#visit_pattern env _visitors_c1 - in - let _visitors_r2 = - self#visit_option self#visit_binder env _visitors_c2 - in - self#visit_inline_tuple env "Open" - [ _visitors_r0; _visitors_r1; _visitors_r2 ] + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ppat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_alias env _visitors_fpat _visitors_falias + _visitors_floc_ + | Ppat_any { loc_ = _visitors_floc_ } -> + self#visit_Ppat_any env _visitors_floc_ + | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_array env _visitors_fpats _visitors_floc_ + | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Ppat_constant env _visitors_fc _visitors_floc_ + | Ppat_constraint + { + pat = _visitors_fpat; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constraint env _visitors_fpat _visitors_fty + _visitors_floc_ + | Ppat_constr + { + constr = _visitors_fconstr; + args = _visitors_fargs; + is_open = _visitors_fis_open; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs + _visitors_fis_open _visitors_floc_ + | Ppat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_floc_ + | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ + | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 + | Ppat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_record env _visitors_ffields + _visitors_fis_closed _visitors_floc_ + | Ppat_map + { + elems = _visitors_felems; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_map env _visitors_felems _visitors_fis_closed + _visitors_floc_ + | Ppat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_floc_ + + method visit_Closed : _ -> array_pattern list -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_array_pattern env _visitors_c0 + in + self#visit_inline_tuple env "Closed" [ _visitors_r0 ] + + method visit_Open : + _ -> + array_pattern list -> + array_pattern list -> + binder option -> + S.t = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + self#visit_list self#visit_array_pattern env _visitors_c0 + in + let _visitors_r1 = + self#visit_list self#visit_array_pattern env _visitors_c1 + in + let _visitors_r2 = + self#visit_option self#visit_binder env _visitors_c2 + in + self#visit_inline_tuple env "Open" + [ _visitors_r0; _visitors_r1; _visitors_r2 ] + + method visit_array_patterns : _ -> array_patterns -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + + method visit_Pattern : _ -> pattern -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_pattern env _visitors_c0 in + self#visit_inline_tuple env "Pattern" [ _visitors_r0 ] + + method visit_String_spread : _ -> string_literal -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + self#visit_inline_tuple env "String_spread" [ _visitors_r0 ] + + method visit_String_spread_const : + _ -> binder -> string option -> location -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fpkg -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_string env _visitors_fpkg + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "String_spread_const" + [ + ("binder", _visitors_r0); + ("pkg", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_array_pattern : _ -> array_pattern -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pattern _visitors_c0 -> self#visit_Pattern env _visitors_c0 + | String_spread _visitors_c0 -> + self#visit_String_spread env _visitors_c0 + | String_spread_const + { + binder = _visitors_fbinder; + pkg = _visitors_fpkg; + loc_ = _visitors_floc_; + } -> + self#visit_String_spread_const env _visitors_fbinder + _visitors_fpkg _visitors_floc_ method visit_Field_def : _ -> label -> expr -> bool -> location -> S.t = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_bool env _visitors_fis_pun in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Field_def" - [ - ("label", _visitors_r0); - ("expr", _visitors_r1); - ("is_pun", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_bool env _visitors_fis_pun in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Field_def" + [ + ("label", _visitors_r0); + ("expr", _visitors_r1); + ("is_pun", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_field_def : _ -> field_def -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_pun _visitors_floc_ - - method visit_Field_pat - : _ -> label -> pattern -> bool -> location -> S.t = - fun env _visitors_flabel _visitors_fpattern _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pattern env _visitors_fpattern in - let _visitors_r2 = self#visit_bool env _visitors_fis_pun in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Field_pat" - [ - ("label", _visitors_r0); - ("pattern", _visitors_r1); - ("is_pun", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_pun _visitors_floc_ + + method visit_Field_pat : + _ -> label -> pattern -> bool -> location -> S.t = + fun env -> + fun _visitors_flabel -> + fun _visitors_fpattern -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pattern env _visitors_fpattern in + let _visitors_r2 = self#visit_bool env _visitors_fis_pun in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Field_pat" + [ + ("label", _visitors_r0); + ("pattern", _visitors_r1); + ("is_pun", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_field_pat : _ -> field_pat -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pattern = _visitors_fpattern; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpattern - _visitors_fis_pun _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pattern = _visitors_fpattern; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpattern + _visitors_fis_pun _visitors_floc_ method visit_Constr_pat_arg : _ -> pattern -> argument_kind -> S.t = - fun env _visitors_fpat _visitors_fkind -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - self#visit_inline_record env "Constr_pat_arg" - [ ("pat", _visitors_r0); ("kind", _visitors_r1) ] + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + self#visit_inline_record env "Constr_pat_arg" + [ ("pat", _visitors_r0); ("kind", _visitors_r1) ] method visit_constr_pat_arg : _ -> constr_pat_arg -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - - method visit_Map_pat_elem - : _ -> constant -> pattern -> bool -> location -> location -> S.t = - fun env _visitors_fkey _visitors_fpat _visitors_fmatch_absent - _visitors_fkey_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fkey in - let _visitors_r1 = self#visit_pattern env _visitors_fpat in - let _visitors_r2 = self#visit_bool env _visitors_fmatch_absent in - let _visitors_r3 = self#visit_location env _visitors_fkey_loc_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Map_pat_elem" - [ - ("key", _visitors_r0); - ("pat", _visitors_r1); - ("match_absent", _visitors_r2); - ("key_loc_", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } + -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + + method visit_Map_pat_elem : + _ -> constant -> pattern -> bool -> location -> location -> S.t = + fun env -> + fun _visitors_fkey -> + fun _visitors_fpat -> + fun _visitors_fmatch_absent -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fkey in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = + self#visit_bool env _visitors_fmatch_absent + in + let _visitors_r3 = + self#visit_location env _visitors_fkey_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Map_pat_elem" + [ + ("key", _visitors_r0); + ("pat", _visitors_r1); + ("match_absent", _visitors_r2); + ("key_loc_", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_map_pat_elem : _ -> map_pat_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Map_pat_elem - { - key = _visitors_fkey; - pat = _visitors_fpat; - match_absent = _visitors_fmatch_absent; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat - _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_pat_elem + { + key = _visitors_fkey; + pat = _visitors_fpat; + match_absent = _visitors_fmatch_absent; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat + _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ method visit_constr_param : _ -> constr_param -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in - let _visitors_r1 = self#visit_bool env _visitors_this.cparam_mut in - let _visitors_r2 = - self#visit_option self#visit_label env _visitors_this.cparam_label - in - self#visit_record env - [ - ("cparam_typ", _visitors_r0); - ("cparam_mut", _visitors_r1); - ("cparam_label", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in + let _visitors_r1 = self#visit_bool env _visitors_this.cparam_mut in + let _visitors_r2 = + self#visit_option self#visit_label env + _visitors_this.cparam_label + in + self#visit_record env + [ + ("cparam_typ", _visitors_r0); + ("cparam_mut", _visitors_r1); + ("cparam_label", _visitors_r2); + ] method visit_constr_decl : _ -> constr_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_constr_name env _visitors_this.constr_name - in - let _visitors_r1 = - self#visit_option - (self#visit_list self#visit_constr_param) - env _visitors_this.constr_args - in - let _visitors_r2 = - self#visit_location env _visitors_this.constr_loc_ - in - self#visit_record env - [ - ("constr_name", _visitors_r0); - ("constr_args", _visitors_r1); - ("constr_loc_", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_constr_name env _visitors_this.constr_name + in + let _visitors_r1 = + self#visit_option + (self#visit_list self#visit_constr_param) + env _visitors_this.constr_args + in + let _visitors_r2 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_string env _visitors_c0 in + let _visitors_r1 = self#visit_location env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_this.constr_tag + in + let _visitors_r3 = + self#visit_location env _visitors_this.constr_loc_ + in + self#visit_record env + [ + ("constr_name", _visitors_r0); + ("constr_args", _visitors_r1); + ("constr_tag", _visitors_r2); + ("constr_loc_", _visitors_r3); + ] method visit_field_name : _ -> field_name -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_string env _visitors_this.label in - let _visitors_r1 = self#visit_location env _visitors_this.loc_ in - self#visit_record env - [ ("label", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_string env _visitors_this.label in + let _visitors_r1 = self#visit_location env _visitors_this.loc_ in + self#visit_record env + [ ("label", _visitors_r0); ("loc_", _visitors_r1) ] method visit_field_decl : _ -> field_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_field_name env _visitors_this.field_name - in - let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in - let _visitors_r2 = self#visit_bool env _visitors_this.field_mut in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - self#visit_location env _visitors_this.field_loc_ - in - self#visit_record env - [ - ("field_name", _visitors_r0); - ("field_ty", _visitors_r1); - ("field_mut", _visitors_r2); - ("field_vis", _visitors_r3); - ("field_loc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_field_name env _visitors_this.field_name + in + let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in + let _visitors_r2 = self#visit_bool env _visitors_this.field_mut in + let _visitors_r3 = + self#visit_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + self#visit_location env _visitors_this.field_loc_ + in + self#visit_record env + [ + ("field_name", _visitors_r0); + ("field_ty", _visitors_r1); + ("field_mut", _visitors_r2); + ("field_vis", _visitors_r3); + ("field_loc_", _visitors_r4); + ] method visit_No_payload : _ -> S.t = fun env -> self#visit_inline_tuple env "No_payload" [] method visit_Single_payload : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Single_payload" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Single_payload" [ _visitors_r0 ] method visit_Enum_payload : _ -> constr_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_constr_decl env _visitors_c0 - in - self#visit_inline_tuple env "Enum_payload" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_constr_decl env _visitors_c0 + in + self#visit_inline_tuple env "Enum_payload" [ _visitors_r0 ] method visit_exception_decl : _ -> exception_decl -> S.t = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Ptd_abstract : _ -> S.t = fun env -> self#visit_inline_tuple env "Ptd_abstract" [] + method visit_Ptd_extern : _ -> S.t = + fun env -> self#visit_inline_tuple env "Ptd_extern" [] + method visit_Ptd_newtype : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Ptd_newtype" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Ptd_newtype" [ _visitors_r0 ] method visit_Ptd_error : _ -> exception_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - self#visit_inline_tuple env "Ptd_error" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + self#visit_inline_tuple env "Ptd_error" [ _visitors_r0 ] method visit_Ptd_variant : _ -> constr_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_constr_decl env _visitors_c0 - in - self#visit_inline_tuple env "Ptd_variant" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_constr_decl env _visitors_c0 + in + self#visit_inline_tuple env "Ptd_variant" [ _visitors_r0 ] method visit_Ptd_record : _ -> field_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_field_decl env _visitors_c0 - in - self#visit_inline_tuple env "Ptd_record" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_field_decl env _visitors_c0 + in + self#visit_inline_tuple env "Ptd_record" [ _visitors_r0 ] method visit_Ptd_alias : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Ptd_alias" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Ptd_alias" [ _visitors_r0 ] method visit_type_desc : _ -> type_desc -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ptd_abstract -> self#visit_Ptd_abstract env - | Ptd_newtype _visitors_c0 -> - self#visit_Ptd_newtype env _visitors_c0 - | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 - | Ptd_variant _visitors_c0 -> - self#visit_Ptd_variant env _visitors_c0 - | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 - | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptd_abstract -> self#visit_Ptd_abstract env + | Ptd_extern -> self#visit_Ptd_extern env + | Ptd_newtype _visitors_c0 -> + self#visit_Ptd_newtype env _visitors_c0 + | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 + | Ptd_variant _visitors_c0 -> + self#visit_Ptd_variant env _visitors_c0 + | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 + | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 method visit_type_decl : _ -> type_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_string env _visitors_this.tycon in - let _visitors_r1 = - self#visit_location env _visitors_this.tycon_loc_ - in - let _visitors_r2 = - self#visit_list self#visit_type_decl_binder env - _visitors_this.params - in - let _visitors_r3 = - self#visit_type_desc env _visitors_this.components - in - let _visitors_r4 = self#visit_docstring env _visitors_this.doc_ in - let _visitors_r5 = - self#visit_visibility env _visitors_this.type_vis - in - let _visitors_r6 = - self#visit_list self#visit_deriving_directive env - _visitors_this.deriving_ - in - let _visitors_r7 = - self#visit_absolute_loc env _visitors_this.loc_ - in - self#visit_record env - [ - ("tycon", _visitors_r0); - ("tycon_loc_", _visitors_r1); - ("params", _visitors_r2); - ("components", _visitors_r3); - ("doc_", _visitors_r4); - ("type_vis", _visitors_r5); - ("deriving_", _visitors_r6); - ("loc_", _visitors_r7); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_string env _visitors_this.tycon in + let _visitors_r1 = + self#visit_location env _visitors_this.tycon_loc_ + in + let _visitors_r2 = + self#visit_list self#visit_type_decl_binder env + _visitors_this.params + in + let _visitors_r3 = + self#visit_type_desc env _visitors_this.components + in + let _visitors_r4 = + self#visit_list self#visit_attribute env _visitors_this.attrs + in + let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r6 = + self#visit_visibility env _visitors_this.type_vis + in + let _visitors_r7 = + self#visit_list self#visit_deriving_directive env + _visitors_this.deriving_ + in + let _visitors_r8 = + self#visit_absolute_loc env _visitors_this.loc_ + in + self#visit_record env + [ + ("tycon", _visitors_r0); + ("tycon_loc_", _visitors_r1); + ("params", _visitors_r2); + ("components", _visitors_r3); + ("attrs", _visitors_r4); + ("doc_", _visitors_r5); + ("type_vis", _visitors_r6); + ("deriving_", _visitors_r7); + ("loc_", _visitors_r8); + ] method visit_local_type_decl : _ -> local_type_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_string env _visitors_this.local_tycon - in - let _visitors_r1 = - self#visit_location env _visitors_this.local_tycon_loc_ - in - let _visitors_r2 = - self#visit_type_desc env _visitors_this.local_components - in - self#visit_record env - [ - ("local_tycon", _visitors_r0); - ("local_tycon_loc_", _visitors_r1); - ("local_components", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_string env _visitors_this.local_tycon + in + let _visitors_r1 = + self#visit_location env _visitors_this.local_tycon_loc_ + in + let _visitors_r2 = + self#visit_type_desc env _visitors_this.local_components + in + let _visitors_r3 = + self#visit_list self#visit_deriving_directive env + _visitors_this.deriving_ + in + self#visit_record env + [ + ("local_tycon", _visitors_r0); + ("local_tycon_loc_", _visitors_r1); + ("local_components", _visitors_r2); + ("deriving_", _visitors_r3); + ] method visit_deriving_directive : _ -> deriving_directive -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_name env _visitors_this.type_name_ - in - let _visitors_r1 = - self#visit_list self#visit_argument env _visitors_this.args - in - let _visitors_r2 = self#visit_location env _visitors_this.loc_ in - self#visit_record env - [ - ("type_name_", _visitors_r0); - ("args", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_name env _visitors_this.type_name_ + in + let _visitors_r1 = + self#visit_list self#visit_argument env _visitors_this.args + in + let _visitors_r2 = self#visit_location env _visitors_this.loc_ in + self#visit_record env + [ + ("type_name_", _visitors_r0); + ("args", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Vis_default : _ -> S.t = fun env -> self#visit_inline_tuple env "Vis_default" [] method visit_Vis_pub : _ -> string option -> location -> S.t = - fun env _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_string env _visitors_fattr - in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Vis_pub" - [ ("attr", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_string env _visitors_fattr + in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Vis_pub" + [ ("attr", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Vis_priv : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Vis_priv" [ ("loc_", _visitors_r0) ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Vis_priv" [ ("loc_", _visitors_r0) ] method visit_visibility : _ -> visibility -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Vis_default -> self#visit_Vis_default env - | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> - self#visit_Vis_pub env _visitors_fattr _visitors_floc_ - | Vis_priv { loc_ = _visitors_floc_ } -> - self#visit_Vis_priv env _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Vis_default -> self#visit_Vis_default env + | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> + self#visit_Vis_pub env _visitors_fattr _visitors_floc_ + | Vis_priv { loc_ = _visitors_floc_ } -> + self#visit_Vis_priv env _visitors_floc_ method visit_Import : _ -> string_literal -> string_literal -> S.t = - fun env _visitors_fmodule_name _visitors_ffunc_name -> - let _visitors_r0 = - self#visit_string_literal env _visitors_fmodule_name - in - let _visitors_r1 = - self#visit_string_literal env _visitors_ffunc_name - in - self#visit_inline_record env "Import" - [ ("module_name", _visitors_r0); ("func_name", _visitors_r1) ] - - method visit_Embedded - : _ -> string_literal option -> embedded_code -> S.t = - fun env _visitors_flanguage _visitors_fcode -> - let _visitors_r0 = - self#visit_option self#visit_string_literal env - _visitors_flanguage - in - let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in - self#visit_inline_record env "Embedded" - [ ("language", _visitors_r0); ("code", _visitors_r1) ] + fun env -> + fun _visitors_fmodule_name -> + fun _visitors_ffunc_name -> + let _visitors_r0 = + self#visit_string_literal env _visitors_fmodule_name + in + let _visitors_r1 = + self#visit_string_literal env _visitors_ffunc_name + in + self#visit_inline_record env "Import" + [ ("module_name", _visitors_r0); ("func_name", _visitors_r1) ] + + method visit_Embedded : + _ -> string_literal option -> embedded_code -> S.t = + fun env -> + fun _visitors_flanguage -> + fun _visitors_fcode -> + let _visitors_r0 = + self#visit_option self#visit_string_literal env + _visitors_flanguage + in + let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in + self#visit_inline_record env "Embedded" + [ ("language", _visitors_r0); ("code", _visitors_r1) ] method visit_func_stubs : _ -> func_stubs -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Import - { - module_name = _visitors_fmodule_name; - func_name = _visitors_ffunc_name; - } -> - self#visit_Import env _visitors_fmodule_name - _visitors_ffunc_name - | Embedded - { language = _visitors_flanguage; code = _visitors_fcode } -> - self#visit_Embedded env _visitors_flanguage _visitors_fcode + fun env -> + fun _visitors_this -> + match _visitors_this with + | Import + { + module_name = _visitors_fmodule_name; + func_name = _visitors_ffunc_name; + } -> + self#visit_Import env _visitors_fmodule_name + _visitors_ffunc_name + | Embedded + { language = _visitors_flanguage; code = _visitors_fcode } -> + self#visit_Embedded env _visitors_flanguage _visitors_fcode method visit_Code_string : _ -> string_literal -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_string_literal env _visitors_c0 in - self#visit_inline_tuple env "Code_string" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + self#visit_inline_tuple env "Code_string" [ _visitors_r0 ] method visit_Code_multiline_string : _ -> string list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_string env _visitors_c0 - in - self#visit_inline_tuple env "Code_multiline_string" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_string env _visitors_c0 + in + self#visit_inline_tuple env "Code_multiline_string" + [ _visitors_r0 ] method visit_embedded_code : _ -> embedded_code -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Code_string _visitors_c0 -> - self#visit_Code_string env _visitors_c0 - | Code_multiline_string _visitors_c0 -> - self#visit_Code_multiline_string env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Code_string _visitors_c0 -> + self#visit_Code_string env _visitors_c0 + | Code_multiline_string _visitors_c0 -> + self#visit_Code_multiline_string env _visitors_c0 method visit_Decl_body : _ -> local_type_decl list -> expr -> S.t = - fun env _visitors_flocal_types _visitors_fexpr -> - let _visitors_r0 = - self#visit_list self#visit_local_type_decl env - _visitors_flocal_types - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - self#visit_inline_record env "Decl_body" - [ ("local_types", _visitors_r0); ("expr", _visitors_r1) ] + fun env -> + fun _visitors_flocal_types -> + fun _visitors_fexpr -> + let _visitors_r0 = + self#visit_list self#visit_local_type_decl env + _visitors_flocal_types + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + self#visit_inline_record env "Decl_body" + [ ("local_types", _visitors_r0); ("expr", _visitors_r1) ] method visit_Decl_stubs : _ -> func_stubs -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - self#visit_inline_tuple env "Decl_stubs" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + self#visit_inline_tuple env "Decl_stubs" [ _visitors_r0 ] method visit_decl_body : _ -> decl_body -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Decl_body - { local_types = _visitors_flocal_types; expr = _visitors_fexpr } - -> - self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr - | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Decl_body + { + local_types = _visitors_flocal_types; + expr = _visitors_fexpr; + } -> + self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr + | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 method visit_fun_decl : _ -> fun_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_option self#visit_type_name env - _visitors_this.type_name - in - let _visitors_r1 = self#visit_binder env _visitors_this.name in - let _visitors_r2 = self#visit_bool env _visitors_this.has_error in - let _visitors_r3 = - self#visit_option self#visit_parameters env - _visitors_this.decl_params - in - let _visitors_r4 = - self#visit_location env _visitors_this.params_loc_ - in - let _visitors_r5 = - self#visit_list self#visit_tvar_binder env - _visitors_this.quantifiers - in - let _visitors_r6 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_this.return_type - in - let _visitors_r7 = self#visit_bool env _visitors_this.is_pub in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - self#visit_record env - [ - ("type_name", _visitors_r0); - ("name", _visitors_r1); - ("has_error", _visitors_r2); - ("decl_params", _visitors_r3); - ("params_loc_", _visitors_r4); - ("quantifiers", _visitors_r5); - ("return_type", _visitors_r6); - ("is_pub", _visitors_r7); - ("doc_", _visitors_r8); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_this.type_name + in + let _visitors_r1 = self#visit_binder env _visitors_this.name in + let _visitors_r2 = + self#visit_option self#visit_location env + _visitors_this.has_error + in + let _visitors_r3 = self#visit_bool env _visitors_this.is_async in + let _visitors_r4 = + self#visit_option self#visit_parameters env + _visitors_this.decl_params + in + let _visitors_r5 = + self#visit_location env _visitors_this.params_loc_ + in + let _visitors_r6 = + self#visit_list self#visit_tvar_binder env + _visitors_this.quantifiers + in + let _visitors_r7 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = self#visit_error_typ env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_this.return_type + in + let _visitors_r8 = self#visit_visibility env _visitors_this.vis in + let _visitors_r9 = + self#visit_list self#visit_attribute env _visitors_this.attrs + in + let _visitors_r10 = self#visit_docstring env _visitors_this.doc_ in + self#visit_record env + [ + ("type_name", _visitors_r0); + ("name", _visitors_r1); + ("has_error", _visitors_r2); + ("is_async", _visitors_r3); + ("decl_params", _visitors_r4); + ("params_loc_", _visitors_r5); + ("quantifiers", _visitors_r6); + ("return_type", _visitors_r7); + ("vis", _visitors_r8); + ("attrs", _visitors_r9); + ("doc_", _visitors_r10); + ] method visit_trait_method_param : _ -> trait_method_param -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in - let _visitors_r1 = - self#visit_option self#visit_label env - _visitors_this.tmparam_label - in - self#visit_record env - [ ("tmparam_typ", _visitors_r0); ("tmparam_label", _visitors_r1) ] - - method visit_Trait_method - : _ -> - binder -> - bool -> - tvar_binder list -> - trait_method_param list -> - (typ * error_typ) option -> - location -> - S.t = - fun env _visitors_fname _visitors_fhas_error _visitors_fquantifiers - _visitors_fparams _visitors_freturn_type _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_bool env _visitors_fhas_error in - let _visitors_r2 = - self#visit_list self#visit_tvar_binder env _visitors_fquantifiers - in - let _visitors_r3 = - self#visit_list self#visit_trait_method_param env - _visitors_fparams - in - let _visitors_r4 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_freturn_type - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Trait_method" - [ - ("name", _visitors_r0); - ("has_error", _visitors_r1); - ("quantifiers", _visitors_r2); - ("params", _visitors_r3); - ("return_type", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in + let _visitors_r1 = + self#visit_option self#visit_label env + _visitors_this.tmparam_label + in + self#visit_record env + [ + ("tmparam_typ", _visitors_r0); ("tmparam_label", _visitors_r1); + ] + + method visit_Trait_method : + _ -> + binder -> + bool -> + tvar_binder list -> + trait_method_param list -> + (typ * error_typ) option -> + location -> + S.t = + fun env -> + fun _visitors_fname -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_freturn_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_bool env _visitors_fhas_error in + let _visitors_r2 = + self#visit_list self#visit_tvar_binder env + _visitors_fquantifiers + in + let _visitors_r3 = + self#visit_list self#visit_trait_method_param env + _visitors_fparams + in + let _visitors_r4 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_freturn_type + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Trait_method" + [ + ("name", _visitors_r0); + ("has_error", _visitors_r1); + ("quantifiers", _visitors_r2); + ("params", _visitors_r3); + ("return_type", _visitors_r4); + ("loc_", _visitors_r5); + ] method visit_trait_method_decl : _ -> trait_method_decl -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Trait_method - { - name = _visitors_fname; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - return_type = _visitors_freturn_type; - loc_ = _visitors_floc_; - } -> - self#visit_Trait_method env _visitors_fname _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams - _visitors_freturn_type _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Trait_method + { + name = _visitors_fname; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + return_type = _visitors_freturn_type; + loc_ = _visitors_floc_; + } -> + self#visit_Trait_method env _visitors_fname + _visitors_fhas_error _visitors_fquantifiers _visitors_fparams + _visitors_freturn_type _visitors_floc_ method visit_trait_decl : _ -> trait_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.trait_name - in - let _visitors_r1 = - self#visit_list self#visit_tvar_constraint env - _visitors_this.trait_supers - in - let _visitors_r2 = - self#visit_list self#visit_trait_method_decl env - _visitors_this.trait_methods - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r4 = - self#visit_absolute_loc env _visitors_this.trait_loc_ - in - let _visitors_r5 = - self#visit_docstring env _visitors_this.trait_doc_ - in - self#visit_record env - [ - ("trait_name", _visitors_r0); - ("trait_supers", _visitors_r1); - ("trait_methods", _visitors_r2); - ("trait_vis", _visitors_r3); - ("trait_loc_", _visitors_r4); - ("trait_doc_", _visitors_r5); - ] - - method visit_Ptop_expr - : _ -> expr -> bool -> local_type_decl list -> absolute_loc -> S.t = - fun env _visitors_fexpr _visitors_fis_main _visitors_flocal_types - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_bool env _visitors_fis_main in - let _visitors_r2 = - self#visit_list self#visit_local_type_decl env - _visitors_flocal_types - in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ptop_expr" - [ - ("expr", _visitors_r0); - ("is_main", _visitors_r1); - ("local_types", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Ptop_test - : _ -> - expr -> - test_name -> - parameters option -> - local_type_decl list -> - absolute_loc -> - S.t = - fun env _visitors_fexpr _visitors_fname _visitors_fparams - _visitors_flocal_types _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_test_name env _visitors_fname in - let _visitors_r2 = - self#visit_option self#visit_parameters env _visitors_fparams - in - let _visitors_r3 = - self#visit_list self#visit_local_type_decl env - _visitors_flocal_types - in - let _visitors_r4 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ptop_test" - [ - ("expr", _visitors_r0); - ("name", _visitors_r1); - ("params", _visitors_r2); - ("local_types", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_binder env _visitors_this.trait_name + in + let _visitors_r1 = + self#visit_list self#visit_tvar_constraint env + _visitors_this.trait_supers + in + let _visitors_r2 = + self#visit_list self#visit_trait_method_decl env + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.trait_loc_ + in + let _visitors_r5 = + self#visit_list self#visit_attribute env + _visitors_this.trait_attrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_this.trait_doc_ + in + self#visit_record env + [ + ("trait_name", _visitors_r0); + ("trait_supers", _visitors_r1); + ("trait_methods", _visitors_r2); + ("trait_vis", _visitors_r3); + ("trait_loc_", _visitors_r4); + ("trait_attrs", _visitors_r5); + ("trait_doc_", _visitors_r6); + ] + + method visit_Ptop_expr : + _ -> expr -> bool -> local_type_decl list -> absolute_loc -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_bool env _visitors_fis_main in + let _visitors_r2 = + self#visit_list self#visit_local_type_decl env + _visitors_flocal_types + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ptop_expr" + [ + ("expr", _visitors_r0); + ("is_main", _visitors_r1); + ("local_types", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Ptop_test : + _ -> + expr -> + test_name -> + parameters option -> + local_type_decl list -> + absolute_loc -> + attribute list -> + docstring -> + S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_test_name env _visitors_fname + in + let _visitors_r2 = + self#visit_option self#visit_parameters env + _visitors_fparams + in + let _visitors_r3 = + self#visit_list self#visit_local_type_decl env + _visitors_flocal_types + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r5 = + self#visit_list self#visit_attribute env _visitors_fattrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_fdoc_ + in + self#visit_inline_record env "Ptop_test" + [ + ("expr", _visitors_r0); + ("name", _visitors_r1); + ("params", _visitors_r2); + ("local_types", _visitors_r3); + ("loc_", _visitors_r4); + ("attrs", _visitors_r5); + ("doc_", _visitors_r6); + ] method visit_Ptop_typedef : _ -> type_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_decl env _visitors_c0 in - self#visit_inline_tuple env "Ptop_typedef" [ _visitors_r0 ] - - method visit_Ptop_funcdef - : _ -> fun_decl -> decl_body -> absolute_loc -> S.t = - fun env _visitors_ffun_decl _visitors_fdecl_body _visitors_floc_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_decl_body env _visitors_fdecl_body in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ptop_funcdef" - [ - ("fun_decl", _visitors_r0); - ("decl_body", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Ptop_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - bool -> - absolute_loc -> - docstring -> - S.t = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fis_pub _visitors_fis_constant _visitors_floc_ - _visitors_fdoc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_bool env _visitors_fis_pub in - let _visitors_r4 = self#visit_bool env _visitors_fis_constant in - let _visitors_r5 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r6 = self#visit_docstring env _visitors_fdoc_ in - self#visit_inline_record env "Ptop_letdef" - [ - ("binder", _visitors_r0); - ("ty", _visitors_r1); - ("expr", _visitors_r2); - ("is_pub", _visitors_r3); - ("is_constant", _visitors_r4); - ("loc_", _visitors_r5); - ("doc_", _visitors_r6); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_decl env _visitors_c0 in + self#visit_inline_tuple env "Ptop_typedef" [ _visitors_r0 ] + + method visit_Ptop_funcdef : + _ -> fun_decl -> decl_body -> absolute_loc -> S.t = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_fdecl_body -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = + self#visit_decl_body env _visitors_fdecl_body + in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + self#visit_inline_record env "Ptop_funcdef" + [ + ("fun_decl", _visitors_r0); + ("decl_body", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Ptop_letdef : + _ -> + binder -> + typ option -> + expr -> + visibility -> + bool -> + absolute_loc -> + attribute list -> + docstring -> + S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fvis -> + fun _visitors_fis_constant -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + self#visit_binder env _visitors_fbinder + in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r4 = + self#visit_bool env _visitors_fis_constant + in + let _visitors_r5 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r6 = + self#visit_list self#visit_attribute env _visitors_fattrs + in + let _visitors_r7 = + self#visit_docstring env _visitors_fdoc_ + in + self#visit_inline_record env "Ptop_letdef" + [ + ("binder", _visitors_r0); + ("ty", _visitors_r1); + ("expr", _visitors_r2); + ("vis", _visitors_r3); + ("is_constant", _visitors_r4); + ("loc_", _visitors_r5); + ("attrs", _visitors_r6); + ("doc_", _visitors_r7); + ] method visit_Ptop_trait : _ -> trait_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in - self#visit_inline_tuple env "Ptop_trait" [ _visitors_r0 ] - - method visit_Ptop_impl - : _ -> - typ option -> - type_name -> - binder -> - bool -> - tvar_binder list -> - parameters -> - (typ * error_typ) option -> - expr -> - bool -> - local_type_decl list -> - absolute_loc -> - location -> - docstring -> - S.t = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fmethod_name - _visitors_fhas_error _visitors_fquantifiers _visitors_fparams - _visitors_fret_ty _visitors_fbody _visitors_fis_pub - _visitors_flocal_types _visitors_floc_ _visitors_fheader_loc_ - _visitors_fdoc_ -> - let _visitors_r0 = - self#visit_option self#visit_typ env _visitors_fself_ty - in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_binder env _visitors_fmethod_name in - let _visitors_r3 = self#visit_bool env _visitors_fhas_error in - let _visitors_r4 = - self#visit_list self#visit_tvar_binder env _visitors_fquantifiers - in - let _visitors_r5 = self#visit_parameters env _visitors_fparams in - let _visitors_r6 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fret_ty - in - let _visitors_r7 = self#visit_expr env _visitors_fbody in - let _visitors_r8 = self#visit_bool env _visitors_fis_pub in - let _visitors_r9 = - self#visit_list self#visit_local_type_decl env - _visitors_flocal_types - in - let _visitors_r10 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r11 = - self#visit_location env _visitors_fheader_loc_ - in - let _visitors_r12 = self#visit_docstring env _visitors_fdoc_ in - self#visit_inline_record env "Ptop_impl" - [ - ("self_ty", _visitors_r0); - ("trait", _visitors_r1); - ("method_name", _visitors_r2); - ("has_error", _visitors_r3); - ("quantifiers", _visitors_r4); - ("params", _visitors_r5); - ("ret_ty", _visitors_r6); - ("body", _visitors_r7); - ("is_pub", _visitors_r8); - ("local_types", _visitors_r9); - ("loc_", _visitors_r10); - ("header_loc_", _visitors_r11); - ("doc_", _visitors_r12); - ] - - method visit_Ptop_impl_relation - : _ -> - typ -> - type_name -> - tvar_binder list -> - bool -> - absolute_loc -> - S.t = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fquantifiers - _visitors_fis_pub _visitors_floc_ -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = - self#visit_list self#visit_tvar_binder env _visitors_fquantifiers - in - let _visitors_r3 = self#visit_bool env _visitors_fis_pub in - let _visitors_r4 = self#visit_absolute_loc env _visitors_floc_ in - self#visit_inline_record env "Ptop_impl_relation" - [ - ("self_ty", _visitors_r0); - ("trait", _visitors_r1); - ("quantifiers", _visitors_r2); - ("is_pub", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in + self#visit_inline_tuple env "Ptop_trait" [ _visitors_r0 ] + + method visit_Ptop_trait_alias : + _ -> + binder -> + type_name -> + visibility -> + absolute_loc -> + attribute list -> + docstring -> + S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ftarget -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_type_name env _visitors_ftarget + in + let _visitors_r2 = self#visit_visibility env _visitors_fvis in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r4 = + self#visit_list self#visit_attribute env _visitors_fattrs + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + self#visit_inline_record env "Ptop_trait_alias" + [ + ("binder", _visitors_r0); + ("target", _visitors_r1); + ("vis", _visitors_r2); + ("loc_", _visitors_r3); + ("attrs", _visitors_r4); + ("doc_", _visitors_r5); + ] + + method visit_Ptop_impl : + _ -> + typ option -> + type_name -> + binder -> + bool -> + tvar_binder list -> + parameters -> + (typ * error_typ) option -> + decl_body -> + visibility -> + absolute_loc -> + location -> + attribute list -> + docstring -> + S.t = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fmethod_name -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_fret_ty -> + fun _visitors_fbody -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fheader_loc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + self#visit_option self#visit_typ env + _visitors_fself_ty + in + let _visitors_r1 = + self#visit_type_name env _visitors_ftrait + in + let _visitors_r2 = + self#visit_binder env _visitors_fmethod_name + in + let _visitors_r3 = + self#visit_bool env _visitors_fhas_error + in + let _visitors_r4 = + self#visit_list self#visit_tvar_binder env + _visitors_fquantifiers + in + let _visitors_r5 = + self#visit_parameters env _visitors_fparams + in + let _visitors_r6 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + self#visit_tuple env + [ _visitors_r0; _visitors_r1 ]) + env _visitors_fret_ty + in + let _visitors_r7 = + self#visit_decl_body env _visitors_fbody + in + let _visitors_r8 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r9 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r10 = + self#visit_location env _visitors_fheader_loc_ + in + let _visitors_r11 = + self#visit_list self#visit_attribute env + _visitors_fattrs + in + let _visitors_r12 = + self#visit_docstring env _visitors_fdoc_ + in + self#visit_inline_record env "Ptop_impl" + [ + ("self_ty", _visitors_r0); + ("trait", _visitors_r1); + ("method_name", _visitors_r2); + ("has_error", _visitors_r3); + ("quantifiers", _visitors_r4); + ("params", _visitors_r5); + ("ret_ty", _visitors_r6); + ("body", _visitors_r7); + ("vis", _visitors_r8); + ("loc_", _visitors_r9); + ("header_loc_", _visitors_r10); + ("attrs", _visitors_r11); + ("doc_", _visitors_r12); + ] + + method visit_Ptop_impl_relation : + _ -> + typ -> + type_name -> + tvar_binder list -> + bool -> + absolute_loc -> + S.t = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fquantifiers -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = + self#visit_list self#visit_tvar_binder env + _visitors_fquantifiers + in + let _visitors_r3 = self#visit_bool env _visitors_fis_pub in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_floc_ + in + self#visit_inline_record env "Ptop_impl_relation" + [ + ("self_ty", _visitors_r0); + ("trait", _visitors_r1); + ("quantifiers", _visitors_r2); + ("is_pub", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_impl : _ -> impl -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Ptop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main - _visitors_flocal_types _visitors_floc_ - | Ptop_test - { - expr = _visitors_fexpr; - name = _visitors_fname; - params = _visitors_fparams; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_test env _visitors_fexpr _visitors_fname - _visitors_fparams _visitors_flocal_types _visitors_floc_ - | Ptop_typedef _visitors_c0 -> - self#visit_Ptop_typedef env _visitors_c0 - | Ptop_funcdef - { - fun_decl = _visitors_ffun_decl; - decl_body = _visitors_fdecl_body; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_funcdef env _visitors_ffun_decl - _visitors_fdecl_body _visitors_floc_ - | Ptop_letdef - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - is_constant = _visitors_fis_constant; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fis_pub _visitors_fis_constant - _visitors_floc_ _visitors_fdoc_ - | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 - | Ptop_impl - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - method_name = _visitors_fmethod_name; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - ret_ty = _visitors_fret_ty; - body = _visitors_fbody; - is_pub = _visitors_fis_pub; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - header_loc_ = _visitors_fheader_loc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait - _visitors_fmethod_name _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams _visitors_fret_ty - _visitors_fbody _visitors_fis_pub _visitors_flocal_types - _visitors_floc_ _visitors_fheader_loc_ _visitors_fdoc_ - | Ptop_impl_relation - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - quantifiers = _visitors_fquantifiers; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_impl_relation env _visitors_fself_ty - _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main + _visitors_flocal_types _visitors_floc_ + | Ptop_test + { + expr = _visitors_fexpr; + name = _visitors_fname; + params = _visitors_fparams; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_test env _visitors_fexpr _visitors_fname + _visitors_fparams _visitors_flocal_types _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_typedef _visitors_c0 -> + self#visit_Ptop_typedef env _visitors_c0 + | Ptop_funcdef + { + fun_decl = _visitors_ffun_decl; + decl_body = _visitors_fdecl_body; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_funcdef env _visitors_ffun_decl + _visitors_fdecl_body _visitors_floc_ + | Ptop_letdef + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + vis = _visitors_fvis; + is_constant = _visitors_fis_constant; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fvis _visitors_fis_constant + _visitors_floc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 + | Ptop_trait_alias + { + binder = _visitors_fbinder; + target = _visitors_ftarget; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_trait_alias env _visitors_fbinder + _visitors_ftarget _visitors_fvis _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_impl + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + method_name = _visitors_fmethod_name; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + ret_ty = _visitors_fret_ty; + body = _visitors_fbody; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + header_loc_ = _visitors_fheader_loc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait + _visitors_fmethod_name _visitors_fhas_error + _visitors_fquantifiers _visitors_fparams _visitors_fret_ty + _visitors_fbody _visitors_fvis _visitors_floc_ + _visitors_fheader_loc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_impl_relation + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + quantifiers = _visitors_fquantifiers; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_impl_relation env _visitors_fself_ty + _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub + _visitors_floc_ method visit_Interp_lit : _ -> string -> string -> location -> S.t = - fun env _visitors_fstr _visitors_frepr _visitors_floc_ -> - let _visitors_r0 = self#visit_string env _visitors_fstr in - let _visitors_r1 = self#visit_string env _visitors_frepr in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Interp_lit" - [ - ("str", _visitors_r0); - ("repr", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fstr -> + fun _visitors_frepr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_string env _visitors_fstr in + let _visitors_r1 = self#visit_string env _visitors_frepr in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Interp_lit" + [ + ("str", _visitors_r0); + ("repr", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Interp_expr : _ -> expr -> location -> S.t = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Interp_expr" - [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Interp_expr" + [ ("expr", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Interp_source : _ -> Literal.interp_source -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_interp_source env _visitors_c0 in - self#visit_inline_tuple env "Interp_source" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_interp_source env _visitors_c0 in + self#visit_inline_tuple env "Interp_source" [ _visitors_r0 ] method visit_interp_elem : _ -> interp_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit - { - str = _visitors_fstr; - repr = _visitors_frepr; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_lit env _visitors_fstr _visitors_frepr - _visitors_floc_ - | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ - | Interp_source _visitors_c0 -> - self#visit_Interp_source env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit + { + str = _visitors_fstr; + repr = _visitors_frepr; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_lit env _visitors_fstr _visitors_frepr + _visitors_floc_ + | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ + | Interp_source _visitors_c0 -> + self#visit_Interp_source env _visitors_c0 method visit_Multiline_string : _ -> string -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_string env _visitors_c0 in - self#visit_inline_tuple env "Multiline_string" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string env _visitors_c0 in + self#visit_inline_tuple env "Multiline_string" [ _visitors_r0 ] method visit_Multiline_interp : _ -> interp_elem list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_interp_elem env _visitors_c0 - in - self#visit_inline_tuple env "Multiline_interp" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_interp_elem env _visitors_c0 + in + self#visit_inline_tuple env "Multiline_interp" [ _visitors_r0 ] method visit_multiline_string_elem : _ -> multiline_string_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Multiline_string _visitors_c0 -> - self#visit_Multiline_string env _visitors_c0 - | Multiline_interp _visitors_c0 -> - self#visit_Multiline_interp env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Multiline_string _visitors_c0 -> + self#visit_Multiline_string env _visitors_c0 + | Multiline_interp _visitors_c0 -> + self#visit_Multiline_interp env _visitors_c0 method visit_impls : _ -> impls -> S.t = fun env -> self#visit_list self#visit_impl env @@ -3939,2440 +4786,3238 @@ include struct object (self : 'self) inherit [_] iterbase - method visit_Pexpr_apply - : _ -> expr -> argument list -> apply_attr -> location -> unit = - fun env _visitors_ffunc _visitors_fargs _visitors_fattr - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fattr in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + method visit_Pexpr_apply : + _ -> expr -> argument list -> apply_attr -> location -> unit = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fattr in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_infix : _ -> var -> expr -> expr -> location -> unit = - fun env _visitors_fop _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_flhs in - let _visitors_r2 = self#visit_expr env _visitors_frhs in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fop -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_flhs in + let _visitors_r2 = self#visit_expr env _visitors_frhs in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_unary : _ -> var -> expr -> location -> unit = - fun env _visitors_fop _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fop -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_array : _ -> expr list -> location -> unit = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_array_spread - : _ -> spreadable_elem list -> location -> unit = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_spreadable_elem env)) - _visitors_felems - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_array_spread : + _ -> spreadable_elem list -> location -> unit = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_spreadable_elem env)) + _visitors_felems + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_array_get : _ -> expr -> expr -> location -> unit = - fun env _visitors_farray _visitors_findex _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_array_get_slice - : _ -> - expr -> - expr option -> - expr option -> - location -> - location -> - unit = - fun env _visitors_farray _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fstart_index - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fend_index - in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_findex_loc_ - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_array_set - : _ -> expr -> expr -> expr -> location -> unit = - fun env _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = self#visit_expr env _visitors_fvalue in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_array_augmented_set - : _ -> var -> expr -> expr -> expr -> location -> unit = - fun env _visitors_fop _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_farray in - let _visitors_r2 = self#visit_expr env _visitors_findex in - let _visitors_r3 = self#visit_expr env _visitors_fvalue in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_array_get_slice : + _ -> + expr -> + expr option -> + expr option -> + location -> + location -> + unit = + fun env -> + fun _visitors_farray -> + fun _visitors_fstart_index -> + fun _visitors_fend_index -> + fun _visitors_findex_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fstart_index + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fend_index + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_findex_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_array_set : + _ -> expr -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = self#visit_expr env _visitors_fvalue in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_array_augmented_set : + _ -> var -> expr -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_fop -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_farray in + let _visitors_r2 = self#visit_expr env _visitors_findex in + let _visitors_r3 = self#visit_expr env _visitors_fvalue in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Pexpr_constant : _ -> constant -> location -> unit = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_multiline_string - : _ -> multiline_string_elem list -> location -> unit = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (self#visit_multiline_string_elem env)) - _visitors_felems - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_multiline_string : + _ -> multiline_string_elem list -> location -> unit = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_multiline_string_elem env)) + _visitors_felems + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_interp : _ -> interp_elem list -> location -> unit = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_interp_elem env)) - _visitors_felems - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_interp_elem env)) + _visitors_felems + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_constraint : _ -> expr -> typ -> location -> unit = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_constr : _ -> constructor -> location -> unit = - fun env _visitors_fconstr _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_while - : _ -> expr -> expr -> expr option -> location -> unit = - fun env _visitors_floop_cond _visitors_floop_body - _visitors_fwhile_else _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fwhile_else - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fconstr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constructor env _visitors_fconstr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_while : + _ -> expr -> expr -> expr option -> label option -> location -> unit + = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fwhile_else + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Pexpr_function : _ -> func -> location -> unit = - fun env _visitors_ffunc _visitors_floc_ -> - let _visitors_r0 = self#visit_func env _visitors_ffunc in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_ffunc -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_func env _visitors_ffunc in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_ident : _ -> var -> location -> unit = - fun env _visitors_fid _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_if - : _ -> expr -> expr -> expr option -> location -> unit = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fifnot - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_guard - : _ -> expr -> expr option -> expr -> location -> unit = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_guard_let - : _ -> - pattern -> - expr -> - (pattern * expr) list option -> - expr -> - location -> - unit = - fun env _visitors_fpat _visitors_fexpr _visitors_fotherwise - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - t - | None -> ()) - _visitors_fotherwise - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_letfn - : _ -> binder -> func -> expr -> location -> unit = - fun env _visitors_fname _visitors_ffunc _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_func env _visitors_ffunc in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_letrec - : _ -> (binder * func) list -> expr -> location -> unit = - fun env _visitors_fbindings _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_func env _visitors_c1 in - ())) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_let - : _ -> pattern -> expr -> expr -> location -> unit = - fun env _visitors_fpattern _visitors_fexpr _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpattern in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_sequence : _ -> expr -> expr -> location -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fid -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_if : + _ -> expr -> expr -> expr option -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fifnot + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_guard : + _ -> expr -> expr option -> expr -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_guard_let : + _ -> pattern -> expr -> case list option -> expr -> location -> unit + = + fun env -> + fun _visitors_fpat -> + fun _visitors_fexpr -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_case env)) + t + | None -> ()) + _visitors_fotherwise + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_is : _ -> expr -> pattern -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_letfn : + _ -> binder -> func -> expr -> location -> unit = + fun env -> + fun _visitors_fname -> + fun _visitors_ffunc -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_func env _visitors_ffunc in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_letrec : + _ -> (binder * func) list -> expr -> location -> unit = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_func env _visitors_c1 in + ())) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_let : + _ -> pattern -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_fpattern -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpattern in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_sequence : _ -> expr list -> expr -> location -> unit + = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_tuple : _ -> expr list -> location -> unit = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_record - : _ -> - type_name option -> - field_def list -> - trailing_mark -> - location -> - unit = - fun env _visitors_ftype_name _visitors_ffields _visitors_ftrailing - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_ftype_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_ftrailing in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_record_update - : _ -> - type_name option -> - expr -> - field_def list -> - location -> - unit = - fun env _visitors_ftype_name _visitors_frecord _visitors_ffields - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_record : + _ -> + type_name option -> + field_def list -> + trailing_mark -> + location -> + unit = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_ftrailing -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_ftrailing + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_record_update : + _ -> type_name option -> expr -> field_def list -> location -> unit + = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_field : _ -> expr -> accessor -> location -> unit = - fun env _visitors_frecord _visitors_faccessor _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_method : _ -> type_name -> label -> location -> unit = - fun env _visitors_ftype_name _visitors_fmethod_name _visitors_floc_ -> - let _visitors_r0 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_dot_apply - : _ -> - expr -> - label -> - argument list -> - bool -> - apply_attr -> - location -> - unit = - fun env _visitors_fself _visitors_fmethod_name _visitors_fargs - _visitors_freturn_self _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fself in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_freturn_self - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fattr in - let _visitors_r5 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fmethod_name -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r1 = self#visit_label env _visitors_fmethod_name in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_dot_apply : + _ -> + expr -> + label -> + argument list -> + bool -> + apply_attr -> + location -> + unit = + fun env -> + fun _visitors_fself -> + fun _visitors_fmethod_name -> + fun _visitors_fargs -> + fun _visitors_freturn_self -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fself in + let _visitors_r1 = + self#visit_label env _visitors_fmethod_name + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_argument env)) + _visitors_fargs + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_freturn_self + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fattr + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Pexpr_as : _ -> expr -> type_name -> location -> unit = - fun env _visitors_fexpr _visitors_ftrait _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_mutate - : _ -> expr -> accessor -> expr -> var option -> location -> unit = - fun env _visitors_frecord _visitors_faccessor _visitors_ffield - _visitors_faugmented_by _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_var env) t - | None -> ()) - _visitors_faugmented_by - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_match - : _ -> expr -> (pattern * expr) list -> location -> location -> unit - = - fun env _visitors_fexpr _visitors_fcases _visitors_fmatch_loc_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fmatch_loc_ - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_letmut - : _ -> binder -> typ option -> expr -> expr -> location -> unit = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_mutate : + _ -> expr -> accessor -> expr -> var option -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_ffield -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_var env) t + | None -> ()) + _visitors_faugmented_by + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_match : + _ -> expr -> case list -> location -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_case env)) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fmatch_loc_ + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_letmut : + _ -> binder -> typ option -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Pexpr_pipe : _ -> expr -> expr -> location -> unit = - fun env _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_assign - : _ -> var -> expr -> var option -> location -> unit = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_var env) t - | None -> ()) - _visitors_faugmented_by - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_assign : + _ -> var -> expr -> var option -> location -> unit = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_var env) t + | None -> ()) + _visitors_faugmented_by + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_hole : _ -> location -> hole -> unit = - fun env _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - let _visitors_r1 = self#visit_hole env _visitors_fkind in - () + fun env -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + let _visitors_r1 = self#visit_hole env _visitors_fkind in + () method visit_Pexpr_return : _ -> expr option -> location -> unit = - fun env _visitors_freturn_value _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_freturn_value - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_freturn_value -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_freturn_value + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_raise : _ -> expr -> location -> unit = - fun env _visitors_ferr_value _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferr_value in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_ferr_value -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferr_value in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_unit : _ -> location -> bool -> unit = - fun env _visitors_floc_ _visitors_ffaked -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ffaked in - () - - method visit_Pexpr_break : _ -> expr option -> location -> unit = - fun env _visitors_farg _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_continue : _ -> expr list -> location -> unit = - fun env _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_loop - : _ -> - expr list -> - (pattern list * expr) list -> - location -> - location -> - unit = - fun env _visitors_fargs _visitors_fbody _visitors_floop_loc_ - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = + fun env -> + fun _visitors_floc_ -> + fun _visitors_ffaked -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_ffaked in + () + + method visit_Pexpr_break : + _ -> expr option -> label option -> location -> unit = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_farg + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_continue : + _ -> expr list -> label option -> location -> unit = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_loop : + _ -> + expr list -> + multi_arg_case list -> + label option -> + location -> + location -> + unit = + fun env -> + fun _visitors_fargs -> + fun _visitors_fbody -> + fun _visitors_flabel -> + fun _visitors_floop_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_multi_arg_case env)) + _visitors_fbody + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_floop_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_for : + _ -> + (binder * expr) list -> + expr option -> + (binder * expr) list -> + expr -> + expr option -> + label option -> + location -> + unit = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fcontinue_block -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = + self#visit_expr env _visitors_c1 + in + ())) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fcondition + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = + self#visit_expr env _visitors_c1 + in + ())) + _visitors_fcontinue_block + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_ffor_else + in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r6 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_foreach : + _ -> + binder option list -> + expr -> + expr -> + expr option -> + label option -> + location -> + unit = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_binder env) t + | None -> ())) + _visitors_fbinders + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_felse_block + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () + + method visit_Pexpr_try : + _ -> + expr -> + case list -> + bool -> + case list option -> + location -> + location -> + location -> + location -> + unit = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_ftry_loc_ -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_c0 + Basic_lst.iter _visitors_this ~f:(self#visit_case env)) + _visitors_fcatch in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fbody - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_floop_loc_ - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_for - : _ -> - (binder * expr) list -> - expr option -> - (binder * expr) list -> - expr -> - expr option -> - location -> - unit = - fun env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fcondition - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcontinue_block - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_ffor_else - in - let _visitors_r5 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_foreach - : _ -> - binder option list -> - expr -> - expr -> - expr option -> - location -> - unit = - fun env _visitors_fbinders _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_binder env) t - | None -> ())) - _visitors_fbinders - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_felse_block - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_try - : _ -> - expr -> - (pattern * expr) list -> - bool -> - (pattern * expr) list option -> - location -> - location -> - location -> - location -> - unit = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_ftry_loc_ _visitors_fcatch_loc_ - _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcatch - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fcatch_all - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - t - | None -> ()) - _visitors_ftry_else - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_ftry_loc_ in - let _visitors_r5 = - (fun _visitors_this -> ()) _visitors_fcatch_loc_ - in - let _visitors_r6 = - (fun _visitors_this -> ()) _visitors_felse_loc_ - in - let _visitors_r7 = (fun _visitors_this -> ()) _visitors_floc_ in - () + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fcatch_all + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_case env)) + t + | None -> ()) + _visitors_ftry_else + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_ftry_loc_ + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_fcatch_loc_ + in + let _visitors_r6 = + (fun _visitors_this -> ()) _visitors_felse_loc_ + in + let _visitors_r7 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Pexpr_map : _ -> map_expr_elem list -> location -> unit = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_map_expr_elem env)) - _visitors_felems - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_map_expr_elem env)) + _visitors_felems + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Pexpr_group : _ -> expr -> group -> location -> unit = - fun env _visitors_fexpr _visitors_fgroup _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fgroup in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Pexpr_static_assert - : _ -> static_assertion list -> expr -> unit = - fun env _visitors_fasserts _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_static_assertion env)) - _visitors_fasserts - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_fgroup -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fgroup in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Pexpr_static_assert : + _ -> static_assertion list -> expr -> unit = + fun env -> + fun _visitors_fasserts -> + fun _visitors_fbody -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_static_assertion env)) + _visitors_fasserts + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + () method visit_expr : _ -> expr -> unit = - fun env _visitors_this -> - match _visitors_this with - | Pexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fattr _visitors_floc_ - | Pexpr_infix - { - op = _visitors_fop; - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_infix env _visitors_fop _visitors_flhs - _visitors_frhs _visitors_floc_ - | Pexpr_unary - { - op = _visitors_fop; - expr = _visitors_fexpr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr - _visitors_floc_ - | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ - | Pexpr_array_spread - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_array_spread env _visitors_felems - _visitors_floc_ - | Pexpr_array_get - { - array = _visitors_farray; - index = _visitors_findex; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get env _visitors_farray _visitors_findex - _visitors_floc_ - | Pexpr_array_get_slice - { - array = _visitors_farray; - start_index = _visitors_fstart_index; - end_index = _visitors_fend_index; - index_loc_ = _visitors_findex_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get_slice env _visitors_farray - _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ - | Pexpr_array_set - { - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_set env _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ - | Pexpr_array_augmented_set - { - op = _visitors_fop; - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_augmented_set env _visitors_fop - _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ - | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ - | Pexpr_multiline_string - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_multiline_string env _visitors_felems - _visitors_floc_ - | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ - | Pexpr_constraint - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty - _visitors_floc_ - | Pexpr_constr - { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ - | Pexpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_floc_ - | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ - | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ - | Pexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_floc_ - | Pexpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_floc_ - | Pexpr_guard_let - { - pat = _visitors_fpat; - expr = _visitors_fexpr; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr - _visitors_fotherwise _visitors_fbody _visitors_floc_ - | Pexpr_letfn - { - name = _visitors_fname; - func = _visitors_ffunc; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc - _visitors_fbody _visitors_floc_ - | Pexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_floc_ - | Pexpr_let - { - pattern = _visitors_fpattern; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr - _visitors_fbody _visitors_floc_ - | Pexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_floc_ - | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ - | Pexpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - trailing = _visitors_ftrailing; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record env _visitors_ftype_name - _visitors_ffields _visitors_ftrailing _visitors_floc_ - | Pexpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - fields = _visitors_ffields; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_ffields _visitors_floc_ - | Pexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_field env _visitors_frecord _visitors_faccessor - _visitors_floc_ - | Pexpr_method - { - type_name = _visitors_ftype_name; - method_name = _visitors_fmethod_name; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_method env _visitors_ftype_name - _visitors_fmethod_name _visitors_floc_ - | Pexpr_dot_apply - { - self = _visitors_fself; - method_name = _visitors_fmethod_name; - args = _visitors_fargs; - return_self = _visitors_freturn_self; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_dot_apply env _visitors_fself - _visitors_fmethod_name _visitors_fargs _visitors_freturn_self - _visitors_fattr _visitors_floc_ - | Pexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_floc_ - | Pexpr_mutate - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - field = _visitors_ffield; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_mutate env _visitors_frecord - _visitors_faccessor _visitors_ffield _visitors_faugmented_by - _visitors_floc_ - | Pexpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases - _visitors_fmatch_loc_ _visitors_floc_ - | Pexpr_letmut - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fbody _visitors_floc_ - | Pexpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs - _visitors_floc_ - | Pexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_floc_ - | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> - self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind - | Pexpr_return - { - return_value = _visitors_freturn_value; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_return env _visitors_freturn_value - _visitors_floc_ - | Pexpr_raise - { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ - | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } -> - self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked - | Pexpr_break { arg = _visitors_farg; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_break env _visitors_farg _visitors_floc_ - | Pexpr_continue { args = _visitors_fargs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_continue env _visitors_fargs _visitors_floc_ - | Pexpr_loop - { - args = _visitors_fargs; - body = _visitors_fbody; - loop_loc_ = _visitors_floop_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody - _visitors_floop_loc_ _visitors_floc_ - | Pexpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - continue_block = _visitors_fcontinue_block; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ - | Pexpr_foreach - { - binders = _visitors_fbinders; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_floc_ - | Pexpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - try_loc_ = _visitors_ftry_loc_; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ - | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_map env _visitors_felems _visitors_floc_ - | Pexpr_group - { - expr = _visitors_fexpr; - group = _visitors_fgroup; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup - _visitors_floc_ - | Pexpr_static_assert - { asserts = _visitors_fasserts; body = _visitors_fbody } -> - self#visit_Pexpr_static_assert env _visitors_fasserts - _visitors_fbody + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fattr _visitors_floc_ + | Pexpr_infix + { + op = _visitors_fop; + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_infix env _visitors_fop _visitors_flhs + _visitors_frhs _visitors_floc_ + | Pexpr_unary + { + op = _visitors_fop; + expr = _visitors_fexpr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr + _visitors_floc_ + | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ + | Pexpr_array_spread + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_array_spread env _visitors_felems + _visitors_floc_ + | Pexpr_array_get + { + array = _visitors_farray; + index = _visitors_findex; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get env _visitors_farray + _visitors_findex _visitors_floc_ + | Pexpr_array_get_slice + { + array = _visitors_farray; + start_index = _visitors_fstart_index; + end_index = _visitors_fend_index; + index_loc_ = _visitors_findex_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get_slice env _visitors_farray + _visitors_fstart_index _visitors_fend_index + _visitors_findex_loc_ _visitors_floc_ + | Pexpr_array_set + { + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_set env _visitors_farray + _visitors_findex _visitors_fvalue _visitors_floc_ + | Pexpr_array_augmented_set + { + op = _visitors_fop; + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_augmented_set env _visitors_fop + _visitors_farray _visitors_findex _visitors_fvalue + _visitors_floc_ + | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ + | Pexpr_multiline_string + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_multiline_string env _visitors_felems + _visitors_floc_ + | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ + | Pexpr_constraint + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty + _visitors_floc_ + | Pexpr_constr + { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ + | Pexpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_flabel + _visitors_floc_ + | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ + | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ + | Pexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_floc_ + | Pexpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_floc_ + | Pexpr_guard_let + { + pat = _visitors_fpat; + expr = _visitors_fexpr; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr + _visitors_fotherwise _visitors_fbody _visitors_floc_ + | Pexpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_is env _visitors_fexpr _visitors_fpat + _visitors_floc_ + | Pexpr_letfn + { + name = _visitors_fname; + func = _visitors_ffunc; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc + _visitors_fbody _visitors_floc_ + | Pexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_floc_ + | Pexpr_let + { + pattern = _visitors_fpattern; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr + _visitors_fbody _visitors_floc_ + | Pexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_floc_ + | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ + | Pexpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + trailing = _visitors_ftrailing; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record env _visitors_ftype_name + _visitors_ffields _visitors_ftrailing _visitors_floc_ + | Pexpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + fields = _visitors_ffields; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_ffields _visitors_floc_ + | Pexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_field env _visitors_frecord + _visitors_faccessor _visitors_floc_ + | Pexpr_method + { + type_name = _visitors_ftype_name; + method_name = _visitors_fmethod_name; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_method env _visitors_ftype_name + _visitors_fmethod_name _visitors_floc_ + | Pexpr_dot_apply + { + self = _visitors_fself; + method_name = _visitors_fmethod_name; + args = _visitors_fargs; + return_self = _visitors_freturn_self; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_dot_apply env _visitors_fself + _visitors_fmethod_name _visitors_fargs _visitors_freturn_self + _visitors_fattr _visitors_floc_ + | Pexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_floc_ + | Pexpr_mutate + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + field = _visitors_ffield; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_mutate env _visitors_frecord + _visitors_faccessor _visitors_ffield _visitors_faugmented_by + _visitors_floc_ + | Pexpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases + _visitors_fmatch_loc_ _visitors_floc_ + | Pexpr_letmut + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fbody _visitors_floc_ + | Pexpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Pexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_floc_ + | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> + self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind + | Pexpr_return + { + return_value = _visitors_freturn_value; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_return env _visitors_freturn_value + _visitors_floc_ + | Pexpr_raise + { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ + | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } + -> + self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked + | Pexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_break env _visitors_farg _visitors_flabel + _visitors_floc_ + | Pexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_continue env _visitors_fargs _visitors_flabel + _visitors_floc_ + | Pexpr_loop + { + args = _visitors_fargs; + body = _visitors_fbody; + label = _visitors_flabel; + loop_loc_ = _visitors_floop_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody + _visitors_flabel _visitors_floop_loc_ _visitors_floc_ + | Pexpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + continue_block = _visitors_fcontinue_block; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_for env _visitors_fbinders + _visitors_fcondition _visitors_fcontinue_block + _visitors_fbody _visitors_ffor_else _visitors_flabel + _visitors_floc_ + | Pexpr_foreach + { + binders = _visitors_fbinders; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr + _visitors_fbody _visitors_felse_block _visitors_flabel + _visitors_floc_ + | Pexpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + try_loc_ = _visitors_ftry_loc_; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ + _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ + | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_map env _visitors_felems _visitors_floc_ + | Pexpr_group + { + expr = _visitors_fexpr; + group = _visitors_fgroup; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup + _visitors_floc_ + | Pexpr_static_assert + { asserts = _visitors_fasserts; body = _visitors_fbody } -> + self#visit_Pexpr_static_assert env _visitors_fasserts + _visitors_fbody method visit_static_assertion : _ -> static_assertion -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in - let _visitors_r1 = - self#visit_longident env _visitors_this.assert_trait - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.assert_loc - in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_this.assert_msg - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in + let _visitors_r1 = + self#visit_longident env _visitors_this.assert_trait + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.assert_loc + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_this.assert_msg + in + () method visit_argument : _ -> argument -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + () method visit_parameters : _ -> parameters -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_parameter env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_parameter env) + + method visit_Discard_positional : _ -> typ option -> location -> unit = + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Positional : _ -> binder -> typ option -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + () + + method visit_Labelled : _ -> binder -> typ option -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + () + + method visit_Optional : _ -> binder -> expr -> typ option -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fdefault -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fdefault in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + () + + method visit_Question_optional : _ -> binder -> typ option -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + () method visit_parameter : _ -> parameter -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.param_binder - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_this.param_annot - in - let _visitors_r2 = - self#visit_parameter_kind env _visitors_this.param_kind - in - () - - method visit_Positional : _ -> unit = fun env -> () - method visit_Labelled : _ -> unit = fun env -> () - - method visit_Optional : _ -> expr -> unit = - fun env _visitors_fdefault -> - let _visitors_r0 = self#visit_expr env _visitors_fdefault in - () - - method visit_Question_optional : _ -> unit = fun env -> () - - method visit_parameter_kind : _ -> parameter_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional { default = _visitors_fdefault } -> - self#visit_Optional env _visitors_fdefault - | Question_optional -> self#visit_Question_optional env - - method visit_Lambda - : _ -> - parameters -> - location -> - expr -> - (typ * error_typ) option -> - fn_kind -> - bool -> - unit = - fun env _visitors_fparameters _visitors_fparams_loc_ _visitors_fbody - _visitors_freturn_type _visitors_fkind_ _visitors_fhas_error -> - let _visitors_r0 = - self#visit_parameters env _visitors_fparameters - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fparams_loc_ - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - ()) - t - | None -> ()) - _visitors_freturn_type - in - let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in - let _visitors_r5 = - (fun _visitors_this -> ()) _visitors_fhas_error - in - () - - method visit_Match - : _ -> - (pattern list * expr) list -> - bool -> - location -> - location -> - unit = - fun env _visitors_fcases _visitors_fhas_error _visitors_ffn_loc_ - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fcases - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fhas_error - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_ffn_loc_ in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Discard_positional { ty = _visitors_fty; loc_ = _visitors_floc_ } + -> + self#visit_Discard_positional env _visitors_fty _visitors_floc_ + | Positional { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Positional env _visitors_fbinder _visitors_fty + | Labelled { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Labelled env _visitors_fbinder _visitors_fty + | Optional + { + binder = _visitors_fbinder; + default = _visitors_fdefault; + ty = _visitors_fty; + } -> + self#visit_Optional env _visitors_fbinder _visitors_fdefault + _visitors_fty + | Question_optional + { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Question_optional env _visitors_fbinder + _visitors_fty + + method visit_Lambda : + _ -> + parameters -> + location -> + expr -> + (typ * error_typ) option -> + fn_kind -> + location option -> + bool -> + unit = + fun env -> + fun _visitors_fparameters -> + fun _visitors_fparams_loc_ -> + fun _visitors_fbody -> + fun _visitors_freturn_type -> + fun _visitors_fkind_ -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + let _visitors_r0 = + self#visit_parameters env _visitors_fparameters + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fparams_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + ()) + t + | None -> ()) + _visitors_freturn_type + in + let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_fhas_error + in + let _visitors_r6 = + (fun _visitors_this -> ()) _visitors_fis_async + in + () + + method visit_Match : + _ -> + multi_arg_case list -> + location option -> + bool -> + location -> + location -> + unit = + fun env -> + fun _visitors_fcases -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + fun _visitors_ffn_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_multi_arg_case env)) + _visitors_fcases + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_fhas_error + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_async + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_ffn_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_func : _ -> func -> unit = - fun env _visitors_this -> - match _visitors_this with - | Lambda - { - parameters = _visitors_fparameters; - params_loc_ = _visitors_fparams_loc_; - body = _visitors_fbody; - return_type = _visitors_freturn_type; - kind_ = _visitors_fkind_; - has_error = _visitors_fhas_error; - } -> - self#visit_Lambda env _visitors_fparameters - _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type - _visitors_fkind_ _visitors_fhas_error - | Match - { - cases = _visitors_fcases; - has_error = _visitors_fhas_error; - fn_loc_ = _visitors_ffn_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Match env _visitors_fcases _visitors_fhas_error - _visitors_ffn_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Lambda + { + parameters = _visitors_fparameters; + params_loc_ = _visitors_fparams_loc_; + body = _visitors_fbody; + return_type = _visitors_freturn_type; + kind_ = _visitors_fkind_; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + } -> + self#visit_Lambda env _visitors_fparameters + _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type + _visitors_fkind_ _visitors_fhas_error _visitors_fis_async + | Match + { + cases = _visitors_fcases; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + fn_loc_ = _visitors_ffn_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Match env _visitors_fcases _visitors_fhas_error + _visitors_fis_async _visitors_ffn_loc_ _visitors_floc_ + + method visit_case : _ -> case -> unit = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pattern env _visitors_this.pattern in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + () + + method visit_multi_arg_case : _ -> multi_arg_case -> unit = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pattern env)) + _visitors_this.patterns + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + () method visit_Elem_regular : _ -> expr -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + () method visit_Elem_spread : _ -> expr -> location -> unit = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_spreadable_elem : _ -> spreadable_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Elem_regular _visitors_c0 -> - self#visit_Elem_regular env _visitors_c0 - | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ - - method visit_Map_expr_elem - : _ -> constant -> expr -> location -> location -> unit = - fun env _visitors_fkey _visitors_fexpr _visitors_fkey_loc_ - _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fkey in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fkey_loc_ in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Elem_regular _visitors_c0 -> + self#visit_Elem_regular env _visitors_c0 + | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ + + method visit_Map_expr_elem : + _ -> constant -> expr -> location -> location -> unit = + fun env -> + fun _visitors_fkey -> + fun _visitors_fexpr -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fkey in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fkey_loc_ + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_map_expr_elem : _ -> map_expr_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Map_expr_elem - { - key = _visitors_fkey; - expr = _visitors_fexpr; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr - _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_expr_elem + { + key = _visitors_fkey; + expr = _visitors_fexpr; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr + _visitors_fkey_loc_ _visitors_floc_ method visit_Error_typ : _ -> typ -> unit = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - () + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + () method visit_Default_error_typ : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_No_error_typ : _ -> unit = fun env -> () method visit_error_typ : _ -> error_typ -> unit = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Ptype_any : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ptype_arrow - : _ -> typ list -> typ -> error_typ -> location -> unit = - fun env _visitors_fty_arg _visitors_fty_res _visitors_fty_err - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fty_arg - in - let _visitors_r1 = self#visit_typ env _visitors_fty_res in - let _visitors_r2 = self#visit_error_typ env _visitors_fty_err in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ptype_arrow : + _ -> typ list -> typ -> error_typ -> bool -> location -> unit = + fun env -> + fun _visitors_fty_arg -> + fun _visitors_fty_res -> + fun _visitors_fty_err -> + fun _visitors_fis_async -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fty_arg + in + let _visitors_r1 = self#visit_typ env _visitors_fty_res in + let _visitors_r2 = + self#visit_error_typ env _visitors_fty_err + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_async + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_Ptype_tuple : _ -> typ list -> location -> unit = - fun env _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_ftys - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ptype_name - : _ -> constrid_loc -> typ list -> location -> unit = - fun env _visitors_fconstr_id _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - self#visit_constrid_loc env _visitors_fconstr_id - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_ftys - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_ftys + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ptype_name : + _ -> constrid_loc -> typ list -> location -> unit = + fun env -> + fun _visitors_fconstr_id -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr_id + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_ftys + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ptype_option : _ -> typ -> location -> location -> unit = - fun env _visitors_fty _visitors_floc_ _visitors_fquestion_loc -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fquestion_loc - in - () + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fquestion_loc -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fquestion_loc + in + () + + method visit_Ptype_object : _ -> constrid_loc -> unit = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_constrid_loc env _visitors_c0 in + () method visit_typ : _ -> typ -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ptype_any { loc_ = _visitors_floc_ } -> - self#visit_Ptype_any env _visitors_floc_ - | Ptype_arrow - { - ty_arg = _visitors_fty_arg; - ty_res = _visitors_fty_res; - ty_err = _visitors_fty_err; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res - _visitors_fty_err _visitors_floc_ - | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> - self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ - | Ptype_name - { - constr_id = _visitors_fconstr_id; - tys = _visitors_ftys; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys - _visitors_floc_ - | Ptype_option - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - question_loc = _visitors_fquestion_loc; - } -> - self#visit_Ptype_option env _visitors_fty _visitors_floc_ - _visitors_fquestion_loc + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptype_any { loc_ = _visitors_floc_ } -> + self#visit_Ptype_any env _visitors_floc_ + | Ptype_arrow + { + ty_arg = _visitors_fty_arg; + ty_res = _visitors_fty_res; + ty_err = _visitors_fty_err; + is_async = _visitors_fis_async; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res + _visitors_fty_err _visitors_fis_async _visitors_floc_ + | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> + self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ + | Ptype_name + { + constr_id = _visitors_fconstr_id; + tys = _visitors_ftys; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys + _visitors_floc_ + | Ptype_option + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + question_loc = _visitors_fquestion_loc; + } -> + self#visit_Ptype_option env _visitors_fty _visitors_floc_ + _visitors_fquestion_loc + | Ptype_object _visitors_c0 -> + self#visit_Ptype_object env _visitors_c0 method visit_Ppat_alias : _ -> pattern -> binder -> location -> unit = - fun env _visitors_fpat _visitors_falias _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_any : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ppat_array : _ -> array_pattern -> location -> unit = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ppat_array : _ -> array_patterns -> location -> unit = + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_array_patterns env _visitors_fpats + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_constant : _ -> constant -> location -> unit = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_constraint : _ -> pattern -> typ -> location -> unit = - fun env _visitors_fpat _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ppat_constr - : _ -> - constructor -> - constr_pat_arg list option -> - bool -> - location -> - unit = - fun env _visitors_fconstr _visitors_fargs _visitors_fis_open - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (self#visit_constr_pat_arg env)) - t - | None -> ()) - _visitors_fargs - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_open in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fpat -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ppat_constr : + _ -> + constructor -> + constr_pat_arg list option -> + bool -> + location -> + unit = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_fis_open -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constructor env _visitors_fconstr + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_constr_pat_arg env)) + t + | None -> ()) + _visitors_fargs + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_open + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_or : _ -> pattern -> pattern -> location -> unit = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in - let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in + let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_tuple : _ -> pattern list -> location -> unit = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_fpats - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pattern env)) + _visitors_fpats + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Ppat_var : _ -> binder -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - () - - method visit_Ppat_record - : _ -> field_pat list -> bool -> location -> unit = - fun env _visitors_ffields _visitors_fis_closed _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_pat env)) - _visitors_ffields - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fis_closed - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ppat_map : _ -> map_pat_elem list -> location -> unit = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_map_pat_elem env)) - _visitors_felems - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ppat_range - : _ -> pattern -> pattern -> bool -> location -> unit = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_flhs in - let _visitors_r1 = self#visit_pattern env _visitors_frhs in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_finclusive - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + () + + method visit_Ppat_record : + _ -> field_pat list -> bool -> location -> unit = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_pat env)) + _visitors_ffields + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_closed + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ppat_map : + _ -> map_pat_elem list -> bool -> location -> unit = + fun env -> + fun _visitors_felems -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_map_pat_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_closed + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ppat_range : + _ -> pattern -> pattern -> bool -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_flhs in + let _visitors_r1 = self#visit_pattern env _visitors_frhs in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_finclusive + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_pattern : _ -> pattern -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ppat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_alias env _visitors_fpat _visitors_falias - _visitors_floc_ - | Ppat_any { loc_ = _visitors_floc_ } -> - self#visit_Ppat_any env _visitors_floc_ - | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_array env _visitors_fpats _visitors_floc_ - | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Ppat_constant env _visitors_fc _visitors_floc_ - | Ppat_constraint - { - pat = _visitors_fpat; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constraint env _visitors_fpat _visitors_fty - _visitors_floc_ - | Ppat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - is_open = _visitors_fis_open; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs - _visitors_fis_open _visitors_floc_ - | Ppat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_floc_ - | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ - | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 - | Ppat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_record env _visitors_ffields - _visitors_fis_closed _visitors_floc_ - | Ppat_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Ppat_map env _visitors_felems _visitors_floc_ - | Ppat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_floc_ - - method visit_Closed : _ -> pattern list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - () - - method visit_Open - : _ -> pattern list -> pattern list -> binder option -> unit = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pattern env)) - _visitors_c1 - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_binder env) t - | None -> ()) - _visitors_c2 - in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ppat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_alias env _visitors_fpat _visitors_falias + _visitors_floc_ + | Ppat_any { loc_ = _visitors_floc_ } -> + self#visit_Ppat_any env _visitors_floc_ + | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_array env _visitors_fpats _visitors_floc_ + | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Ppat_constant env _visitors_fc _visitors_floc_ + | Ppat_constraint + { + pat = _visitors_fpat; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constraint env _visitors_fpat _visitors_fty + _visitors_floc_ + | Ppat_constr + { + constr = _visitors_fconstr; + args = _visitors_fargs; + is_open = _visitors_fis_open; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs + _visitors_fis_open _visitors_floc_ + | Ppat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_floc_ + | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ + | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 + | Ppat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_record env _visitors_ffields + _visitors_fis_closed _visitors_floc_ + | Ppat_map + { + elems = _visitors_felems; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_map env _visitors_felems _visitors_fis_closed + _visitors_floc_ + | Ppat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_floc_ + + method visit_Closed : _ -> array_pattern list -> unit = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_array_pattern env)) + _visitors_c0 + in + () + + method visit_Open : + _ -> + array_pattern list -> + array_pattern list -> + binder option -> + unit = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_array_pattern env)) + _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_array_pattern env)) + _visitors_c1 + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_binder env) t + | None -> ()) + _visitors_c2 + in + () + + method visit_array_patterns : _ -> array_patterns -> unit = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + + method visit_Pattern : _ -> pattern -> unit = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_pattern env _visitors_c0 in + () + + method visit_String_spread : _ -> string_literal -> unit = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + () + + method visit_String_spread_const : + _ -> binder -> string option -> location -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fpkg -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_fpkg + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_array_pattern : _ -> array_pattern -> unit = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pattern _visitors_c0 -> self#visit_Pattern env _visitors_c0 + | String_spread _visitors_c0 -> + self#visit_String_spread env _visitors_c0 + | String_spread_const + { + binder = _visitors_fbinder; + pkg = _visitors_fpkg; + loc_ = _visitors_floc_; + } -> + self#visit_String_spread_const env _visitors_fbinder + _visitors_fpkg _visitors_floc_ method visit_Field_def : _ -> label -> expr -> bool -> location -> unit = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pun in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_pun + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_field_def : _ -> field_def -> unit = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_pun _visitors_floc_ - - method visit_Field_pat - : _ -> label -> pattern -> bool -> location -> unit = - fun env _visitors_flabel _visitors_fpattern _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pattern env _visitors_fpattern in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pun in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_pun _visitors_floc_ + + method visit_Field_pat : + _ -> label -> pattern -> bool -> location -> unit = + fun env -> + fun _visitors_flabel -> + fun _visitors_fpattern -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pattern env _visitors_fpattern in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_pun + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_field_pat : _ -> field_pat -> unit = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pattern = _visitors_fpattern; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpattern - _visitors_fis_pun _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pattern = _visitors_fpattern; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpattern + _visitors_fis_pun _visitors_floc_ method visit_Constr_pat_arg : _ -> pattern -> argument_kind -> unit = - fun env _visitors_fpat _visitors_fkind -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - () + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + () method visit_constr_pat_arg : _ -> constr_pat_arg -> unit = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - - method visit_Map_pat_elem - : _ -> constant -> pattern -> bool -> location -> location -> unit = - fun env _visitors_fkey _visitors_fpat _visitors_fmatch_absent - _visitors_fkey_loc_ _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fkey in - let _visitors_r1 = self#visit_pattern env _visitors_fpat in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fmatch_absent - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fkey_loc_ in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } + -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + + method visit_Map_pat_elem : + _ -> constant -> pattern -> bool -> location -> location -> unit = + fun env -> + fun _visitors_fkey -> + fun _visitors_fpat -> + fun _visitors_fmatch_absent -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fkey in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fmatch_absent + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fkey_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_map_pat_elem : _ -> map_pat_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Map_pat_elem - { - key = _visitors_fkey; - pat = _visitors_fpat; - match_absent = _visitors_fmatch_absent; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat - _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_pat_elem + { + key = _visitors_fkey; + pat = _visitors_fpat; + match_absent = _visitors_fmatch_absent; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat + _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ method visit_constr_param : _ -> constr_param -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.cparam_mut - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_label env) t - | None -> ()) - _visitors_this.cparam_label - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.cparam_mut + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_this.cparam_label + in + () method visit_constr_decl : _ -> constr_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_constr_name env _visitors_this.constr_name - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (self#visit_constr_param env)) - t - | None -> ()) - _visitors_this.constr_args - in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.constr_loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_constr_name env _visitors_this.constr_name + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_constr_param env)) + t + | None -> ()) + _visitors_this.constr_args + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_c1 + in + ()) + t + | None -> ()) + _visitors_this.constr_tag + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_this.constr_loc_ + in + () method visit_field_name : _ -> field_name -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.label - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.label + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.loc_ + in + () method visit_field_decl : _ -> field_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_field_name env _visitors_this.field_name - in - let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.field_mut - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.field_loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_field_name env _visitors_this.field_name + in + let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.field_mut + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_this.field_loc_ + in + () method visit_No_payload : _ -> unit = fun env -> () method visit_Single_payload : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_Enum_payload : _ -> constr_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_decl env)) + _visitors_c0 + in + () method visit_exception_decl : _ -> exception_decl -> unit = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Ptd_abstract : _ -> unit = fun env -> () + method visit_Ptd_extern : _ -> unit = fun env -> () method visit_Ptd_newtype : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_Ptd_error : _ -> exception_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + () method visit_Ptd_variant : _ -> constr_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_decl env)) + _visitors_c0 + in + () method visit_Ptd_record : _ -> field_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_decl env)) + _visitors_c0 + in + () method visit_Ptd_alias : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_type_desc : _ -> type_desc -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ptd_abstract -> self#visit_Ptd_abstract env - | Ptd_newtype _visitors_c0 -> - self#visit_Ptd_newtype env _visitors_c0 - | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 - | Ptd_variant _visitors_c0 -> - self#visit_Ptd_variant env _visitors_c0 - | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 - | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptd_abstract -> self#visit_Ptd_abstract env + | Ptd_extern -> self#visit_Ptd_extern env + | Ptd_newtype _visitors_c0 -> + self#visit_Ptd_newtype env _visitors_c0 + | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 + | Ptd_variant _visitors_c0 -> + self#visit_Ptd_variant env _visitors_c0 + | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 + | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 method visit_type_decl : _ -> type_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.tycon - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.tycon_loc_ - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_type_decl_binder env)) - _visitors_this.params - in - let _visitors_r3 = - self#visit_type_desc env _visitors_this.components - in - let _visitors_r4 = self#visit_docstring env _visitors_this.doc_ in - let _visitors_r5 = - self#visit_visibility env _visitors_this.type_vis - in - let _visitors_r6 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (self#visit_deriving_directive env)) - _visitors_this.deriving_ - in - let _visitors_r7 = (fun _visitors_this -> ()) _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.tycon + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.tycon_loc_ + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_type_decl_binder env)) + _visitors_this.params + in + let _visitors_r3 = + self#visit_type_desc env _visitors_this.components + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_attribute env)) + _visitors_this.attrs + in + let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r6 = + self#visit_visibility env _visitors_this.type_vis + in + let _visitors_r7 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_deriving_directive env)) + _visitors_this.deriving_ + in + let _visitors_r8 = + (fun _visitors_this -> ()) _visitors_this.loc_ + in + () method visit_local_type_decl : _ -> local_type_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.local_tycon - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.local_tycon_loc_ - in - let _visitors_r2 = - self#visit_type_desc env _visitors_this.local_components - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.local_tycon + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.local_tycon_loc_ + in + let _visitors_r2 = + self#visit_type_desc env _visitors_this.local_components + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_deriving_directive env)) + _visitors_this.deriving_ + in + () method visit_deriving_directive : _ -> deriving_directive -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_name env _visitors_this.type_name_ - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_argument env)) - _visitors_this.args - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_name env _visitors_this.type_name_ + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_argument env)) + _visitors_this.args + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.loc_ + in + () method visit_Vis_default : _ -> unit = fun env -> () method visit_Vis_pub : _ -> string option -> location -> unit = - fun env _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (fun _visitors_this -> ()) t - | None -> ()) - _visitors_fattr - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_fattr + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Vis_priv : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_visibility : _ -> visibility -> unit = - fun env _visitors_this -> - match _visitors_this with - | Vis_default -> self#visit_Vis_default env - | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> - self#visit_Vis_pub env _visitors_fattr _visitors_floc_ - | Vis_priv { loc_ = _visitors_floc_ } -> - self#visit_Vis_priv env _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Vis_default -> self#visit_Vis_default env + | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> + self#visit_Vis_pub env _visitors_fattr _visitors_floc_ + | Vis_priv { loc_ = _visitors_floc_ } -> + self#visit_Vis_priv env _visitors_floc_ method visit_Import : _ -> string_literal -> string_literal -> unit = - fun env _visitors_fmodule_name _visitors_ffunc_name -> - let _visitors_r0 = - self#visit_string_literal env _visitors_fmodule_name - in - let _visitors_r1 = - self#visit_string_literal env _visitors_ffunc_name - in - () - - method visit_Embedded - : _ -> string_literal option -> embedded_code -> unit = - fun env _visitors_flanguage _visitors_fcode -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_string_literal env) t - | None -> ()) - _visitors_flanguage - in - let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in - () + fun env -> + fun _visitors_fmodule_name -> + fun _visitors_ffunc_name -> + let _visitors_r0 = + self#visit_string_literal env _visitors_fmodule_name + in + let _visitors_r1 = + self#visit_string_literal env _visitors_ffunc_name + in + () + + method visit_Embedded : + _ -> string_literal option -> embedded_code -> unit = + fun env -> + fun _visitors_flanguage -> + fun _visitors_fcode -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_string_literal env) t + | None -> ()) + _visitors_flanguage + in + let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in + () method visit_func_stubs : _ -> func_stubs -> unit = - fun env _visitors_this -> - match _visitors_this with - | Import - { - module_name = _visitors_fmodule_name; - func_name = _visitors_ffunc_name; - } -> - self#visit_Import env _visitors_fmodule_name - _visitors_ffunc_name - | Embedded - { language = _visitors_flanguage; code = _visitors_fcode } -> - self#visit_Embedded env _visitors_flanguage _visitors_fcode + fun env -> + fun _visitors_this -> + match _visitors_this with + | Import + { + module_name = _visitors_fmodule_name; + func_name = _visitors_ffunc_name; + } -> + self#visit_Import env _visitors_fmodule_name + _visitors_ffunc_name + | Embedded + { language = _visitors_flanguage; code = _visitors_fcode } -> + self#visit_Embedded env _visitors_flanguage _visitors_fcode method visit_Code_string : _ -> string_literal -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_string_literal env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + () method visit_Code_multiline_string : _ -> string list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun _visitors_this -> ())) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(fun _visitors_this -> ())) + _visitors_c0 + in + () method visit_embedded_code : _ -> embedded_code -> unit = - fun env _visitors_this -> - match _visitors_this with - | Code_string _visitors_c0 -> - self#visit_Code_string env _visitors_c0 - | Code_multiline_string _visitors_c0 -> - self#visit_Code_multiline_string env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Code_string _visitors_c0 -> + self#visit_Code_string env _visitors_c0 + | Code_multiline_string _visitors_c0 -> + self#visit_Code_multiline_string env _visitors_c0 method visit_Decl_body : _ -> local_type_decl list -> expr -> unit = - fun env _visitors_flocal_types _visitors_fexpr -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - () + fun env -> + fun _visitors_flocal_types -> + fun _visitors_fexpr -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + () method visit_Decl_stubs : _ -> func_stubs -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + () method visit_decl_body : _ -> decl_body -> unit = - fun env _visitors_this -> - match _visitors_this with - | Decl_body - { local_types = _visitors_flocal_types; expr = _visitors_fexpr } - -> - self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr - | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Decl_body + { + local_types = _visitors_flocal_types; + expr = _visitors_fexpr; + } -> + self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr + | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 method visit_fun_decl : _ -> fun_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_this.type_name - in - let _visitors_r1 = self#visit_binder env _visitors_this.name in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.has_error - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_parameters env) t - | None -> ()) - _visitors_this.decl_params - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.params_loc_ - in - let _visitors_r5 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_tvar_binder env)) - _visitors_this.quantifiers - in - let _visitors_r6 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - ()) - t - | None -> ()) - _visitors_this.return_type - in - let _visitors_r7 = - (fun _visitors_this -> ()) _visitors_this.is_pub - in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_this.type_name + in + let _visitors_r1 = self#visit_binder env _visitors_this.name in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (fun _visitors_this -> ()) t + | None -> ()) + _visitors_this.has_error + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_this.is_async + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_parameters env) t + | None -> ()) + _visitors_this.decl_params + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_this.params_loc_ + in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_tvar_binder env)) + _visitors_this.quantifiers + in + let _visitors_r7 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + ()) + t + | None -> ()) + _visitors_this.return_type + in + let _visitors_r8 = self#visit_visibility env _visitors_this.vis in + let _visitors_r9 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_attribute env)) + _visitors_this.attrs + in + let _visitors_r10 = self#visit_docstring env _visitors_this.doc_ in + () method visit_trait_method_param : _ -> trait_method_param -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_label env) t - | None -> ()) - _visitors_this.tmparam_label - in - () - - method visit_Trait_method - : _ -> - binder -> - bool -> - tvar_binder list -> - trait_method_param list -> - (typ * error_typ) option -> - location -> - unit = - fun env _visitors_fname _visitors_fhas_error _visitors_fquantifiers - _visitors_fparams _visitors_freturn_type _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fhas_error - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this - (self#visit_trait_method_param env)) - _visitors_fparams - in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - ()) - t - | None -> ()) - _visitors_freturn_type - in - let _visitors_r5 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_this.tmparam_label + in + () + + method visit_Trait_method : + _ -> + binder -> + bool -> + tvar_binder list -> + trait_method_param list -> + (typ * error_typ) option -> + location -> + unit = + fun env -> + fun _visitors_fname -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_freturn_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fhas_error + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_trait_method_param env)) + _visitors_fparams + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + ()) + t + | None -> ()) + _visitors_freturn_type + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_trait_method_decl : _ -> trait_method_decl -> unit = - fun env _visitors_this -> - match _visitors_this with - | Trait_method - { - name = _visitors_fname; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - return_type = _visitors_freturn_type; - loc_ = _visitors_floc_; - } -> - self#visit_Trait_method env _visitors_fname _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams - _visitors_freturn_type _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Trait_method + { + name = _visitors_fname; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + return_type = _visitors_freturn_type; + loc_ = _visitors_floc_; + } -> + self#visit_Trait_method env _visitors_fname + _visitors_fhas_error _visitors_fquantifiers _visitors_fparams + _visitors_freturn_type _visitors_floc_ method visit_trait_decl : _ -> trait_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.trait_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_tvar_constraint env)) - _visitors_this.trait_supers - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_trait_method_decl env)) - _visitors_this.trait_methods - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_this.trait_loc_ - in - let _visitors_r5 = - self#visit_docstring env _visitors_this.trait_doc_ - in - () - - method visit_Ptop_expr - : _ -> expr -> bool -> local_type_decl list -> absolute_loc -> unit - = - fun env _visitors_fexpr _visitors_fis_main _visitors_flocal_types - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fis_main in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ptop_test - : _ -> - expr -> - test_name -> - parameters option -> - local_type_decl list -> - absolute_loc -> - unit = - fun env _visitors_fexpr _visitors_fname _visitors_fparams - _visitors_flocal_types _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fname in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_parameters env) t - | None -> ()) - _visitors_fparams - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_binder env _visitors_this.trait_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_tvar_constraint env)) + _visitors_this.trait_supers + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_trait_method_decl env)) + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_this.trait_loc_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_attribute env)) + _visitors_this.trait_attrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_this.trait_doc_ + in + () + + method visit_Ptop_expr : + _ -> expr -> bool -> local_type_decl list -> absolute_loc -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_main + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ptop_test : + _ -> + expr -> + test_name -> + parameters option -> + local_type_decl list -> + absolute_loc -> + attribute list -> + docstring -> + unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fname + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_parameters env) t + | None -> ()) + _visitors_fparams + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_fdoc_ + in + () method visit_Ptop_typedef : _ -> type_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_decl env _visitors_c0 in - () - - method visit_Ptop_funcdef - : _ -> fun_decl -> decl_body -> absolute_loc -> unit = - fun env _visitors_ffun_decl _visitors_fdecl_body _visitors_floc_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_decl_body env _visitors_fdecl_body in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () - - method visit_Ptop_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - bool -> - absolute_loc -> - docstring -> - unit = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fis_pub _visitors_fis_constant _visitors_floc_ - _visitors_fdoc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fis_pub in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_fis_constant - in - let _visitors_r5 = (fun _visitors_this -> ()) _visitors_floc_ in - let _visitors_r6 = self#visit_docstring env _visitors_fdoc_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_decl env _visitors_c0 in + () + + method visit_Ptop_funcdef : + _ -> fun_decl -> decl_body -> absolute_loc -> unit = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_fdecl_body -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = + self#visit_decl_body env _visitors_fdecl_body + in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () + + method visit_Ptop_letdef : + _ -> + binder -> + typ option -> + expr -> + visibility -> + bool -> + absolute_loc -> + attribute list -> + docstring -> + unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fvis -> + fun _visitors_fis_constant -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + self#visit_binder env _visitors_fbinder + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fis_constant + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_floc_ + in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r7 = + self#visit_docstring env _visitors_fdoc_ + in + () method visit_Ptop_trait : _ -> trait_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in - () - - method visit_Ptop_impl - : _ -> - typ option -> - type_name -> - binder -> - bool -> - tvar_binder list -> - parameters -> - (typ * error_typ) option -> - expr -> - bool -> - local_type_decl list -> - absolute_loc -> - location -> - docstring -> - unit = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fmethod_name - _visitors_fhas_error _visitors_fquantifiers _visitors_fparams - _visitors_fret_ty _visitors_fbody _visitors_fis_pub - _visitors_flocal_types _visitors_floc_ _visitors_fheader_loc_ - _visitors_fdoc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fself_ty - in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_binder env _visitors_fmethod_name in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_fhas_error - in - let _visitors_r4 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r5 = self#visit_parameters env _visitors_fparams in - let _visitors_r6 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - ()) - t - | None -> ()) - _visitors_fret_ty - in - let _visitors_r7 = self#visit_expr env _visitors_fbody in - let _visitors_r8 = (fun _visitors_this -> ()) _visitors_fis_pub in - let _visitors_r9 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r10 = (fun _visitors_this -> ()) _visitors_floc_ in - let _visitors_r11 = - (fun _visitors_this -> ()) _visitors_fheader_loc_ - in - let _visitors_r12 = self#visit_docstring env _visitors_fdoc_ in - () - - method visit_Ptop_impl_relation - : _ -> - typ -> - type_name -> - tvar_binder list -> - bool -> - absolute_loc -> - unit = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fquantifiers - _visitors_fis_pub _visitors_floc_ -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fis_pub in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in + () + + method visit_Ptop_trait_alias : + _ -> + binder -> + type_name -> + visibility -> + absolute_loc -> + attribute list -> + docstring -> + unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ftarget -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_type_name env _visitors_ftarget + in + let _visitors_r2 = self#visit_visibility env _visitors_fvis in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_floc_ + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + () + + method visit_Ptop_impl : + _ -> + typ option -> + type_name -> + binder -> + bool -> + tvar_binder list -> + parameters -> + (typ * error_typ) option -> + decl_body -> + visibility -> + absolute_loc -> + location -> + attribute list -> + docstring -> + unit = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fmethod_name -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_fret_ty -> + fun _visitors_fbody -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fheader_loc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fself_ty + in + let _visitors_r1 = + self#visit_type_name env _visitors_ftrait + in + let _visitors_r2 = + self#visit_binder env _visitors_fmethod_name + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fhas_error + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r5 = + self#visit_parameters env _visitors_fparams + in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + ()) + t + | None -> ()) + _visitors_fret_ty + in + let _visitors_r7 = + self#visit_decl_body env _visitors_fbody + in + let _visitors_r8 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r9 = + (fun _visitors_this -> ()) _visitors_floc_ + in + let _visitors_r10 = + (fun _visitors_this -> ()) _visitors_fheader_loc_ + in + let _visitors_r11 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r12 = + self#visit_docstring env _visitors_fdoc_ + in + () + + method visit_Ptop_impl_relation : + _ -> + typ -> + type_name -> + tvar_binder list -> + bool -> + absolute_loc -> + unit = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fquantifiers -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_pub + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_floc_ + in + () method visit_impl : _ -> impl -> unit = - fun env _visitors_this -> - match _visitors_this with - | Ptop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main - _visitors_flocal_types _visitors_floc_ - | Ptop_test - { - expr = _visitors_fexpr; - name = _visitors_fname; - params = _visitors_fparams; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_test env _visitors_fexpr _visitors_fname - _visitors_fparams _visitors_flocal_types _visitors_floc_ - | Ptop_typedef _visitors_c0 -> - self#visit_Ptop_typedef env _visitors_c0 - | Ptop_funcdef - { - fun_decl = _visitors_ffun_decl; - decl_body = _visitors_fdecl_body; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_funcdef env _visitors_ffun_decl - _visitors_fdecl_body _visitors_floc_ - | Ptop_letdef - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - is_constant = _visitors_fis_constant; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fis_pub _visitors_fis_constant - _visitors_floc_ _visitors_fdoc_ - | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 - | Ptop_impl - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - method_name = _visitors_fmethod_name; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - ret_ty = _visitors_fret_ty; - body = _visitors_fbody; - is_pub = _visitors_fis_pub; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - header_loc_ = _visitors_fheader_loc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait - _visitors_fmethod_name _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams _visitors_fret_ty - _visitors_fbody _visitors_fis_pub _visitors_flocal_types - _visitors_floc_ _visitors_fheader_loc_ _visitors_fdoc_ - | Ptop_impl_relation - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - quantifiers = _visitors_fquantifiers; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_impl_relation env _visitors_fself_ty - _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main + _visitors_flocal_types _visitors_floc_ + | Ptop_test + { + expr = _visitors_fexpr; + name = _visitors_fname; + params = _visitors_fparams; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_test env _visitors_fexpr _visitors_fname + _visitors_fparams _visitors_flocal_types _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_typedef _visitors_c0 -> + self#visit_Ptop_typedef env _visitors_c0 + | Ptop_funcdef + { + fun_decl = _visitors_ffun_decl; + decl_body = _visitors_fdecl_body; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_funcdef env _visitors_ffun_decl + _visitors_fdecl_body _visitors_floc_ + | Ptop_letdef + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + vis = _visitors_fvis; + is_constant = _visitors_fis_constant; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fvis _visitors_fis_constant + _visitors_floc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 + | Ptop_trait_alias + { + binder = _visitors_fbinder; + target = _visitors_ftarget; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_trait_alias env _visitors_fbinder + _visitors_ftarget _visitors_fvis _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_impl + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + method_name = _visitors_fmethod_name; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + ret_ty = _visitors_fret_ty; + body = _visitors_fbody; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + header_loc_ = _visitors_fheader_loc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait + _visitors_fmethod_name _visitors_fhas_error + _visitors_fquantifiers _visitors_fparams _visitors_fret_ty + _visitors_fbody _visitors_fvis _visitors_floc_ + _visitors_fheader_loc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_impl_relation + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + quantifiers = _visitors_fquantifiers; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_impl_relation env _visitors_fself_ty + _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub + _visitors_floc_ method visit_Interp_lit : _ -> string -> string -> location -> unit = - fun env _visitors_fstr _visitors_frepr _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fstr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_frepr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fstr -> + fun _visitors_frepr -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fstr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_frepr in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Interp_expr : _ -> expr -> location -> unit = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_floc_ in + () method visit_Interp_source : _ -> Literal.interp_source -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_interp_source env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_interp_source env _visitors_c0 in + () method visit_interp_elem : _ -> interp_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit - { - str = _visitors_fstr; - repr = _visitors_frepr; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_lit env _visitors_fstr _visitors_frepr - _visitors_floc_ - | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ - | Interp_source _visitors_c0 -> - self#visit_Interp_source env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit + { + str = _visitors_fstr; + repr = _visitors_frepr; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_lit env _visitors_fstr _visitors_frepr + _visitors_floc_ + | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ + | Interp_source _visitors_c0 -> + self#visit_Interp_source env _visitors_c0 method visit_Multiline_string : _ -> string -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in + () method visit_Multiline_interp : _ -> interp_elem list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_interp_elem env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_interp_elem env)) + _visitors_c0 + in + () method visit_multiline_string_elem : _ -> multiline_string_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Multiline_string _visitors_c0 -> - self#visit_Multiline_string env _visitors_c0 - | Multiline_interp _visitors_c0 -> - self#visit_Multiline_interp env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Multiline_string _visitors_c0 -> + self#visit_Multiline_string env _visitors_c0 + | Multiline_interp _visitors_c0 -> + self#visit_Multiline_interp env _visitors_c0 method visit_impls : _ -> impls -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_impl env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_impl env) end [@@@VISITORS.END] @@ -6386,3058 +8031,3861 @@ include struct object (self : 'self) inherit [_] mapbase - method visit_Pexpr_apply - : _ -> expr -> argument list -> apply_attr -> location -> expr = - fun env _visitors_ffunc _visitors_fargs _visitors_fattr - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fattr - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_apply - { - func = _visitors_r0; - args = _visitors_r1; - attr = _visitors_r2; - loc_ = _visitors_r3; - } + method visit_Pexpr_apply : + _ -> expr -> argument list -> apply_attr -> location -> expr = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fattr + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_apply + { + func = _visitors_r0; + args = _visitors_r1; + attr = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Pexpr_infix : _ -> var -> expr -> expr -> location -> expr = - fun env _visitors_fop _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_flhs in - let _visitors_r2 = self#visit_expr env _visitors_frhs in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_infix - { - op = _visitors_r0; - lhs = _visitors_r1; - rhs = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fop -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_flhs in + let _visitors_r2 = self#visit_expr env _visitors_frhs in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_infix + { + op = _visitors_r0; + lhs = _visitors_r1; + rhs = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Pexpr_unary : _ -> var -> expr -> location -> expr = - fun env _visitors_fop _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_unary - { op = _visitors_r0; expr = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fop -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_unary + { op = _visitors_r0; expr = _visitors_r1; loc_ = _visitors_r2 } method visit_Pexpr_array : _ -> expr list -> location -> expr = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array { exprs = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_array_spread - : _ -> spreadable_elem list -> location -> expr = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_spreadable_elem env)) - _visitors_felems - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array_spread { elems = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array { exprs = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Pexpr_array_spread : + _ -> spreadable_elem list -> location -> expr = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_spreadable_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array_spread { elems = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_array_get : _ -> expr -> expr -> location -> expr = - fun env _visitors_farray _visitors_findex _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array_get - { - array = _visitors_r0; - index = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Pexpr_array_get_slice - : _ -> - expr -> - expr option -> - expr option -> - location -> - location -> - expr = - fun env _visitors_farray _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fstart_index - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fend_index - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_findex_loc_ - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array_get_slice - { - array = _visitors_r0; - start_index = _visitors_r1; - end_index = _visitors_r2; - index_loc_ = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Pexpr_array_set - : _ -> expr -> expr -> expr -> location -> expr = - fun env _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_farray in - let _visitors_r1 = self#visit_expr env _visitors_findex in - let _visitors_r2 = self#visit_expr env _visitors_fvalue in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array_set - { - array = _visitors_r0; - index = _visitors_r1; - value = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_array_augmented_set - : _ -> var -> expr -> expr -> expr -> location -> expr = - fun env _visitors_fop _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fop in - let _visitors_r1 = self#visit_expr env _visitors_farray in - let _visitors_r2 = self#visit_expr env _visitors_findex in - let _visitors_r3 = self#visit_expr env _visitors_fvalue in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_array_augmented_set - { - op = _visitors_r0; - array = _visitors_r1; - index = _visitors_r2; - value = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array_get + { + array = _visitors_r0; + index = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_array_get_slice : + _ -> + expr -> + expr option -> + expr option -> + location -> + location -> + expr = + fun env -> + fun _visitors_farray -> + fun _visitors_fstart_index -> + fun _visitors_fend_index -> + fun _visitors_findex_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fstart_index + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fend_index + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_findex_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array_get_slice + { + array = _visitors_r0; + start_index = _visitors_r1; + end_index = _visitors_r2; + index_loc_ = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Pexpr_array_set : + _ -> expr -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_expr env _visitors_findex in + let _visitors_r2 = self#visit_expr env _visitors_fvalue in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array_set + { + array = _visitors_r0; + index = _visitors_r1; + value = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_array_augmented_set : + _ -> var -> expr -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_fop -> + fun _visitors_farray -> + fun _visitors_findex -> + fun _visitors_fvalue -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fop in + let _visitors_r1 = self#visit_expr env _visitors_farray in + let _visitors_r2 = self#visit_expr env _visitors_findex in + let _visitors_r3 = self#visit_expr env _visitors_fvalue in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_array_augmented_set + { + op = _visitors_r0; + array = _visitors_r1; + index = _visitors_r2; + value = _visitors_r3; + loc_ = _visitors_r4; + } method visit_Pexpr_constant : _ -> constant -> location -> expr = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_constant { c = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_multiline_string - : _ -> multiline_string_elem list -> location -> expr = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (self#visit_multiline_string_elem env)) - _visitors_felems - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_multiline_string { elems = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_constant { c = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Pexpr_multiline_string : + _ -> multiline_string_elem list -> location -> expr = + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_multiline_string_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_multiline_string + { elems = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_interp : _ -> interp_elem list -> location -> expr = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_interp_elem env)) - _visitors_felems - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_interp { elems = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_interp_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_interp { elems = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_constraint : _ -> expr -> typ -> location -> expr = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_constraint - { expr = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_constraint + { expr = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Pexpr_constr : _ -> constructor -> location -> expr = - fun env _visitors_fconstr _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_constr { constr = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_while - : _ -> expr -> expr -> expr option -> location -> expr = - fun env _visitors_floop_cond _visitors_floop_body - _visitors_fwhile_else _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fwhile_else - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_while - { - loop_cond = _visitors_r0; - loop_body = _visitors_r1; - while_else = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fconstr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constructor env _visitors_fconstr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_constr { constr = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Pexpr_while : + _ -> expr -> expr -> expr option -> label option -> location -> expr + = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fwhile_else + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_while + { + loop_cond = _visitors_r0; + loop_body = _visitors_r1; + while_else = _visitors_r2; + label = _visitors_r3; + loc_ = _visitors_r4; + } method visit_Pexpr_function : _ -> func -> location -> expr = - fun env _visitors_ffunc _visitors_floc_ -> - let _visitors_r0 = self#visit_func env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_function { func = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_ffunc -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_func env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_function { func = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_ident : _ -> var -> location -> expr = - fun env _visitors_fid _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_ident { id = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_if - : _ -> expr -> expr -> expr option -> location -> expr = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fifnot - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_if - { - cond = _visitors_r0; - ifso = _visitors_r1; - ifnot = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_guard - : _ -> expr -> expr option -> expr -> location -> expr = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_guard - { - cond = _visitors_r0; - otherwise = _visitors_r1; - body = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_guard_let - : _ -> - pattern -> - expr -> - (pattern * expr) list option -> - expr -> - location -> - expr = - fun env _visitors_fpat _visitors_fexpr _visitors_fotherwise - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = - self#visit_expr env _visitors_c1 - in - (_visitors_r0, _visitors_r1))) - t) - | None -> None) - _visitors_fotherwise - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_guard_let - { - pat = _visitors_r0; - expr = _visitors_r1; - otherwise = _visitors_r2; - body = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Pexpr_letfn - : _ -> binder -> func -> expr -> location -> expr = - fun env _visitors_fname _visitors_ffunc _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = self#visit_func env _visitors_ffunc in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_letfn - { - name = _visitors_r0; - func = _visitors_r1; - body = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_letrec - : _ -> (binder * func) list -> expr -> location -> expr = - fun env _visitors_fbindings _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_func env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_letrec - { - bindings = _visitors_r0; - body = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Pexpr_let - : _ -> pattern -> expr -> expr -> location -> expr = - fun env _visitors_fpattern _visitors_fexpr _visitors_fbody - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpattern in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_let - { - pattern = _visitors_r0; - expr = _visitors_r1; - body = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_sequence : _ -> expr -> expr -> location -> expr = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_sequence - { - expr1 = _visitors_r0; - expr2 = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_fid -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_ident { id = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Pexpr_if : + _ -> expr -> expr -> expr option -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fifnot + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_if + { + cond = _visitors_r0; + ifso = _visitors_r1; + ifnot = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_guard : + _ -> expr -> expr option -> expr -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_guard + { + cond = _visitors_r0; + otherwise = _visitors_r1; + body = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_guard_let : + _ -> pattern -> expr -> case list option -> expr -> location -> expr + = + fun env -> + fun _visitors_fpat -> + fun _visitors_fexpr -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_case env)) + t) + | None -> None) + _visitors_fotherwise + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_guard_let + { + pat = _visitors_r0; + expr = _visitors_r1; + otherwise = _visitors_r2; + body = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Pexpr_is : _ -> expr -> pattern -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_is + { + expr = _visitors_r0; + pat = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_letfn : + _ -> binder -> func -> expr -> location -> expr = + fun env -> + fun _visitors_fname -> + fun _visitors_ffunc -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = self#visit_func env _visitors_ffunc in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_letfn + { + name = _visitors_r0; + func = _visitors_r1; + body = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_letrec : + _ -> (binder * func) list -> expr -> location -> expr = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_func env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_letrec + { + bindings = _visitors_r0; + body = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_let : + _ -> pattern -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_fpattern -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpattern in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_let + { + pattern = _visitors_r0; + expr = _visitors_r1; + body = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_sequence : _ -> expr list -> expr -> location -> expr + = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_sequence + { + exprs = _visitors_r0; + last_expr = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Pexpr_tuple : _ -> expr list -> location -> expr = - fun env _visitors_fexprs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_tuple { exprs = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_record - : _ -> - type_name option -> - field_def list -> - trailing_mark -> - location -> - expr = - fun env _visitors_ftype_name _visitors_ffields _visitors_ftrailing - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_ftype_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ftrailing - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_record - { - type_name = _visitors_r0; - fields = _visitors_r1; - trailing = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_record_update - : _ -> - type_name option -> - expr -> - field_def list -> - location -> - expr = - fun env _visitors_ftype_name _visitors_frecord _visitors_ffields - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_record_update - { - type_name = _visitors_r0; - record = _visitors_r1; - fields = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fexprs -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_tuple { exprs = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Pexpr_record : + _ -> + type_name option -> + field_def list -> + trailing_mark -> + location -> + expr = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_ftrailing -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_ftrailing + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_record + { + type_name = _visitors_r0; + fields = _visitors_r1; + trailing = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_record_update : + _ -> type_name option -> expr -> field_def list -> location -> expr + = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_ffields -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_record_update + { + type_name = _visitors_r0; + record = _visitors_r1; + fields = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Pexpr_field : _ -> expr -> accessor -> location -> expr = - fun env _visitors_frecord _visitors_faccessor _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_field - { - record = _visitors_r0; - accessor = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_field + { + record = _visitors_r0; + accessor = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Pexpr_method : _ -> type_name -> label -> location -> expr = - fun env _visitors_ftype_name _visitors_fmethod_name _visitors_floc_ -> - let _visitors_r0 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_method - { - type_name = _visitors_r0; - method_name = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Pexpr_dot_apply - : _ -> - expr -> - label -> - argument list -> - bool -> - apply_attr -> - location -> - expr = - fun env _visitors_fself _visitors_fmethod_name _visitors_fargs - _visitors_freturn_self _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fself in - let _visitors_r1 = self#visit_label env _visitors_fmethod_name in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_freturn_self - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fattr - in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_dot_apply - { - self = _visitors_r0; - method_name = _visitors_r1; - args = _visitors_r2; - return_self = _visitors_r3; - attr = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fmethod_name -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r1 = self#visit_label env _visitors_fmethod_name in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_method + { + type_name = _visitors_r0; + method_name = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_dot_apply : + _ -> + expr -> + label -> + argument list -> + bool -> + apply_attr -> + location -> + expr = + fun env -> + fun _visitors_fself -> + fun _visitors_fmethod_name -> + fun _visitors_fargs -> + fun _visitors_freturn_self -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fself in + let _visitors_r1 = + self#visit_label env _visitors_fmethod_name + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_argument env)) + _visitors_fargs + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) + _visitors_freturn_self + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fattr + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_dot_apply + { + self = _visitors_r0; + method_name = _visitors_r1; + args = _visitors_r2; + return_self = _visitors_r3; + attr = _visitors_r4; + loc_ = _visitors_r5; + } method visit_Pexpr_as : _ -> expr -> type_name -> location -> expr = - fun env _visitors_fexpr _visitors_ftrait _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_as - { expr = _visitors_r0; trait = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Pexpr_mutate - : _ -> expr -> accessor -> expr -> var option -> location -> expr = - fun env _visitors_frecord _visitors_faccessor _visitors_ffield - _visitors_faugmented_by _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_var env) t) - | None -> None) - _visitors_faugmented_by - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_mutate - { - record = _visitors_r0; - accessor = _visitors_r1; - field = _visitors_r2; - augmented_by = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Pexpr_match - : _ -> expr -> (pattern * expr) list -> location -> location -> expr - = - fun env _visitors_fexpr _visitors_fcases _visitors_fmatch_loc_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fmatch_loc_ - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_match - { - expr = _visitors_r0; - cases = _visitors_r1; - match_loc_ = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_letmut - : _ -> binder -> typ option -> expr -> expr -> location -> expr = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fbody _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_letmut - { - binder = _visitors_r0; - ty = _visitors_r1; - expr = _visitors_r2; - body = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_as + { + expr = _visitors_r0; + trait = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_mutate : + _ -> expr -> accessor -> expr -> var option -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_ffield -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = + self#visit_accessor env _visitors_faccessor + in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_var env) t) + | None -> None) + _visitors_faugmented_by + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_mutate + { + record = _visitors_r0; + accessor = _visitors_r1; + field = _visitors_r2; + augmented_by = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Pexpr_match : + _ -> expr -> case list -> location -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_case env)) + _visitors_fcases + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fmatch_loc_ + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_match + { + expr = _visitors_r0; + cases = _visitors_r1; + match_loc_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Pexpr_letmut : + _ -> binder -> typ option -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_letmut + { + binder = _visitors_r0; + ty = _visitors_r1; + expr = _visitors_r2; + body = _visitors_r3; + loc_ = _visitors_r4; + } method visit_Pexpr_pipe : _ -> expr -> expr -> location -> expr = - fun env _visitors_flhs _visitors_frhs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_pipe - { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Pexpr_assign - : _ -> var -> expr -> var option -> location -> expr = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_var env) t) - | None -> None) - _visitors_faugmented_by - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_assign - { - var = _visitors_r0; - expr = _visitors_r1; - augmented_by = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_pipe + { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Pexpr_assign : + _ -> var -> expr -> var option -> location -> expr = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_var env) t) + | None -> None) + _visitors_faugmented_by + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_assign + { + var = _visitors_r0; + expr = _visitors_r1; + augmented_by = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Pexpr_hole : _ -> location -> hole -> expr = - fun env _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - let _visitors_r1 = self#visit_hole env _visitors_fkind in - Pexpr_hole { loc_ = _visitors_r0; kind = _visitors_r1 } + fun env -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r1 = self#visit_hole env _visitors_fkind in + Pexpr_hole { loc_ = _visitors_r0; kind = _visitors_r1 } method visit_Pexpr_return : _ -> expr option -> location -> expr = - fun env _visitors_freturn_value _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_freturn_value - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_return { return_value = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_freturn_value -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_freturn_value + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_return { return_value = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_raise : _ -> expr -> location -> expr = - fun env _visitors_ferr_value _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferr_value in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_raise { err_value = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_ferr_value -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferr_value in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_raise { err_value = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_unit : _ -> location -> bool -> expr = - fun env _visitors_floc_ _visitors_ffaked -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_ffaked - in - Pexpr_unit { loc_ = _visitors_r0; faked = _visitors_r1 } - - method visit_Pexpr_break : _ -> expr option -> location -> expr = - fun env _visitors_farg _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_break { arg = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_continue : _ -> expr list -> location -> expr = - fun env _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_continue { args = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Pexpr_loop - : _ -> - expr list -> - (pattern list * expr) list -> - location -> - location -> - expr = - fun env _visitors_fargs _visitors_fbody _visitors_floop_loc_ - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = + fun env -> + fun _visitors_floc_ -> + fun _visitors_ffaked -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_ffaked + in + Pexpr_unit { loc_ = _visitors_r0; faked = _visitors_r1 } + + method visit_Pexpr_break : + _ -> expr option -> label option -> location -> expr = + fun env -> + fun _visitors_farg -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_farg + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_break + { + arg = _visitors_r0; + label = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_continue : + _ -> expr list -> label option -> location -> expr = + fun env -> + fun _visitors_fargs -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_continue + { + args = _visitors_r0; + label = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_loop : + _ -> + expr list -> + multi_arg_case list -> + label option -> + location -> + location -> + expr = + fun env -> + fun _visitors_fargs -> + fun _visitors_fbody -> + fun _visitors_flabel -> + fun _visitors_floop_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_multi_arg_case env)) + _visitors_fbody + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floop_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_loop + { + args = _visitors_r0; + body = _visitors_r1; + label = _visitors_r2; + loop_loc_ = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Pexpr_for : + _ -> + (binder * expr) list -> + expr option -> + (binder * expr) list -> + expr -> + expr option -> + label option -> + location -> + expr = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fcontinue_block -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = + self#visit_expr env _visitors_c1 + in + (_visitors_r0, _visitors_r1))) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fcondition + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = + self#visit_expr env _visitors_c1 + in + (_visitors_r0, _visitors_r1))) + _visitors_fcontinue_block + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_ffor_else + in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r6 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_for + { + binders = _visitors_r0; + condition = _visitors_r1; + continue_block = _visitors_r2; + body = _visitors_r3; + for_else = _visitors_r4; + label = _visitors_r5; + loc_ = _visitors_r6; + } + + method visit_Pexpr_foreach : + _ -> + binder option list -> + expr -> + expr -> + expr option -> + label option -> + location -> + expr = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_binder env) t) + | None -> None)) + _visitors_fbinders + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_felse_block + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_foreach + { + binders = _visitors_r0; + expr = _visitors_r1; + body = _visitors_r2; + else_block = _visitors_r3; + label = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Pexpr_try : + _ -> + expr -> + case list -> + bool -> + case list option -> + location -> + location -> + location -> + location -> + expr = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_ftry_loc_ -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_c0 + Basic_lst.map _visitors_this (self#visit_case env)) + _visitors_fcatch in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbody - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floop_loc_ - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_loop - { - args = _visitors_r0; - body = _visitors_r1; - loop_loc_ = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Pexpr_for - : _ -> - (binder * expr) list -> - expr option -> - (binder * expr) list -> - expr -> - expr option -> - location -> - expr = - fun env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fcondition - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcontinue_block - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_ffor_else - in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_for - { - binders = _visitors_r0; - condition = _visitors_r1; - continue_block = _visitors_r2; - body = _visitors_r3; - for_else = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Pexpr_foreach - : _ -> - binder option list -> - expr -> - expr -> - expr option -> - location -> - expr = - fun env _visitors_fbinders _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_binder env) t) - | None -> None)) - _visitors_fbinders - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_felse_block - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_foreach - { - binders = _visitors_r0; - expr = _visitors_r1; - body = _visitors_r2; - else_block = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Pexpr_try - : _ -> - expr -> - (pattern * expr) list -> - bool -> - (pattern * expr) list option -> - location -> - location -> - location -> - location -> - expr = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_ftry_loc_ _visitors_fcatch_loc_ - _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_pattern env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcatch - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fcatch_all - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_pattern env _visitors_c0 - in - let _visitors_r1 = - self#visit_expr env _visitors_c1 - in - (_visitors_r0, _visitors_r1))) - t) - | None -> None) - _visitors_ftry_else - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_ftry_loc_ - in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_fcatch_loc_ - in - let _visitors_r6 = - (fun _visitors_this -> _visitors_this) _visitors_felse_loc_ - in - let _visitors_r7 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_try - { - body = _visitors_r0; - catch = _visitors_r1; - catch_all = _visitors_r2; - try_else = _visitors_r3; - try_loc_ = _visitors_r4; - catch_loc_ = _visitors_r5; - else_loc_ = _visitors_r6; - loc_ = _visitors_r7; - } + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) + _visitors_fcatch_all + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_case env)) + t) + | None -> None) + _visitors_ftry_else + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_ftry_loc_ + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) + _visitors_fcatch_loc_ + in + let _visitors_r6 = + (fun _visitors_this -> _visitors_this) + _visitors_felse_loc_ + in + let _visitors_r7 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_try + { + body = _visitors_r0; + catch = _visitors_r1; + catch_all = _visitors_r2; + try_else = _visitors_r3; + try_loc_ = _visitors_r4; + catch_loc_ = _visitors_r5; + else_loc_ = _visitors_r6; + loc_ = _visitors_r7; + } method visit_Pexpr_map : _ -> map_expr_elem list -> location -> expr = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_map_expr_elem env)) - _visitors_felems - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_map { elems = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_felems -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_map_expr_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_map { elems = _visitors_r0; loc_ = _visitors_r1 } method visit_Pexpr_group : _ -> expr -> group -> location -> expr = - fun env _visitors_fexpr _visitors_fgroup _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fgroup - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Pexpr_group - { expr = _visitors_r0; group = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Pexpr_static_assert - : _ -> static_assertion list -> expr -> expr = - fun env _visitors_fasserts _visitors_fbody -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_static_assertion env)) - _visitors_fasserts - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - Pexpr_static_assert { asserts = _visitors_r0; body = _visitors_r1 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_fgroup -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fgroup + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Pexpr_group + { + expr = _visitors_r0; + group = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Pexpr_static_assert : + _ -> static_assertion list -> expr -> expr = + fun env -> + fun _visitors_fasserts -> + fun _visitors_fbody -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_static_assertion env)) + _visitors_fasserts + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + Pexpr_static_assert + { asserts = _visitors_r0; body = _visitors_r1 } method visit_expr : _ -> expr -> expr = - fun env _visitors_this -> - match _visitors_this with - | Pexpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fattr _visitors_floc_ - | Pexpr_infix - { - op = _visitors_fop; - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_infix env _visitors_fop _visitors_flhs - _visitors_frhs _visitors_floc_ - | Pexpr_unary - { - op = _visitors_fop; - expr = _visitors_fexpr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr - _visitors_floc_ - | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ - | Pexpr_array_spread - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_array_spread env _visitors_felems - _visitors_floc_ - | Pexpr_array_get - { - array = _visitors_farray; - index = _visitors_findex; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get env _visitors_farray _visitors_findex - _visitors_floc_ - | Pexpr_array_get_slice - { - array = _visitors_farray; - start_index = _visitors_fstart_index; - end_index = _visitors_fend_index; - index_loc_ = _visitors_findex_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_get_slice env _visitors_farray - _visitors_fstart_index _visitors_fend_index - _visitors_findex_loc_ _visitors_floc_ - | Pexpr_array_set - { - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_set env _visitors_farray _visitors_findex - _visitors_fvalue _visitors_floc_ - | Pexpr_array_augmented_set - { - op = _visitors_fop; - array = _visitors_farray; - index = _visitors_findex; - value = _visitors_fvalue; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_array_augmented_set env _visitors_fop - _visitors_farray _visitors_findex _visitors_fvalue - _visitors_floc_ - | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ - | Pexpr_multiline_string - { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_multiline_string env _visitors_felems - _visitors_floc_ - | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ - | Pexpr_constraint - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty - _visitors_floc_ - | Pexpr_constr - { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ - | Pexpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_floc_ - | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ - | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ - | Pexpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_floc_ - | Pexpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_floc_ - | Pexpr_guard_let - { - pat = _visitors_fpat; - expr = _visitors_fexpr; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr - _visitors_fotherwise _visitors_fbody _visitors_floc_ - | Pexpr_letfn - { - name = _visitors_fname; - func = _visitors_ffunc; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc - _visitors_fbody _visitors_floc_ - | Pexpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_floc_ - | Pexpr_let - { - pattern = _visitors_fpattern; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr - _visitors_fbody _visitors_floc_ - | Pexpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_floc_ - | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ - | Pexpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - trailing = _visitors_ftrailing; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record env _visitors_ftype_name - _visitors_ffields _visitors_ftrailing _visitors_floc_ - | Pexpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - fields = _visitors_ffields; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_ffields _visitors_floc_ - | Pexpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_field env _visitors_frecord _visitors_faccessor - _visitors_floc_ - | Pexpr_method - { - type_name = _visitors_ftype_name; - method_name = _visitors_fmethod_name; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_method env _visitors_ftype_name - _visitors_fmethod_name _visitors_floc_ - | Pexpr_dot_apply - { - self = _visitors_fself; - method_name = _visitors_fmethod_name; - args = _visitors_fargs; - return_self = _visitors_freturn_self; - attr = _visitors_fattr; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_dot_apply env _visitors_fself - _visitors_fmethod_name _visitors_fargs _visitors_freturn_self - _visitors_fattr _visitors_floc_ - | Pexpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait - _visitors_floc_ - | Pexpr_mutate - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - field = _visitors_ffield; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_mutate env _visitors_frecord - _visitors_faccessor _visitors_ffield _visitors_faugmented_by - _visitors_floc_ - | Pexpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases - _visitors_fmatch_loc_ _visitors_floc_ - | Pexpr_letmut - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - body = _visitors_fbody; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fbody _visitors_floc_ - | Pexpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs - _visitors_floc_ - | Pexpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_floc_ - | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> - self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind - | Pexpr_return - { - return_value = _visitors_freturn_value; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_return env _visitors_freturn_value - _visitors_floc_ - | Pexpr_raise - { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ - | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } -> - self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked - | Pexpr_break { arg = _visitors_farg; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_break env _visitors_farg _visitors_floc_ - | Pexpr_continue { args = _visitors_fargs; loc_ = _visitors_floc_ } - -> - self#visit_Pexpr_continue env _visitors_fargs _visitors_floc_ - | Pexpr_loop - { - args = _visitors_fargs; - body = _visitors_fbody; - loop_loc_ = _visitors_floop_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody - _visitors_floop_loc_ _visitors_floc_ - | Pexpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - continue_block = _visitors_fcontinue_block; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fcontinue_block _visitors_fbody _visitors_ffor_else - _visitors_floc_ - | Pexpr_foreach - { - binders = _visitors_fbinders; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_floc_ - | Pexpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - try_loc_ = _visitors_ftry_loc_; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ - | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Pexpr_map env _visitors_felems _visitors_floc_ - | Pexpr_group - { - expr = _visitors_fexpr; - group = _visitors_fgroup; - loc_ = _visitors_floc_; - } -> - self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup - _visitors_floc_ - | Pexpr_static_assert - { asserts = _visitors_fasserts; body = _visitors_fbody } -> - self#visit_Pexpr_static_assert env _visitors_fasserts - _visitors_fbody - - method visit_static_assertion - : _ -> static_assertion -> static_assertion = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in - let _visitors_r1 = - self#visit_longident env _visitors_this.assert_trait - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.assert_loc - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_this.assert_msg - in - { - assert_type = _visitors_r0; - assert_trait = _visitors_r1; - assert_loc = _visitors_r2; - assert_msg = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pexpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fattr _visitors_floc_ + | Pexpr_infix + { + op = _visitors_fop; + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_infix env _visitors_fop _visitors_flhs + _visitors_frhs _visitors_floc_ + | Pexpr_unary + { + op = _visitors_fop; + expr = _visitors_fexpr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_unary env _visitors_fop _visitors_fexpr + _visitors_floc_ + | Pexpr_array { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_array env _visitors_fexprs _visitors_floc_ + | Pexpr_array_spread + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_array_spread env _visitors_felems + _visitors_floc_ + | Pexpr_array_get + { + array = _visitors_farray; + index = _visitors_findex; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get env _visitors_farray + _visitors_findex _visitors_floc_ + | Pexpr_array_get_slice + { + array = _visitors_farray; + start_index = _visitors_fstart_index; + end_index = _visitors_fend_index; + index_loc_ = _visitors_findex_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_get_slice env _visitors_farray + _visitors_fstart_index _visitors_fend_index + _visitors_findex_loc_ _visitors_floc_ + | Pexpr_array_set + { + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_set env _visitors_farray + _visitors_findex _visitors_fvalue _visitors_floc_ + | Pexpr_array_augmented_set + { + op = _visitors_fop; + array = _visitors_farray; + index = _visitors_findex; + value = _visitors_fvalue; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_array_augmented_set env _visitors_fop + _visitors_farray _visitors_findex _visitors_fvalue + _visitors_floc_ + | Pexpr_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constant env _visitors_fc _visitors_floc_ + | Pexpr_multiline_string + { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_multiline_string env _visitors_felems + _visitors_floc_ + | Pexpr_interp { elems = _visitors_felems; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_interp env _visitors_felems _visitors_floc_ + | Pexpr_constraint + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_constraint env _visitors_fexpr _visitors_fty + _visitors_floc_ + | Pexpr_constr + { constr = _visitors_fconstr; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_constr env _visitors_fconstr _visitors_floc_ + | Pexpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_flabel + _visitors_floc_ + | Pexpr_function { func = _visitors_ffunc; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_function env _visitors_ffunc _visitors_floc_ + | Pexpr_ident { id = _visitors_fid; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_ident env _visitors_fid _visitors_floc_ + | Pexpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_floc_ + | Pexpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_floc_ + | Pexpr_guard_let + { + pat = _visitors_fpat; + expr = _visitors_fexpr; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_guard_let env _visitors_fpat _visitors_fexpr + _visitors_fotherwise _visitors_fbody _visitors_floc_ + | Pexpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_is env _visitors_fexpr _visitors_fpat + _visitors_floc_ + | Pexpr_letfn + { + name = _visitors_fname; + func = _visitors_ffunc; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letfn env _visitors_fname _visitors_ffunc + _visitors_fbody _visitors_floc_ + | Pexpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_floc_ + | Pexpr_let + { + pattern = _visitors_fpattern; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_let env _visitors_fpattern _visitors_fexpr + _visitors_fbody _visitors_floc_ + | Pexpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_floc_ + | Pexpr_tuple { exprs = _visitors_fexprs; loc_ = _visitors_floc_ } + -> + self#visit_Pexpr_tuple env _visitors_fexprs _visitors_floc_ + | Pexpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + trailing = _visitors_ftrailing; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record env _visitors_ftype_name + _visitors_ffields _visitors_ftrailing _visitors_floc_ + | Pexpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + fields = _visitors_ffields; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_ffields _visitors_floc_ + | Pexpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_field env _visitors_frecord + _visitors_faccessor _visitors_floc_ + | Pexpr_method + { + type_name = _visitors_ftype_name; + method_name = _visitors_fmethod_name; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_method env _visitors_ftype_name + _visitors_fmethod_name _visitors_floc_ + | Pexpr_dot_apply + { + self = _visitors_fself; + method_name = _visitors_fmethod_name; + args = _visitors_fargs; + return_self = _visitors_freturn_self; + attr = _visitors_fattr; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_dot_apply env _visitors_fself + _visitors_fmethod_name _visitors_fargs _visitors_freturn_self + _visitors_fattr _visitors_floc_ + | Pexpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_as env _visitors_fexpr _visitors_ftrait + _visitors_floc_ + | Pexpr_mutate + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + field = _visitors_ffield; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_mutate env _visitors_frecord + _visitors_faccessor _visitors_ffield _visitors_faugmented_by + _visitors_floc_ + | Pexpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_match env _visitors_fexpr _visitors_fcases + _visitors_fmatch_loc_ _visitors_floc_ + | Pexpr_letmut + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + body = _visitors_fbody; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_letmut env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fbody _visitors_floc_ + | Pexpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_pipe env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Pexpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_floc_ + | Pexpr_hole { loc_ = _visitors_floc_; kind = _visitors_fkind } -> + self#visit_Pexpr_hole env _visitors_floc_ _visitors_fkind + | Pexpr_return + { + return_value = _visitors_freturn_value; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_return env _visitors_freturn_value + _visitors_floc_ + | Pexpr_raise + { err_value = _visitors_ferr_value; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_raise env _visitors_ferr_value _visitors_floc_ + | Pexpr_unit { loc_ = _visitors_floc_; faked = _visitors_ffaked } + -> + self#visit_Pexpr_unit env _visitors_floc_ _visitors_ffaked + | Pexpr_break + { + arg = _visitors_farg; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_break env _visitors_farg _visitors_flabel + _visitors_floc_ + | Pexpr_continue + { + args = _visitors_fargs; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_continue env _visitors_fargs _visitors_flabel + _visitors_floc_ + | Pexpr_loop + { + args = _visitors_fargs; + body = _visitors_fbody; + label = _visitors_flabel; + loop_loc_ = _visitors_floop_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_loop env _visitors_fargs _visitors_fbody + _visitors_flabel _visitors_floop_loc_ _visitors_floc_ + | Pexpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + continue_block = _visitors_fcontinue_block; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_for env _visitors_fbinders + _visitors_fcondition _visitors_fcontinue_block + _visitors_fbody _visitors_ffor_else _visitors_flabel + _visitors_floc_ + | Pexpr_foreach + { + binders = _visitors_fbinders; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_foreach env _visitors_fbinders _visitors_fexpr + _visitors_fbody _visitors_felse_block _visitors_flabel + _visitors_floc_ + | Pexpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + try_loc_ = _visitors_ftry_loc_; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_ftry_loc_ + _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ + | Pexpr_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> + self#visit_Pexpr_map env _visitors_felems _visitors_floc_ + | Pexpr_group + { + expr = _visitors_fexpr; + group = _visitors_fgroup; + loc_ = _visitors_floc_; + } -> + self#visit_Pexpr_group env _visitors_fexpr _visitors_fgroup + _visitors_floc_ + | Pexpr_static_assert + { asserts = _visitors_fasserts; body = _visitors_fbody } -> + self#visit_Pexpr_static_assert env _visitors_fasserts + _visitors_fbody + + method visit_static_assertion : + _ -> static_assertion -> static_assertion = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.assert_type in + let _visitors_r1 = + self#visit_longident env _visitors_this.assert_trait + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.assert_loc + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_this.assert_msg + in + { + assert_type = _visitors_r0; + assert_trait = _visitors_r1; + assert_loc = _visitors_r2; + assert_msg = _visitors_r3; + } method visit_argument : _ -> argument -> argument = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - { arg_value = _visitors_r0; arg_kind = _visitors_r1 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + { arg_value = _visitors_r0; arg_kind = _visitors_r1 } method visit_parameters : _ -> parameters -> parameters = - fun env _visitors_this -> - Basic_lst.map _visitors_this (self#visit_parameter env) + fun env -> + fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_parameter env) + + method visit_Discard_positional : + _ -> typ option -> location -> parameter = + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Discard_positional { ty = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Positional : _ -> binder -> typ option -> parameter = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + Positional { binder = _visitors_r0; ty = _visitors_r1 } + + method visit_Labelled : _ -> binder -> typ option -> parameter = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + Labelled { binder = _visitors_r0; ty = _visitors_r1 } + + method visit_Optional : _ -> binder -> expr -> typ option -> parameter = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fdefault -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_expr env _visitors_fdefault in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + Optional + { + binder = _visitors_r0; + default = _visitors_r1; + ty = _visitors_r2; + } + + method visit_Question_optional : _ -> binder -> typ option -> parameter + = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + Question_optional { binder = _visitors_r0; ty = _visitors_r1 } method visit_parameter : _ -> parameter -> parameter = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.param_binder - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_this.param_annot - in - let _visitors_r2 = - self#visit_parameter_kind env _visitors_this.param_kind - in - { - param_binder = _visitors_r0; - param_annot = _visitors_r1; - param_kind = _visitors_r2; - } - - method visit_Positional : _ -> parameter_kind = fun env -> Positional - method visit_Labelled : _ -> parameter_kind = fun env -> Labelled - - method visit_Optional : _ -> expr -> parameter_kind = - fun env _visitors_fdefault -> - let _visitors_r0 = self#visit_expr env _visitors_fdefault in - Optional { default = _visitors_r0 } - - method visit_Question_optional : _ -> parameter_kind = - fun env -> Question_optional - - method visit_parameter_kind : _ -> parameter_kind -> parameter_kind = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional { default = _visitors_fdefault } -> - self#visit_Optional env _visitors_fdefault - | Question_optional -> self#visit_Question_optional env - - method visit_Lambda - : _ -> - parameters -> - location -> - expr -> - (typ * error_typ) option -> - fn_kind -> - bool -> - func = - fun env _visitors_fparameters _visitors_fparams_loc_ _visitors_fbody - _visitors_freturn_type _visitors_fkind_ _visitors_fhas_error -> - let _visitors_r0 = - self#visit_parameters env _visitors_fparameters - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fparams_loc_ - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_freturn_type - in - let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_fhas_error - in - Lambda - { - parameters = _visitors_r0; - params_loc_ = _visitors_r1; - body = _visitors_r2; - return_type = _visitors_r3; - kind_ = _visitors_r4; - has_error = _visitors_r5; - } - - method visit_Match - : _ -> - (pattern list * expr) list -> - bool -> - location -> - location -> - func = - fun env _visitors_fcases _visitors_fhas_error _visitors_ffn_loc_ - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fcases - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fhas_error - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_ffn_loc_ - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Match - { - cases = _visitors_r0; - has_error = _visitors_r1; - fn_loc_ = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Discard_positional { ty = _visitors_fty; loc_ = _visitors_floc_ } + -> + self#visit_Discard_positional env _visitors_fty _visitors_floc_ + | Positional { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Positional env _visitors_fbinder _visitors_fty + | Labelled { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Labelled env _visitors_fbinder _visitors_fty + | Optional + { + binder = _visitors_fbinder; + default = _visitors_fdefault; + ty = _visitors_fty; + } -> + self#visit_Optional env _visitors_fbinder _visitors_fdefault + _visitors_fty + | Question_optional + { binder = _visitors_fbinder; ty = _visitors_fty } -> + self#visit_Question_optional env _visitors_fbinder + _visitors_fty + + method visit_Lambda : + _ -> + parameters -> + location -> + expr -> + (typ * error_typ) option -> + fn_kind -> + location option -> + bool -> + func = + fun env -> + fun _visitors_fparameters -> + fun _visitors_fparams_loc_ -> + fun _visitors_fbody -> + fun _visitors_freturn_type -> + fun _visitors_fkind_ -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + let _visitors_r0 = + self#visit_parameters env _visitors_fparameters + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) + _visitors_fparams_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_freturn_type + in + let _visitors_r4 = self#visit_fn_kind env _visitors_fkind_ in + let _visitors_r5 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_fhas_error + in + let _visitors_r6 = + (fun _visitors_this -> _visitors_this) _visitors_fis_async + in + Lambda + { + parameters = _visitors_r0; + params_loc_ = _visitors_r1; + body = _visitors_r2; + return_type = _visitors_r3; + kind_ = _visitors_r4; + has_error = _visitors_r5; + is_async = _visitors_r6; + } + + method visit_Match : + _ -> + multi_arg_case list -> + location option -> + bool -> + location -> + location -> + func = + fun env -> + fun _visitors_fcases -> + fun _visitors_fhas_error -> + fun _visitors_fis_async -> + fun _visitors_ffn_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_multi_arg_case env)) + _visitors_fcases + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_fhas_error + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_async + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_ffn_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Match + { + cases = _visitors_r0; + has_error = _visitors_r1; + is_async = _visitors_r2; + fn_loc_ = _visitors_r3; + loc_ = _visitors_r4; + } method visit_func : _ -> func -> func = - fun env _visitors_this -> - match _visitors_this with - | Lambda - { - parameters = _visitors_fparameters; - params_loc_ = _visitors_fparams_loc_; - body = _visitors_fbody; - return_type = _visitors_freturn_type; - kind_ = _visitors_fkind_; - has_error = _visitors_fhas_error; - } -> - self#visit_Lambda env _visitors_fparameters - _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type - _visitors_fkind_ _visitors_fhas_error - | Match - { - cases = _visitors_fcases; - has_error = _visitors_fhas_error; - fn_loc_ = _visitors_ffn_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Match env _visitors_fcases _visitors_fhas_error - _visitors_ffn_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Lambda + { + parameters = _visitors_fparameters; + params_loc_ = _visitors_fparams_loc_; + body = _visitors_fbody; + return_type = _visitors_freturn_type; + kind_ = _visitors_fkind_; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + } -> + self#visit_Lambda env _visitors_fparameters + _visitors_fparams_loc_ _visitors_fbody _visitors_freturn_type + _visitors_fkind_ _visitors_fhas_error _visitors_fis_async + | Match + { + cases = _visitors_fcases; + has_error = _visitors_fhas_error; + is_async = _visitors_fis_async; + fn_loc_ = _visitors_ffn_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Match env _visitors_fcases _visitors_fhas_error + _visitors_fis_async _visitors_ffn_loc_ _visitors_floc_ + + method visit_case : _ -> case -> case = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pattern env _visitors_this.pattern in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + { + pattern = _visitors_r0; + guard = _visitors_r1; + body = _visitors_r2; + } + + method visit_multi_arg_case : _ -> multi_arg_case -> multi_arg_case = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pattern env)) + _visitors_this.patterns + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_this.guard + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + { + patterns = _visitors_r0; + guard = _visitors_r1; + body = _visitors_r2; + } method visit_Elem_regular : _ -> expr -> spreadable_elem = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - Elem_regular _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + Elem_regular _visitors_r0 method visit_Elem_spread : _ -> expr -> location -> spreadable_elem = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Elem_spread { expr = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Elem_spread { expr = _visitors_r0; loc_ = _visitors_r1 } method visit_spreadable_elem : _ -> spreadable_elem -> spreadable_elem = - fun env _visitors_this -> - match _visitors_this with - | Elem_regular _visitors_c0 -> - self#visit_Elem_regular env _visitors_c0 - | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ - - method visit_Map_expr_elem - : _ -> constant -> expr -> location -> location -> map_expr_elem = - fun env _visitors_fkey _visitors_fexpr _visitors_fkey_loc_ - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fkey - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fkey_loc_ - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Map_expr_elem - { - key = _visitors_r0; - expr = _visitors_r1; - key_loc_ = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Elem_regular _visitors_c0 -> + self#visit_Elem_regular env _visitors_c0 + | Elem_spread { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Elem_spread env _visitors_fexpr _visitors_floc_ + + method visit_Map_expr_elem : + _ -> constant -> expr -> location -> location -> map_expr_elem = + fun env -> + fun _visitors_fkey -> + fun _visitors_fexpr -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fkey + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fkey_loc_ + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Map_expr_elem + { + key = _visitors_r0; + expr = _visitors_r1; + key_loc_ = _visitors_r2; + loc_ = _visitors_r3; + } method visit_map_expr_elem : _ -> map_expr_elem -> map_expr_elem = - fun env _visitors_this -> - match _visitors_this with - | Map_expr_elem - { - key = _visitors_fkey; - expr = _visitors_fexpr; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr - _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_expr_elem + { + key = _visitors_fkey; + expr = _visitors_fexpr; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_expr_elem env _visitors_fkey _visitors_fexpr + _visitors_fkey_loc_ _visitors_floc_ method visit_Error_typ : _ -> typ -> error_typ = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - Error_typ { ty = _visitors_r0 } + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + Error_typ { ty = _visitors_r0 } method visit_Default_error_typ : _ -> location -> error_typ = - fun env _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Default_error_typ { loc_ = _visitors_r0 } + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Default_error_typ { loc_ = _visitors_r0 } method visit_No_error_typ : _ -> error_typ = fun env -> No_error_typ method visit_error_typ : _ -> error_typ -> error_typ = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Ptype_any : _ -> location -> typ = - fun env _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptype_any { loc_ = _visitors_r0 } - - method visit_Ptype_arrow - : _ -> typ list -> typ -> error_typ -> location -> typ = - fun env _visitors_fty_arg _visitors_fty_res _visitors_fty_err - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fty_arg - in - let _visitors_r1 = self#visit_typ env _visitors_fty_res in - let _visitors_r2 = self#visit_error_typ env _visitors_fty_err in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptype_arrow - { - ty_arg = _visitors_r0; - ty_res = _visitors_r1; - ty_err = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptype_any { loc_ = _visitors_r0 } + + method visit_Ptype_arrow : + _ -> typ list -> typ -> error_typ -> bool -> location -> typ = + fun env -> + fun _visitors_fty_arg -> + fun _visitors_fty_res -> + fun _visitors_fty_err -> + fun _visitors_fis_async -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fty_arg + in + let _visitors_r1 = self#visit_typ env _visitors_fty_res in + let _visitors_r2 = + self#visit_error_typ env _visitors_fty_err + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_async + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptype_arrow + { + ty_arg = _visitors_r0; + ty_res = _visitors_r1; + ty_err = _visitors_r2; + is_async = _visitors_r3; + loc_ = _visitors_r4; + } method visit_Ptype_tuple : _ -> typ list -> location -> typ = - fun env _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_ftys - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptype_tuple { tys = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Ptype_name - : _ -> constrid_loc -> typ list -> location -> typ = - fun env _visitors_fconstr_id _visitors_ftys _visitors_floc_ -> - let _visitors_r0 = - self#visit_constrid_loc env _visitors_fconstr_id - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_ftys - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptype_name - { - constr_id = _visitors_r0; - tys = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_ftys + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptype_tuple { tys = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Ptype_name : + _ -> constrid_loc -> typ list -> location -> typ = + fun env -> + fun _visitors_fconstr_id -> + fun _visitors_ftys -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr_id + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_ftys + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptype_name + { + constr_id = _visitors_r0; + tys = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Ptype_option : _ -> typ -> location -> location -> typ = - fun env _visitors_fty _visitors_floc_ _visitors_fquestion_loc -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fquestion_loc - in - Ptype_option - { - ty = _visitors_r0; - loc_ = _visitors_r1; - question_loc = _visitors_r2; - } + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fquestion_loc -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fquestion_loc + in + Ptype_option + { + ty = _visitors_r0; + loc_ = _visitors_r1; + question_loc = _visitors_r2; + } + + method visit_Ptype_object : _ -> constrid_loc -> typ = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_constrid_loc env _visitors_c0 in + Ptype_object _visitors_r0 method visit_typ : _ -> typ -> typ = - fun env _visitors_this -> - match _visitors_this with - | Ptype_any { loc_ = _visitors_floc_ } -> - self#visit_Ptype_any env _visitors_floc_ - | Ptype_arrow - { - ty_arg = _visitors_fty_arg; - ty_res = _visitors_fty_res; - ty_err = _visitors_fty_err; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res - _visitors_fty_err _visitors_floc_ - | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> - self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ - | Ptype_name - { - constr_id = _visitors_fconstr_id; - tys = _visitors_ftys; - loc_ = _visitors_floc_; - } -> - self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys - _visitors_floc_ - | Ptype_option - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - question_loc = _visitors_fquestion_loc; - } -> - self#visit_Ptype_option env _visitors_fty _visitors_floc_ - _visitors_fquestion_loc + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptype_any { loc_ = _visitors_floc_ } -> + self#visit_Ptype_any env _visitors_floc_ + | Ptype_arrow + { + ty_arg = _visitors_fty_arg; + ty_res = _visitors_fty_res; + ty_err = _visitors_fty_err; + is_async = _visitors_fis_async; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_arrow env _visitors_fty_arg _visitors_fty_res + _visitors_fty_err _visitors_fis_async _visitors_floc_ + | Ptype_tuple { tys = _visitors_ftys; loc_ = _visitors_floc_ } -> + self#visit_Ptype_tuple env _visitors_ftys _visitors_floc_ + | Ptype_name + { + constr_id = _visitors_fconstr_id; + tys = _visitors_ftys; + loc_ = _visitors_floc_; + } -> + self#visit_Ptype_name env _visitors_fconstr_id _visitors_ftys + _visitors_floc_ + | Ptype_option + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + question_loc = _visitors_fquestion_loc; + } -> + self#visit_Ptype_option env _visitors_fty _visitors_floc_ + _visitors_fquestion_loc + | Ptype_object _visitors_c0 -> + self#visit_Ptype_object env _visitors_c0 method visit_Ppat_alias : _ -> pattern -> binder -> location -> pattern = - fun env _visitors_fpat _visitors_falias _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_alias - { pat = _visitors_r0; alias = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_alias + { + pat = _visitors_r0; + alias = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Ppat_any : _ -> location -> pattern = - fun env _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_any { loc_ = _visitors_r0 } - - method visit_Ppat_array : _ -> array_pattern -> location -> pattern = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_array { pats = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_any { loc_ = _visitors_r0 } + + method visit_Ppat_array : _ -> array_patterns -> location -> pattern = + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_array_patterns env _visitors_fpats + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_array { pats = _visitors_r0; loc_ = _visitors_r1 } method visit_Ppat_constant : _ -> constant -> location -> pattern = - fun env _visitors_fc _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_constant { c = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Ppat_constraint - : _ -> pattern -> typ -> location -> pattern = - fun env _visitors_fpat _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_constraint - { pat = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Ppat_constr - : _ -> - constructor -> - constr_pat_arg list option -> - bool -> - location -> - pattern = - fun env _visitors_fconstr _visitors_fargs _visitors_fis_open - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> - Basic_lst.map _visitors_this - (self#visit_constr_pat_arg env)) - t) - | None -> None) - _visitors_fargs - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_open - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_constr - { - constr = _visitors_r0; - args = _visitors_r1; - is_open = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fc -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_constant { c = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Ppat_constraint : + _ -> pattern -> typ -> location -> pattern = + fun env -> + fun _visitors_fpat -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_constraint + { pat = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Ppat_constr : + _ -> + constructor -> + constr_pat_arg list option -> + bool -> + location -> + pattern = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_fis_open -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constructor env _visitors_fconstr + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_constr_pat_arg env)) + t) + | None -> None) + _visitors_fargs + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_open + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_constr + { + constr = _visitors_r0; + args = _visitors_r1; + is_open = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Ppat_or : _ -> pattern -> pattern -> location -> pattern = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in - let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_or - { pat1 = _visitors_r0; pat2 = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat1 in + let _visitors_r1 = self#visit_pattern env _visitors_fpat2 in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_or + { + pat1 = _visitors_r0; + pat2 = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Ppat_tuple : _ -> pattern list -> location -> pattern = - fun env _visitors_fpats _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_fpats - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_tuple { pats = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fpats -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pattern env)) + _visitors_fpats + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_tuple { pats = _visitors_r0; loc_ = _visitors_r1 } method visit_Ppat_var : _ -> binder -> pattern = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - Ppat_var _visitors_r0 - - method visit_Ppat_record - : _ -> field_pat list -> bool -> location -> pattern = - fun env _visitors_ffields _visitors_fis_closed _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_pat env)) - _visitors_ffields - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fis_closed - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_record - { - fields = _visitors_r0; - is_closed = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Ppat_map : _ -> map_pat_elem list -> location -> pattern = - fun env _visitors_felems _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_map_pat_elem env)) - _visitors_felems - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_map { elems = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Ppat_range - : _ -> pattern -> pattern -> bool -> location -> pattern = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive - _visitors_floc_ -> - let _visitors_r0 = self#visit_pattern env _visitors_flhs in - let _visitors_r1 = self#visit_pattern env _visitors_frhs in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_finclusive - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ppat_range - { - lhs = _visitors_r0; - rhs = _visitors_r1; - inclusive = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + Ppat_var _visitors_r0 + + method visit_Ppat_record : + _ -> field_pat list -> bool -> location -> pattern = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_pat env)) + _visitors_ffields + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_closed + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_record + { + fields = _visitors_r0; + is_closed = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Ppat_map : + _ -> map_pat_elem list -> bool -> location -> pattern = + fun env -> + fun _visitors_felems -> + fun _visitors_fis_closed -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_map_pat_elem env)) + _visitors_felems + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_closed + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_map + { + elems = _visitors_r0; + is_closed = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Ppat_range : + _ -> pattern -> pattern -> bool -> location -> pattern = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pattern env _visitors_flhs in + let _visitors_r1 = self#visit_pattern env _visitors_frhs in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_finclusive + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ppat_range + { + lhs = _visitors_r0; + rhs = _visitors_r1; + inclusive = _visitors_r2; + loc_ = _visitors_r3; + } method visit_pattern : _ -> pattern -> pattern = - fun env _visitors_this -> - match _visitors_this with - | Ppat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_alias env _visitors_fpat _visitors_falias - _visitors_floc_ - | Ppat_any { loc_ = _visitors_floc_ } -> - self#visit_Ppat_any env _visitors_floc_ - | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_array env _visitors_fpats _visitors_floc_ - | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> - self#visit_Ppat_constant env _visitors_fc _visitors_floc_ - | Ppat_constraint - { - pat = _visitors_fpat; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constraint env _visitors_fpat _visitors_fty - _visitors_floc_ - | Ppat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - is_open = _visitors_fis_open; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs - _visitors_fis_open _visitors_floc_ - | Ppat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_floc_ - | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> - self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ - | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 - | Ppat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_record env _visitors_ffields - _visitors_fis_closed _visitors_floc_ - | Ppat_map { elems = _visitors_felems; loc_ = _visitors_floc_ } -> - self#visit_Ppat_map env _visitors_felems _visitors_floc_ - | Ppat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - loc_ = _visitors_floc_; - } -> - self#visit_Ppat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_floc_ - - method visit_Closed : _ -> pattern list -> array_pattern = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - Closed _visitors_r0 - - method visit_Open - : _ -> - pattern list -> - pattern list -> - binder option -> - array_pattern = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pattern env)) - _visitors_c1 - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_binder env) t) - | None -> None) - _visitors_c2 - in - Open (_visitors_r0, _visitors_r1, _visitors_r2) + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ppat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_alias env _visitors_fpat _visitors_falias + _visitors_floc_ + | Ppat_any { loc_ = _visitors_floc_ } -> + self#visit_Ppat_any env _visitors_floc_ + | Ppat_array { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_array env _visitors_fpats _visitors_floc_ + | Ppat_constant { c = _visitors_fc; loc_ = _visitors_floc_ } -> + self#visit_Ppat_constant env _visitors_fc _visitors_floc_ + | Ppat_constraint + { + pat = _visitors_fpat; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constraint env _visitors_fpat _visitors_fty + _visitors_floc_ + | Ppat_constr + { + constr = _visitors_fconstr; + args = _visitors_fargs; + is_open = _visitors_fis_open; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_constr env _visitors_fconstr _visitors_fargs + _visitors_fis_open _visitors_floc_ + | Ppat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_floc_ + | Ppat_tuple { pats = _visitors_fpats; loc_ = _visitors_floc_ } -> + self#visit_Ppat_tuple env _visitors_fpats _visitors_floc_ + | Ppat_var _visitors_c0 -> self#visit_Ppat_var env _visitors_c0 + | Ppat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_record env _visitors_ffields + _visitors_fis_closed _visitors_floc_ + | Ppat_map + { + elems = _visitors_felems; + is_closed = _visitors_fis_closed; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_map env _visitors_felems _visitors_fis_closed + _visitors_floc_ + | Ppat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + loc_ = _visitors_floc_; + } -> + self#visit_Ppat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_floc_ + + method visit_Closed : _ -> array_pattern list -> array_patterns = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_array_pattern env)) + _visitors_c0 + in + Closed _visitors_r0 + + method visit_Open : + _ -> + array_pattern list -> + array_pattern list -> + binder option -> + array_patterns = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_array_pattern env)) + _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_array_pattern env)) + _visitors_c1 + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_binder env) t) + | None -> None) + _visitors_c2 + in + Open (_visitors_r0, _visitors_r1, _visitors_r2) + + method visit_array_patterns : _ -> array_patterns -> array_patterns = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + + method visit_Pattern : _ -> pattern -> array_pattern = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_pattern env _visitors_c0 in + Pattern _visitors_r0 + + method visit_String_spread : _ -> string_literal -> array_pattern = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + String_spread _visitors_r0 + + method visit_String_spread_const : + _ -> binder -> string option -> location -> array_pattern = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fpkg -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_fpkg + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + String_spread_const + { + binder = _visitors_r0; + pkg = _visitors_r1; + loc_ = _visitors_r2; + } method visit_array_pattern : _ -> array_pattern -> array_pattern = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 - - method visit_Field_def - : _ -> label -> expr -> bool -> location -> field_def = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pun - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Field_def - { - label = _visitors_r0; - expr = _visitors_r1; - is_pun = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pattern _visitors_c0 -> self#visit_Pattern env _visitors_c0 + | String_spread _visitors_c0 -> + self#visit_String_spread env _visitors_c0 + | String_spread_const + { + binder = _visitors_fbinder; + pkg = _visitors_fpkg; + loc_ = _visitors_floc_; + } -> + self#visit_String_spread_const env _visitors_fbinder + _visitors_fpkg _visitors_floc_ + + method visit_Field_def : + _ -> label -> expr -> bool -> location -> field_def = + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pun + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Field_def + { + label = _visitors_r0; + expr = _visitors_r1; + is_pun = _visitors_r2; + loc_ = _visitors_r3; + } method visit_field_def : _ -> field_def -> field_def = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_pun _visitors_floc_ - - method visit_Field_pat - : _ -> label -> pattern -> bool -> location -> field_pat = - fun env _visitors_flabel _visitors_fpattern _visitors_fis_pun - _visitors_floc_ -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pattern env _visitors_fpattern in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pun - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Field_pat - { - label = _visitors_r0; - pattern = _visitors_r1; - is_pun = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_pun _visitors_floc_ + + method visit_Field_pat : + _ -> label -> pattern -> bool -> location -> field_pat = + fun env -> + fun _visitors_flabel -> + fun _visitors_fpattern -> + fun _visitors_fis_pun -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pattern env _visitors_fpattern in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pun + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Field_pat + { + label = _visitors_r0; + pattern = _visitors_r1; + is_pun = _visitors_r2; + loc_ = _visitors_r3; + } method visit_field_pat : _ -> field_pat -> field_pat = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pattern = _visitors_fpattern; - is_pun = _visitors_fis_pun; - loc_ = _visitors_floc_; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpattern - _visitors_fis_pun _visitors_floc_ - - method visit_Constr_pat_arg - : _ -> pattern -> argument_kind -> constr_pat_arg = - fun env _visitors_fpat _visitors_fkind -> - let _visitors_r0 = self#visit_pattern env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - Constr_pat_arg { pat = _visitors_r0; kind = _visitors_r1 } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pattern = _visitors_fpattern; + is_pun = _visitors_fis_pun; + loc_ = _visitors_floc_; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpattern + _visitors_fis_pun _visitors_floc_ + + method visit_Constr_pat_arg : + _ -> pattern -> argument_kind -> constr_pat_arg = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_pattern env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + Constr_pat_arg { pat = _visitors_r0; kind = _visitors_r1 } method visit_constr_pat_arg : _ -> constr_pat_arg -> constr_pat_arg = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - - method visit_Map_pat_elem - : _ -> - constant -> - pattern -> - bool -> - location -> - location -> - map_pat_elem = - fun env _visitors_fkey _visitors_fpat _visitors_fmatch_absent - _visitors_fkey_loc_ _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fkey - in - let _visitors_r1 = self#visit_pattern env _visitors_fpat in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fmatch_absent - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fkey_loc_ - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Map_pat_elem - { - key = _visitors_r0; - pat = _visitors_r1; - match_absent = _visitors_r2; - key_loc_ = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg { pat = _visitors_fpat; kind = _visitors_fkind } + -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + + method visit_Map_pat_elem : + _ -> + constant -> + pattern -> + bool -> + location -> + location -> + map_pat_elem = + fun env -> + fun _visitors_fkey -> + fun _visitors_fpat -> + fun _visitors_fmatch_absent -> + fun _visitors_fkey_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fkey + in + let _visitors_r1 = self#visit_pattern env _visitors_fpat in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) + _visitors_fmatch_absent + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fkey_loc_ + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Map_pat_elem + { + key = _visitors_r0; + pat = _visitors_r1; + match_absent = _visitors_r2; + key_loc_ = _visitors_r3; + loc_ = _visitors_r4; + } method visit_map_pat_elem : _ -> map_pat_elem -> map_pat_elem = - fun env _visitors_this -> - match _visitors_this with - | Map_pat_elem - { - key = _visitors_fkey; - pat = _visitors_fpat; - match_absent = _visitors_fmatch_absent; - key_loc_ = _visitors_fkey_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat - _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Map_pat_elem + { + key = _visitors_fkey; + pat = _visitors_fpat; + match_absent = _visitors_fmatch_absent; + key_loc_ = _visitors_fkey_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Map_pat_elem env _visitors_fkey _visitors_fpat + _visitors_fmatch_absent _visitors_fkey_loc_ _visitors_floc_ method visit_constr_param : _ -> constr_param -> constr_param = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.cparam_mut - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_label env) t) - | None -> None) - _visitors_this.cparam_label - in - { - cparam_typ = _visitors_r0; - cparam_mut = _visitors_r1; - cparam_label = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.cparam_typ in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.cparam_mut + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_this.cparam_label + in + { + cparam_typ = _visitors_r0; + cparam_mut = _visitors_r1; + cparam_label = _visitors_r2; + } method visit_constr_decl : _ -> constr_decl -> constr_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_constr_name env _visitors_this.constr_name - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> - Basic_lst.map _visitors_this - (self#visit_constr_param env)) - t) - | None -> None) - _visitors_this.constr_args - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.constr_loc_ - in - { - constr_name = _visitors_r0; - constr_args = _visitors_r1; - constr_loc_ = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_constr_name env _visitors_this.constr_name + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_constr_param env)) + t) + | None -> None) + _visitors_this.constr_args + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_this.constr_tag + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_this.constr_loc_ + in + { + constr_name = _visitors_r0; + constr_args = _visitors_r1; + constr_tag = _visitors_r2; + constr_loc_ = _visitors_r3; + } method visit_field_name : _ -> field_name -> field_name = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_this.label - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.loc_ - in - { label = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_this.label + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.loc_ + in + { label = _visitors_r0; loc_ = _visitors_r1 } method visit_field_decl : _ -> field_decl -> field_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_field_name env _visitors_this.field_name - in - let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.field_mut - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.field_loc_ - in - { - field_name = _visitors_r0; - field_ty = _visitors_r1; - field_mut = _visitors_r2; - field_vis = _visitors_r3; - field_loc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_field_name env _visitors_this.field_name + in + let _visitors_r1 = self#visit_typ env _visitors_this.field_ty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.field_mut + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_this.field_loc_ + in + { + field_name = _visitors_r0; + field_ty = _visitors_r1; + field_mut = _visitors_r2; + field_vis = _visitors_r3; + field_loc_ = _visitors_r4; + } method visit_No_payload : _ -> exception_decl = fun env -> No_payload method visit_Single_payload : _ -> typ -> exception_decl = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Single_payload _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Single_payload _visitors_r0 method visit_Enum_payload : _ -> constr_decl list -> exception_decl = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - Enum_payload _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_decl env)) + _visitors_c0 + in + Enum_payload _visitors_r0 method visit_exception_decl : _ -> exception_decl -> exception_decl = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Ptd_abstract : _ -> type_desc = fun env -> Ptd_abstract + method visit_Ptd_extern : _ -> type_desc = fun env -> Ptd_extern method visit_Ptd_newtype : _ -> typ -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Ptd_newtype _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Ptd_newtype _visitors_r0 method visit_Ptd_error : _ -> exception_decl -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - Ptd_error _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + Ptd_error _visitors_r0 method visit_Ptd_variant : _ -> constr_decl list -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - Ptd_variant _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_decl env)) + _visitors_c0 + in + Ptd_variant _visitors_r0 method visit_Ptd_record : _ -> field_decl list -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_decl env)) - _visitors_c0 - in - Ptd_record _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_decl env)) + _visitors_c0 + in + Ptd_record _visitors_r0 method visit_Ptd_alias : _ -> typ -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Ptd_alias _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Ptd_alias _visitors_r0 method visit_type_desc : _ -> type_desc -> type_desc = - fun env _visitors_this -> - match _visitors_this with - | Ptd_abstract -> self#visit_Ptd_abstract env - | Ptd_newtype _visitors_c0 -> - self#visit_Ptd_newtype env _visitors_c0 - | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 - | Ptd_variant _visitors_c0 -> - self#visit_Ptd_variant env _visitors_c0 - | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 - | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptd_abstract -> self#visit_Ptd_abstract env + | Ptd_extern -> self#visit_Ptd_extern env + | Ptd_newtype _visitors_c0 -> + self#visit_Ptd_newtype env _visitors_c0 + | Ptd_error _visitors_c0 -> self#visit_Ptd_error env _visitors_c0 + | Ptd_variant _visitors_c0 -> + self#visit_Ptd_variant env _visitors_c0 + | Ptd_record _visitors_c0 -> self#visit_Ptd_record env _visitors_c0 + | Ptd_alias _visitors_c0 -> self#visit_Ptd_alias env _visitors_c0 method visit_type_decl : _ -> type_decl -> type_decl = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_this.tycon - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.tycon_loc_ - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_type_decl_binder env)) - _visitors_this.params - in - let _visitors_r3 = - self#visit_type_desc env _visitors_this.components - in - let _visitors_r4 = self#visit_docstring env _visitors_this.doc_ in - let _visitors_r5 = - self#visit_visibility env _visitors_this.type_vis - in - let _visitors_r6 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_deriving_directive env)) - _visitors_this.deriving_ - in - let _visitors_r7 = - (fun _visitors_this -> _visitors_this) _visitors_this.loc_ - in - { - tycon = _visitors_r0; - tycon_loc_ = _visitors_r1; - params = _visitors_r2; - components = _visitors_r3; - doc_ = _visitors_r4; - type_vis = _visitors_r5; - deriving_ = _visitors_r6; - loc_ = _visitors_r7; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_this.tycon + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.tycon_loc_ + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_type_decl_binder env)) + _visitors_this.params + in + let _visitors_r3 = + self#visit_type_desc env _visitors_this.components + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_this.attrs + in + let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r6 = + self#visit_visibility env _visitors_this.type_vis + in + let _visitors_r7 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_deriving_directive env)) + _visitors_this.deriving_ + in + let _visitors_r8 = + (fun _visitors_this -> _visitors_this) _visitors_this.loc_ + in + { + tycon = _visitors_r0; + tycon_loc_ = _visitors_r1; + params = _visitors_r2; + components = _visitors_r3; + attrs = _visitors_r4; + doc_ = _visitors_r5; + type_vis = _visitors_r6; + deriving_ = _visitors_r7; + loc_ = _visitors_r8; + } method visit_local_type_decl : _ -> local_type_decl -> local_type_decl = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_this.local_tycon - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) - _visitors_this.local_tycon_loc_ - in - let _visitors_r2 = - self#visit_type_desc env _visitors_this.local_components - in - { - local_tycon = _visitors_r0; - local_tycon_loc_ = _visitors_r1; - local_components = _visitors_r2; - } - - method visit_deriving_directive - : _ -> deriving_directive -> deriving_directive = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_name env _visitors_this.type_name_ - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_argument env)) - _visitors_this.args - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.loc_ - in - { - type_name_ = _visitors_r0; - args = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_this.local_tycon + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) + _visitors_this.local_tycon_loc_ + in + let _visitors_r2 = + self#visit_type_desc env _visitors_this.local_components + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_deriving_directive env)) + _visitors_this.deriving_ + in + { + local_tycon = _visitors_r0; + local_tycon_loc_ = _visitors_r1; + local_components = _visitors_r2; + deriving_ = _visitors_r3; + } + + method visit_deriving_directive : + _ -> deriving_directive -> deriving_directive = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_name env _visitors_this.type_name_ + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_argument env)) + _visitors_this.args + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.loc_ + in + { + type_name_ = _visitors_r0; + args = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Vis_default : _ -> visibility = fun env -> Vis_default method visit_Vis_pub : _ -> string option -> location -> visibility = - fun env _visitors_fattr _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((fun _visitors_this -> _visitors_this) t) - | None -> None) - _visitors_fattr - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Vis_pub { attr = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fattr -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_fattr + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Vis_pub { attr = _visitors_r0; loc_ = _visitors_r1 } method visit_Vis_priv : _ -> location -> visibility = - fun env _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Vis_priv { loc_ = _visitors_r0 } + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Vis_priv { loc_ = _visitors_r0 } method visit_visibility : _ -> visibility -> visibility = - fun env _visitors_this -> - match _visitors_this with - | Vis_default -> self#visit_Vis_default env - | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> - self#visit_Vis_pub env _visitors_fattr _visitors_floc_ - | Vis_priv { loc_ = _visitors_floc_ } -> - self#visit_Vis_priv env _visitors_floc_ - - method visit_Import - : _ -> string_literal -> string_literal -> func_stubs = - fun env _visitors_fmodule_name _visitors_ffunc_name -> - let _visitors_r0 = - self#visit_string_literal env _visitors_fmodule_name - in - let _visitors_r1 = - self#visit_string_literal env _visitors_ffunc_name - in - Import { module_name = _visitors_r0; func_name = _visitors_r1 } - - method visit_Embedded - : _ -> string_literal option -> embedded_code -> func_stubs = - fun env _visitors_flanguage _visitors_fcode -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_string_literal env) t) - | None -> None) - _visitors_flanguage - in - let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in - Embedded { language = _visitors_r0; code = _visitors_r1 } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Vis_default -> self#visit_Vis_default env + | Vis_pub { attr = _visitors_fattr; loc_ = _visitors_floc_ } -> + self#visit_Vis_pub env _visitors_fattr _visitors_floc_ + | Vis_priv { loc_ = _visitors_floc_ } -> + self#visit_Vis_priv env _visitors_floc_ + + method visit_Import : + _ -> string_literal -> string_literal -> func_stubs = + fun env -> + fun _visitors_fmodule_name -> + fun _visitors_ffunc_name -> + let _visitors_r0 = + self#visit_string_literal env _visitors_fmodule_name + in + let _visitors_r1 = + self#visit_string_literal env _visitors_ffunc_name + in + Import { module_name = _visitors_r0; func_name = _visitors_r1 } + + method visit_Embedded : + _ -> string_literal option -> embedded_code -> func_stubs = + fun env -> + fun _visitors_flanguage -> + fun _visitors_fcode -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_string_literal env) t) + | None -> None) + _visitors_flanguage + in + let _visitors_r1 = self#visit_embedded_code env _visitors_fcode in + Embedded { language = _visitors_r0; code = _visitors_r1 } method visit_func_stubs : _ -> func_stubs -> func_stubs = - fun env _visitors_this -> - match _visitors_this with - | Import - { - module_name = _visitors_fmodule_name; - func_name = _visitors_ffunc_name; - } -> - self#visit_Import env _visitors_fmodule_name - _visitors_ffunc_name - | Embedded - { language = _visitors_flanguage; code = _visitors_fcode } -> - self#visit_Embedded env _visitors_flanguage _visitors_fcode + fun env -> + fun _visitors_this -> + match _visitors_this with + | Import + { + module_name = _visitors_fmodule_name; + func_name = _visitors_ffunc_name; + } -> + self#visit_Import env _visitors_fmodule_name + _visitors_ffunc_name + | Embedded + { language = _visitors_flanguage; code = _visitors_fcode } -> + self#visit_Embedded env _visitors_flanguage _visitors_fcode method visit_Code_string : _ -> string_literal -> embedded_code = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_string_literal env _visitors_c0 in - Code_string _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string_literal env _visitors_c0 in + Code_string _visitors_r0 method visit_Code_multiline_string : _ -> string list -> embedded_code = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun _visitors_this -> - _visitors_this)) - _visitors_c0 - in - Code_multiline_string _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (fun _visitors_this -> + _visitors_this)) + _visitors_c0 + in + Code_multiline_string _visitors_r0 method visit_embedded_code : _ -> embedded_code -> embedded_code = - fun env _visitors_this -> - match _visitors_this with - | Code_string _visitors_c0 -> - self#visit_Code_string env _visitors_c0 - | Code_multiline_string _visitors_c0 -> - self#visit_Code_multiline_string env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Code_string _visitors_c0 -> + self#visit_Code_string env _visitors_c0 + | Code_multiline_string _visitors_c0 -> + self#visit_Code_multiline_string env _visitors_c0 method visit_Decl_body : _ -> local_type_decl list -> expr -> decl_body = - fun env _visitors_flocal_types _visitors_fexpr -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - Decl_body { local_types = _visitors_r0; expr = _visitors_r1 } + fun env -> + fun _visitors_flocal_types -> + fun _visitors_fexpr -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + Decl_body { local_types = _visitors_r0; expr = _visitors_r1 } method visit_Decl_stubs : _ -> func_stubs -> decl_body = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - Decl_stubs _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + Decl_stubs _visitors_r0 method visit_decl_body : _ -> decl_body -> decl_body = - fun env _visitors_this -> - match _visitors_this with - | Decl_body - { local_types = _visitors_flocal_types; expr = _visitors_fexpr } - -> - self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr - | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Decl_body + { + local_types = _visitors_flocal_types; + expr = _visitors_fexpr; + } -> + self#visit_Decl_body env _visitors_flocal_types _visitors_fexpr + | Decl_stubs _visitors_c0 -> self#visit_Decl_stubs env _visitors_c0 method visit_fun_decl : _ -> fun_decl -> fun_decl = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_this.type_name - in - let _visitors_r1 = self#visit_binder env _visitors_this.name in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.has_error - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_parameters env) t) - | None -> None) - _visitors_this.decl_params - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.params_loc_ - in - let _visitors_r5 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_tvar_binder env)) - _visitors_this.quantifiers - in - let _visitors_r6 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_this.return_type - in - let _visitors_r7 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_pub - in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - { - type_name = _visitors_r0; - name = _visitors_r1; - has_error = _visitors_r2; - decl_params = _visitors_r3; - params_loc_ = _visitors_r4; - quantifiers = _visitors_r5; - return_type = _visitors_r6; - is_pub = _visitors_r7; - doc_ = _visitors_r8; - } - - method visit_trait_method_param - : _ -> trait_method_param -> trait_method_param = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_label env) t) - | None -> None) - _visitors_this.tmparam_label - in - { tmparam_typ = _visitors_r0; tmparam_label = _visitors_r1 } - - method visit_Trait_method - : _ -> - binder -> - bool -> - tvar_binder list -> - trait_method_param list -> - (typ * error_typ) option -> - location -> - trait_method_decl = - fun env _visitors_fname _visitors_fhas_error _visitors_fquantifiers - _visitors_fparams _visitors_freturn_type _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fname in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fhas_error - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_trait_method_param env)) - _visitors_fparams - in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_freturn_type - in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Trait_method - { - name = _visitors_r0; - has_error = _visitors_r1; - quantifiers = _visitors_r2; - params = _visitors_r3; - return_type = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_trait_method_decl - : _ -> trait_method_decl -> trait_method_decl = - fun env _visitors_this -> - match _visitors_this with - | Trait_method - { - name = _visitors_fname; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - return_type = _visitors_freturn_type; - loc_ = _visitors_floc_; - } -> - self#visit_Trait_method env _visitors_fname _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams - _visitors_freturn_type _visitors_floc_ + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_this.type_name + in + let _visitors_r1 = self#visit_binder env _visitors_this.name in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((fun _visitors_this -> _visitors_this) t) + | None -> None) + _visitors_this.has_error + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_async + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_parameters env) t) + | None -> None) + _visitors_this.decl_params + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) _visitors_this.params_loc_ + in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_tvar_binder env)) + _visitors_this.quantifiers + in + let _visitors_r7 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_this.return_type + in + let _visitors_r8 = self#visit_visibility env _visitors_this.vis in + let _visitors_r9 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_this.attrs + in + let _visitors_r10 = self#visit_docstring env _visitors_this.doc_ in + { + type_name = _visitors_r0; + name = _visitors_r1; + has_error = _visitors_r2; + is_async = _visitors_r3; + decl_params = _visitors_r4; + params_loc_ = _visitors_r5; + quantifiers = _visitors_r6; + return_type = _visitors_r7; + vis = _visitors_r8; + attrs = _visitors_r9; + doc_ = _visitors_r10; + } + + method visit_trait_method_param : + _ -> trait_method_param -> trait_method_param = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.tmparam_typ in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_this.tmparam_label + in + { tmparam_typ = _visitors_r0; tmparam_label = _visitors_r1 } + + method visit_Trait_method : + _ -> + binder -> + bool -> + tvar_binder list -> + trait_method_param list -> + (typ * error_typ) option -> + location -> + trait_method_decl = + fun env -> + fun _visitors_fname -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_freturn_type -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fname in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fhas_error + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_trait_method_param env)) + _visitors_fparams + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_freturn_type + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Trait_method + { + name = _visitors_r0; + has_error = _visitors_r1; + quantifiers = _visitors_r2; + params = _visitors_r3; + return_type = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_trait_method_decl : + _ -> trait_method_decl -> trait_method_decl = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Trait_method + { + name = _visitors_fname; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + return_type = _visitors_freturn_type; + loc_ = _visitors_floc_; + } -> + self#visit_Trait_method env _visitors_fname + _visitors_fhas_error _visitors_fquantifiers _visitors_fparams + _visitors_freturn_type _visitors_floc_ method visit_trait_decl : _ -> trait_decl -> trait_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_binder env _visitors_this.trait_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_tvar_constraint env)) - _visitors_this.trait_supers - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_trait_method_decl env)) - _visitors_this.trait_methods - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.trait_loc_ - in - let _visitors_r5 = - self#visit_docstring env _visitors_this.trait_doc_ - in - { - trait_name = _visitors_r0; - trait_supers = _visitors_r1; - trait_methods = _visitors_r2; - trait_vis = _visitors_r3; - trait_loc_ = _visitors_r4; - trait_doc_ = _visitors_r5; - } - - method visit_Ptop_expr - : _ -> expr -> bool -> local_type_decl list -> absolute_loc -> impl - = - fun env _visitors_fexpr _visitors_fis_main _visitors_flocal_types - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fis_main - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptop_expr - { - expr = _visitors_r0; - is_main = _visitors_r1; - local_types = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Ptop_test - : _ -> - expr -> - test_name -> - parameters option -> - local_type_decl list -> - absolute_loc -> - impl = - fun env _visitors_fexpr _visitors_fname _visitors_fparams - _visitors_flocal_types _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fname - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_parameters env) t) - | None -> None) - _visitors_fparams - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptop_test - { - expr = _visitors_r0; - name = _visitors_r1; - params = _visitors_r2; - local_types = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_binder env _visitors_this.trait_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_tvar_constraint env)) + _visitors_this.trait_supers + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_trait_method_decl env)) + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_this.trait_loc_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_this.trait_attrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_this.trait_doc_ + in + { + trait_name = _visitors_r0; + trait_supers = _visitors_r1; + trait_methods = _visitors_r2; + trait_vis = _visitors_r3; + trait_loc_ = _visitors_r4; + trait_attrs = _visitors_r5; + trait_doc_ = _visitors_r6; + } + + method visit_Ptop_expr : + _ -> expr -> bool -> local_type_decl list -> absolute_loc -> impl = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_main + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptop_expr + { + expr = _visitors_r0; + is_main = _visitors_r1; + local_types = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Ptop_test : + _ -> + expr -> + test_name -> + parameters option -> + local_type_decl list -> + absolute_loc -> + attribute list -> + docstring -> + impl = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fname -> + fun _visitors_fparams -> + fun _visitors_flocal_types -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fname + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_parameters env) t) + | None -> None) + _visitors_fparams + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_local_type_decl env)) + _visitors_flocal_types + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r6 = + self#visit_docstring env _visitors_fdoc_ + in + Ptop_test + { + expr = _visitors_r0; + name = _visitors_r1; + params = _visitors_r2; + local_types = _visitors_r3; + loc_ = _visitors_r4; + attrs = _visitors_r5; + doc_ = _visitors_r6; + } method visit_Ptop_typedef : _ -> type_decl -> impl = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_decl env _visitors_c0 in - Ptop_typedef _visitors_r0 - - method visit_Ptop_funcdef - : _ -> fun_decl -> decl_body -> absolute_loc -> impl = - fun env _visitors_ffun_decl _visitors_fdecl_body _visitors_floc_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_decl_body env _visitors_fdecl_body in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptop_funcdef - { - fun_decl = _visitors_r0; - decl_body = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Ptop_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - bool -> - absolute_loc -> - docstring -> - impl = - fun env _visitors_fbinder _visitors_fty _visitors_fexpr - _visitors_fis_pub _visitors_fis_constant _visitors_floc_ - _visitors_fdoc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fty - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fis_constant - in - let _visitors_r5 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - let _visitors_r6 = self#visit_docstring env _visitors_fdoc_ in - Ptop_letdef - { - binder = _visitors_r0; - ty = _visitors_r1; - expr = _visitors_r2; - is_pub = _visitors_r3; - is_constant = _visitors_r4; - loc_ = _visitors_r5; - doc_ = _visitors_r6; - } + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_decl env _visitors_c0 in + Ptop_typedef _visitors_r0 + + method visit_Ptop_funcdef : + _ -> fun_decl -> decl_body -> absolute_loc -> impl = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_fdecl_body -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = + self#visit_decl_body env _visitors_fdecl_body + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptop_funcdef + { + fun_decl = _visitors_r0; + decl_body = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Ptop_letdef : + _ -> + binder -> + typ option -> + expr -> + visibility -> + bool -> + absolute_loc -> + attribute list -> + docstring -> + impl = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_fexpr -> + fun _visitors_fvis -> + fun _visitors_fis_constant -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + self#visit_binder env _visitors_fbinder + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fty + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) + _visitors_fis_constant + in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r7 = + self#visit_docstring env _visitors_fdoc_ + in + Ptop_letdef + { + binder = _visitors_r0; + ty = _visitors_r1; + expr = _visitors_r2; + vis = _visitors_r3; + is_constant = _visitors_r4; + loc_ = _visitors_r5; + attrs = _visitors_r6; + doc_ = _visitors_r7; + } method visit_Ptop_trait : _ -> trait_decl -> impl = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in - Ptop_trait _visitors_r0 - - method visit_Ptop_impl - : _ -> - typ option -> - type_name -> - binder -> - bool -> - tvar_binder list -> - parameters -> - (typ * error_typ) option -> - expr -> - bool -> - local_type_decl list -> - absolute_loc -> - location -> - docstring -> - impl = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fmethod_name - _visitors_fhas_error _visitors_fquantifiers _visitors_fparams - _visitors_fret_ty _visitors_fbody _visitors_fis_pub - _visitors_flocal_types _visitors_floc_ _visitors_fheader_loc_ - _visitors_fdoc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fself_ty - in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_binder env _visitors_fmethod_name in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fhas_error - in - let _visitors_r4 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r5 = self#visit_parameters env _visitors_fparams in - let _visitors_r6 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_trait_decl env _visitors_c0 in + Ptop_trait _visitors_r0 + + method visit_Ptop_trait_alias : + _ -> + binder -> + type_name -> + visibility -> + absolute_loc -> + attribute list -> + docstring -> + impl = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ftarget -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_type_name env _visitors_ftarget + in + let _visitors_r2 = self#visit_visibility env _visitors_fvis in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + Ptop_trait_alias + { + binder = _visitors_r0; + target = _visitors_r1; + vis = _visitors_r2; + loc_ = _visitors_r3; + attrs = _visitors_r4; + doc_ = _visitors_r5; + } + + method visit_Ptop_impl : + _ -> + typ option -> + type_name -> + binder -> + bool -> + tvar_binder list -> + parameters -> + (typ * error_typ) option -> + decl_body -> + visibility -> + absolute_loc -> + location -> + attribute list -> + docstring -> + impl = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fmethod_name -> + fun _visitors_fhas_error -> + fun _visitors_fquantifiers -> + fun _visitors_fparams -> + fun _visitors_fret_ty -> + fun _visitors_fbody -> + fun _visitors_fvis -> + fun _visitors_floc_ -> + fun _visitors_fheader_loc_ -> + fun _visitors_fattrs -> + fun _visitors_fdoc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fself_ty + in let _visitors_r1 = - self#visit_error_typ env _visitors_c1 + self#visit_type_name env _visitors_ftrait + in + let _visitors_r2 = + self#visit_binder env _visitors_fmethod_name + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) + _visitors_fhas_error + in + let _visitors_r4 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r5 = + self#visit_parameters env _visitors_fparams + in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_typ env _visitors_c0 + in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_fret_ty in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_fret_ty - in - let _visitors_r7 = self#visit_expr env _visitors_fbody in - let _visitors_r8 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub - in - let _visitors_r9 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_local_type_decl env)) - _visitors_flocal_types - in - let _visitors_r10 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - let _visitors_r11 = - (fun _visitors_this -> _visitors_this) _visitors_fheader_loc_ - in - let _visitors_r12 = self#visit_docstring env _visitors_fdoc_ in - Ptop_impl - { - self_ty = _visitors_r0; - trait = _visitors_r1; - method_name = _visitors_r2; - has_error = _visitors_r3; - quantifiers = _visitors_r4; - params = _visitors_r5; - ret_ty = _visitors_r6; - body = _visitors_r7; - is_pub = _visitors_r8; - local_types = _visitors_r9; - loc_ = _visitors_r10; - header_loc_ = _visitors_r11; - doc_ = _visitors_r12; - } - - method visit_Ptop_impl_relation - : _ -> - typ -> - type_name -> - tvar_binder list -> - bool -> - absolute_loc -> - impl = - fun env _visitors_fself_ty _visitors_ftrait _visitors_fquantifiers - _visitors_fis_pub _visitors_floc_ -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_tvar_binder env)) - _visitors_fquantifiers - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Ptop_impl_relation - { - self_ty = _visitors_r0; - trait = _visitors_r1; - quantifiers = _visitors_r2; - is_pub = _visitors_r3; - loc_ = _visitors_r4; - } + let _visitors_r7 = + self#visit_decl_body env _visitors_fbody + in + let _visitors_r8 = + self#visit_visibility env _visitors_fvis + in + let _visitors_r9 = + (fun _visitors_this -> _visitors_this) + _visitors_floc_ + in + let _visitors_r10 = + (fun _visitors_this -> _visitors_this) + _visitors_fheader_loc_ + in + let _visitors_r11 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_attribute env)) + _visitors_fattrs + in + let _visitors_r12 = + self#visit_docstring env _visitors_fdoc_ + in + Ptop_impl + { + self_ty = _visitors_r0; + trait = _visitors_r1; + method_name = _visitors_r2; + has_error = _visitors_r3; + quantifiers = _visitors_r4; + params = _visitors_r5; + ret_ty = _visitors_r6; + body = _visitors_r7; + vis = _visitors_r8; + loc_ = _visitors_r9; + header_loc_ = _visitors_r10; + attrs = _visitors_r11; + doc_ = _visitors_r12; + } + + method visit_Ptop_impl_relation : + _ -> + typ -> + type_name -> + tvar_binder list -> + bool -> + absolute_loc -> + impl = + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + fun _visitors_fquantifiers -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_tvar_binder env)) + _visitors_fquantifiers + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pub + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Ptop_impl_relation + { + self_ty = _visitors_r0; + trait = _visitors_r1; + quantifiers = _visitors_r2; + is_pub = _visitors_r3; + loc_ = _visitors_r4; + } method visit_impl : _ -> impl -> impl = - fun env _visitors_this -> - match _visitors_this with - | Ptop_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main - _visitors_flocal_types _visitors_floc_ - | Ptop_test - { - expr = _visitors_fexpr; - name = _visitors_fname; - params = _visitors_fparams; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_test env _visitors_fexpr _visitors_fname - _visitors_fparams _visitors_flocal_types _visitors_floc_ - | Ptop_typedef _visitors_c0 -> - self#visit_Ptop_typedef env _visitors_c0 - | Ptop_funcdef - { - fun_decl = _visitors_ffun_decl; - decl_body = _visitors_fdecl_body; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_funcdef env _visitors_ffun_decl - _visitors_fdecl_body _visitors_floc_ - | Ptop_letdef - { - binder = _visitors_fbinder; - ty = _visitors_fty; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - is_constant = _visitors_fis_constant; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty - _visitors_fexpr _visitors_fis_pub _visitors_fis_constant - _visitors_floc_ _visitors_fdoc_ - | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 - | Ptop_impl - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - method_name = _visitors_fmethod_name; - has_error = _visitors_fhas_error; - quantifiers = _visitors_fquantifiers; - params = _visitors_fparams; - ret_ty = _visitors_fret_ty; - body = _visitors_fbody; - is_pub = _visitors_fis_pub; - local_types = _visitors_flocal_types; - loc_ = _visitors_floc_; - header_loc_ = _visitors_fheader_loc_; - doc_ = _visitors_fdoc_; - } -> - self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait - _visitors_fmethod_name _visitors_fhas_error - _visitors_fquantifiers _visitors_fparams _visitors_fret_ty - _visitors_fbody _visitors_fis_pub _visitors_flocal_types - _visitors_floc_ _visitors_fheader_loc_ _visitors_fdoc_ - | Ptop_impl_relation - { - self_ty = _visitors_fself_ty; - trait = _visitors_ftrait; - quantifiers = _visitors_fquantifiers; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - } -> - self#visit_Ptop_impl_relation env _visitors_fself_ty - _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub - _visitors_floc_ - - method visit_Interp_lit - : _ -> string -> string -> location -> interp_elem = - fun env _visitors_fstr _visitors_frepr _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fstr - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_frepr - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Interp_lit - { str = _visitors_r0; repr = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Ptop_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_expr env _visitors_fexpr _visitors_fis_main + _visitors_flocal_types _visitors_floc_ + | Ptop_test + { + expr = _visitors_fexpr; + name = _visitors_fname; + params = _visitors_fparams; + local_types = _visitors_flocal_types; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_test env _visitors_fexpr _visitors_fname + _visitors_fparams _visitors_flocal_types _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_typedef _visitors_c0 -> + self#visit_Ptop_typedef env _visitors_c0 + | Ptop_funcdef + { + fun_decl = _visitors_ffun_decl; + decl_body = _visitors_fdecl_body; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_funcdef env _visitors_ffun_decl + _visitors_fdecl_body _visitors_floc_ + | Ptop_letdef + { + binder = _visitors_fbinder; + ty = _visitors_fty; + expr = _visitors_fexpr; + vis = _visitors_fvis; + is_constant = _visitors_fis_constant; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_letdef env _visitors_fbinder _visitors_fty + _visitors_fexpr _visitors_fvis _visitors_fis_constant + _visitors_floc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_trait _visitors_c0 -> self#visit_Ptop_trait env _visitors_c0 + | Ptop_trait_alias + { + binder = _visitors_fbinder; + target = _visitors_ftarget; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_trait_alias env _visitors_fbinder + _visitors_ftarget _visitors_fvis _visitors_floc_ + _visitors_fattrs _visitors_fdoc_ + | Ptop_impl + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + method_name = _visitors_fmethod_name; + has_error = _visitors_fhas_error; + quantifiers = _visitors_fquantifiers; + params = _visitors_fparams; + ret_ty = _visitors_fret_ty; + body = _visitors_fbody; + vis = _visitors_fvis; + loc_ = _visitors_floc_; + header_loc_ = _visitors_fheader_loc_; + attrs = _visitors_fattrs; + doc_ = _visitors_fdoc_; + } -> + self#visit_Ptop_impl env _visitors_fself_ty _visitors_ftrait + _visitors_fmethod_name _visitors_fhas_error + _visitors_fquantifiers _visitors_fparams _visitors_fret_ty + _visitors_fbody _visitors_fvis _visitors_floc_ + _visitors_fheader_loc_ _visitors_fattrs _visitors_fdoc_ + | Ptop_impl_relation + { + self_ty = _visitors_fself_ty; + trait = _visitors_ftrait; + quantifiers = _visitors_fquantifiers; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + } -> + self#visit_Ptop_impl_relation env _visitors_fself_ty + _visitors_ftrait _visitors_fquantifiers _visitors_fis_pub + _visitors_floc_ + + method visit_Interp_lit : + _ -> string -> string -> location -> interp_elem = + fun env -> + fun _visitors_fstr -> + fun _visitors_frepr -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fstr + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_frepr + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Interp_lit + { + str = _visitors_r0; + repr = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Interp_expr : _ -> expr -> location -> interp_elem = - fun env _visitors_fexpr _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_floc_ - in - Interp_expr { expr = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_floc_ + in + Interp_expr { expr = _visitors_r0; loc_ = _visitors_r1 } method visit_Interp_source : _ -> Literal.interp_source -> interp_elem = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_interp_source env _visitors_c0 in - Interp_source _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_interp_source env _visitors_c0 in + Interp_source _visitors_r0 method visit_interp_elem : _ -> interp_elem -> interp_elem = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit - { - str = _visitors_fstr; - repr = _visitors_frepr; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_lit env _visitors_fstr _visitors_frepr - _visitors_floc_ - | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ - | Interp_source _visitors_c0 -> - self#visit_Interp_source env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit + { + str = _visitors_fstr; + repr = _visitors_frepr; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_lit env _visitors_fstr _visitors_frepr + _visitors_floc_ + | Interp_expr { expr = _visitors_fexpr; loc_ = _visitors_floc_ } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_floc_ + | Interp_source _visitors_c0 -> + self#visit_Interp_source env _visitors_c0 method visit_Multiline_string : _ -> string -> multiline_string_elem = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Multiline_string _visitors_r0 - - method visit_Multiline_interp - : _ -> interp_elem list -> multiline_string_elem = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_interp_elem env)) - _visitors_c0 - in - Multiline_interp _visitors_r0 - - method visit_multiline_string_elem - : _ -> multiline_string_elem -> multiline_string_elem = - fun env _visitors_this -> - match _visitors_this with - | Multiline_string _visitors_c0 -> - self#visit_Multiline_string env _visitors_c0 - | Multiline_interp _visitors_c0 -> - self#visit_Multiline_interp env _visitors_c0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + Multiline_string _visitors_r0 + + method visit_Multiline_interp : + _ -> interp_elem list -> multiline_string_elem = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_interp_elem env)) + _visitors_c0 + in + Multiline_interp _visitors_r0 + + method visit_multiline_string_elem : + _ -> multiline_string_elem -> multiline_string_elem = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Multiline_string _visitors_c0 -> + self#visit_Multiline_string env _visitors_c0 + | Multiline_interp _visitors_c0 -> + self#visit_Multiline_interp env _visitors_c0 method visit_impls : _ -> impls -> impls = - fun env _visitors_this -> - Basic_lst.map _visitors_this (self#visit_impl env) + fun env -> + fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_impl env) end [@@@VISITORS.END] @@ -9449,13 +11897,15 @@ include struct let _ = fun (_ : argument) -> () let _ = fun (_ : parameters) -> () let _ = fun (_ : parameter) -> () - let _ = fun (_ : parameter_kind) -> () let _ = fun (_ : func) -> () + let _ = fun (_ : case) -> () + let _ = fun (_ : multi_arg_case) -> () let _ = fun (_ : spreadable_elem) -> () let _ = fun (_ : map_expr_elem) -> () let _ = fun (_ : error_typ) -> () let _ = fun (_ : typ) -> () let _ = fun (_ : pattern) -> () + let _ = fun (_ : array_patterns) -> () let _ = fun (_ : array_pattern) -> () let _ = fun (_ : field_def) -> () let _ = fun (_ : field_pat) -> () @@ -9486,47 +11936,57 @@ include struct end let filter_fields ctor fields = - Basic_lst.fold_right fields [] (fun field acc -> - match field with - | ( ( "params_loc_" | "loc_" | "index_loc_" | "try_loc_" | "catch_loc_" - | "constr_loc" | "tycon_loc_" | "local_tycon_loc_" | "constr_loc_" - | "field_loc_" | "header_loc_" | "trait_loc_" | "question_loc" - | "match_loc_" | "loop_loc_" | "fn_loc_" | "key_loc_" | "else_loc_" ), - _ ) - when not !Basic_config.show_loc -> - acc - | "args_loc_", _ -> acc - | "repr", _ -> acc - | ("doc_" | "trait_doc_"), _ when not !Basic_config.show_doc -> acc - | ("is_pub" | "abbreviation" | "faked"), S.Atom "false" -> acc - | "faked", S.Atom "true" -> ("faked", S.Atom "faked") :: acc - | ("field_vis" | "type_vis"), S.Atom "Vis_default" -> acc - | "deriving_", List [] -> acc - | ("ty_params_" | "type_name"), List [] -> acc - | "is_closed", S.Atom "true" -> acc - | "continue_block", List [] -> acc - | "args", List [] when ctor = "Pexpr_continue" -> acc - | "arg", List [] when ctor = "Pexpr_break" -> acc - | "trait_supers", List [] -> acc - | "param_kind", Atom "Positional" -> acc - | "is_main", S.Atom "false" -> acc - | "arg_is_pun_", Atom "false" -> acc - | ("doc_" | "intf_doc_"), List [] -> acc - | "pragmas", List [] -> acc - | "kind_", Atom "Lambda" -> acc - | "is_open", Atom "false" when ctor = "Ppat_constr" -> acc - | "augmented_by", List [] -> acc - | "return_self", Atom "false" -> acc - | "return_self", Atom "true" -> - ("return_self", List [ Atom "return_self" ]) :: acc - | "has_error", Atom "false" -> acc - | "extend_error", Atom "false" -> acc - | "attr", Atom "No_attr" -> acc - | "local_types", List [] -> acc - | "is_constant", Atom "false" when ctor = "Ptop_letdef" -> acc - | "is_constant", Atom "true" when ctor = "Ptop_letdef" -> - ("is_constant", List [ Atom "is_constant" ]) :: acc - | _ -> field :: acc) + Basic_lst.fold_right fields [] (fun field -> + fun acc -> + match field with + | ( ( "params_loc_" | "loc_" | "index_loc_" | "try_loc_" | "catch_loc_" + | "constr_loc" | "tycon_loc_" | "local_tycon_loc_" | "constr_loc_" + | "field_loc_" | "header_loc_" | "trait_loc_" | "question_loc" + | "match_loc_" | "loop_loc_" | "fn_loc_" | "key_loc_" | "else_loc_" + ), + _ ) + when not !Basic_config.show_loc -> + acc + | "args_loc_", _ -> acc + | "repr", _ -> acc + | ("doc_" | "trait_doc_"), _ when not !Basic_config.show_doc -> acc + | ("is_pub" | "abbreviation" | "faked"), S.Atom "false" -> acc + | "faked", S.Atom "true" -> ("faked", S.Atom "faked") :: acc + | ("field_vis" | "type_vis"), S.Atom "Vis_default" -> acc + | "deriving_", List [] -> acc + | ("ty_params_" | "type_name"), List [] -> acc + | "is_closed", S.Atom "true" -> acc + | "continue_block", List [] -> acc + | "args", List [] when ctor = "Pexpr_continue" -> acc + | "arg", List [] when ctor = "Pexpr_break" -> acc + | "trait_supers", List [] -> acc + | "param_kind", Atom "Positional" -> acc + | "is_main", S.Atom "false" -> acc + | "arg_is_pun_", Atom "false" -> acc + | ("doc_" | "intf_doc_"), List [] -> acc + | "pragmas", List [] -> acc + | "kind_", Atom "Lambda" -> acc + | "is_open", Atom "false" when ctor = "Ppat_constr" -> acc + | "augmented_by", List [] -> acc + | "return_self", Atom "false" -> acc + | "return_self", Atom "true" -> + ("return_self", List [ Atom "return_self" ]) :: acc + | "has_error", Atom "false" -> acc + | "has_error", List [] -> acc + | "has_error", List (_ :: []) when not !Basic_config.show_loc -> + ("has_error", Atom "true") :: acc + | "extend_error", Atom "false" -> acc + | "attr", Atom "No_attr" -> acc + | "local_types", List [] -> acc + | "is_constant", Atom "false" when ctor = "Ptop_letdef" -> acc + | "is_constant", Atom "true" when ctor = "Ptop_letdef" -> + ("is_constant", List [ Atom "is_constant" ]) :: acc + | "label", List [] -> acc + | "is_async", Atom "false" -> acc + | "is_async", Atom "true" -> ("is_async", List [ Atom "async" ]) :: acc + | ("attrs" | "trait_attrs"), List [] -> acc + | "constr_tag", List [] -> acc + | _ -> field :: acc) let loc_of_impl i = match i with @@ -9536,10 +11996,39 @@ let loc_of_impl i = | Ptop_funcdef { loc_; _ } | Ptop_letdef { loc_; _ } | Ptop_trait { trait_loc_ = loc_; _ } + | Ptop_trait_alias { loc_; _ } | Ptop_impl { loc_; _ } | Ptop_impl_relation { loc_; _ } -> loc_ +let binder_name_of_param (p : parameter) = + (match p with + | Discard_positional _ -> "_" + | Positional { binder; _ } + | Labelled { binder; _ } + | Optional { binder; _ } + | Question_optional { binder; _ } -> + binder.binder_name + : string) + +let ty_of_param (p : parameter) = + (match p with + | Discard_positional { ty; _ } -> ty + | Positional { ty; _ } -> ty + | Labelled { ty; _ } -> ty + | Optional { ty; _ } -> ty + | Question_optional { ty; _ } -> ty + : typ option) + +let loc_of_param_binder (p : parameter) = + (match p with + | Discard_positional { loc_; _ } -> loc_ + | Positional { binder; _ } -> binder.loc_ + | Labelled { binder; _ } -> binder.loc_ + | Optional { binder; _ } -> binder.loc_ + | Question_optional { binder; _ } -> binder.loc_ + : location) + type loc_ctx = Use_absolute_loc of absolute_loc | Use_relative_loc let sexp = @@ -9559,20 +12048,15 @@ let sexp = else super#visit_docstring env docstring method! visit_parameter env p = - match p.param_kind with - | Positional -> + match p with + | Positional { binder; ty } -> List [ - self#visit_binder env p.param_binder; - Moon_sexp_conv.sexp_of_option (self#visit_typ env) p.param_annot; - ] - | _ -> - List - [ - self#visit_binder env p.param_binder; - Moon_sexp_conv.sexp_of_option (self#visit_typ env) p.param_annot; - self#visit_parameter_kind env p.param_kind; + self#visit_binder env binder; + Moon_sexp_conv.sexp_of_option (self#visit_typ env) ty; ] + | Discard_positional _ | Labelled _ | Optional _ | Question_optional _ -> + super#visit_parameter env p method! visit_argument env arg = match arg.arg_kind with @@ -9604,7 +12088,7 @@ let sexp = method! visit_location env loc = match env with - | Use_absolute_loc base -> Rloc.to_loc ~base loc |> sexp_of_absolute_loc + | Use_absolute_loc base -> sexp_of_absolute_loc (Rloc.to_loc ~base loc) | Use_relative_loc -> super#visit_location env loc method! visit_impl env impl = @@ -9613,6 +12097,37 @@ let sexp = let base = loc_of_impl impl in super#visit_impl (Use_absolute_loc base) impl | Use_relative_loc -> super#visit_impl Use_relative_loc impl + + method! visit_array_pattern env pat = + match pat with + | Pattern p -> self#visit_pattern env p + | String_spread s -> S.List [ Atom "String_spread"; Atom s.string_val ] + | String_spread_const { binder; pkg = None } -> + S.List [ Atom "String_spread_const"; Atom binder.binder_name ] + | String_spread_const { binder; pkg = Some pkg } -> + S.List + [ + Atom "String_spread_const"; + Atom + (Stdlib.String.concat "" + [ "@"; pkg; "."; binder.binder_name ] [@merlin.hide]); + ] + + method! visit_case env case = + match case with + | { pattern = p; guard = None; body = action } -> + S.List [ self#visit_pattern env p; self#visit_expr env action ] + | _ -> super#visit_case env case + + method! visit_multi_arg_case env case = + match case with + | { patterns = p; guard = None; body = action } -> + S.List + [ + S.List (Basic_lst.map p (self#visit_pattern env)); + self#visit_expr env action; + ] + | _ -> super#visit_multi_arg_case env case end let sexp_of_impl impl = sexp#visit_impl Use_relative_loc impl @@ -9632,17 +12147,18 @@ let sexp_of_type_decl type_decl = let sexp_of_trait_decl trait_decl = sexp#visit_trait_decl Use_relative_loc trait_decl -let sexp_of_argument argument = sexp#visit_argument Use_relative_loc argument - -let sexp_of_deriving_directive deriving = - sexp#visit_deriving_directive Use_relative_loc deriving - let string_of_vis = function | Vis_default -> "abstract" | Vis_priv _ -> "private" | Vis_pub { attr = None } -> "public" | Vis_pub { attr = Some attr } -> "public " ^ attr +let string_of_apply_attr = function + | Exclamation -> "!" + | Question -> "?" + | Double_exclamation -> "!!" + | No_attr -> "" + let loc_of_expression e = match e with | Pexpr_apply { loc_; _ } @@ -9692,7 +12208,8 @@ let loc_of_expression e = | Pexpr_pipe { loc_; _ } | Pexpr_map { loc_; _ } | Pexpr_group { loc_; _ } - | Pexpr_multiline_string { loc_; _ } -> + | Pexpr_multiline_string { loc_; _ } + | Pexpr_is { loc_; _ } -> loc_ | Pexpr_static_assert _ -> Rloc.no_location @@ -9718,5 +12235,6 @@ let loc_of_type_expression te = | Ptype_arrow { loc_; _ } | Ptype_tuple { loc_; _ } | Ptype_name { loc_; _ } - | Ptype_option { loc_; _ } -> + | Ptype_option { loc_; _ } + | Ptype_object { loc_; _ } -> loc_ diff --git a/src/parsing_util.ml b/src/parsing_util.ml index 649e1b2..d44279e 100644 --- a/src/parsing_util.ml +++ b/src/parsing_util.ml @@ -15,6 +15,10 @@ module Syntax = Parsing_syntax module Operators = Parsing_operators +module Lst = Basic_lst +module Vec = Basic_vec +module Menhir_token = Lex_menhir_token +module Unicode_lex = Lex_unicode_lex type constant = Syntax.constant type label = Syntax.label @@ -37,71 +41,73 @@ let i (start, end_) = let enter_next_block () = Parsing_menhir_state.update_state () let aloc = Loc.of_menhir -let make_Pexpr_constant ~loc_ c : expr = Pexpr_constant { c; loc_ } -let make_Pexpr_ident ~loc_ id : expr = Pexpr_ident { id; loc_ } -let make_Pexpr_tuple ~loc_ exprs : expr = Pexpr_tuple { exprs; loc_ } - -let make_Pexpr_array ~loc_ (elems : Syntax.spreadable_elem list) : expr = - let exception To_spread in - try - Pexpr_array - { - exprs = - Basic_lst.map elems (function - | Elem_regular e -> e - | Elem_spread _ -> raise_notrace To_spread); - loc_; - } - with To_spread -> Pexpr_array_spread { elems; loc_ } - -let make_interps c : Syntax.interp_elem list = - List.map - (fun lit -> - match lit with - | Lex_literal.Interp_lit { c; repr; loc_ } -> - let loc_ = - Rloc.of_loc ~base:(Parsing_menhir_state.get_base_pos ()) loc_ - in - Syntax.Interp_lit { str = c; repr; loc_ } - | Interp_source s -> Syntax.Interp_source s) - c - -let make_Pexpr_interp ~loc_ c : expr = - let elems = make_interps c in - Pexpr_interp { elems; loc_ } - -let make_Pexpr_record ~loc_ ~trailing type_name fs : expr = - Pexpr_record { type_name; fields = fs; loc_; trailing } - -let make_Ppat_alias ~loc_ (pat, alias) : pattern = - Ppat_alias { pat; alias; loc_ } - -let make_Ppat_constant ~loc_ c : pattern = Ppat_constant { c; loc_ } -let make_Ppat_tuple ~loc_ pats : pattern = Ppat_tuple { pats; loc_ } - -let make_Ppat_constr ~loc_ (constr, args, is_open) : pattern = - Ppat_constr { constr; args; is_open; loc_ } - -let make_Ptype_tuple ~loc_ tys : typ = Ptype_tuple { tys; loc_ } - -let make_Ptype_option ~loc_ ~constr_loc ty : typ = - Ptype_option { loc_; question_loc = constr_loc; ty } - -let make_field_pat ~loc_ label pattern is_pun : field_pat = - Field_pat { label; pattern; is_pun; loc_ } - -let make_uplus ~loc_ name (arg : expr) : expr = - match (name, arg) with - | "+", Pexpr_constant { c = Const_int _; _ } -> arg - | "+", Pexpr_constant { c = Const_double _; _ } -> arg - | _ -> - Pexpr_apply - { - loc_; - func = make_Pexpr_ident ~loc_ { var_name = Lident "~+"; loc_ }; - args = [ { arg_value = arg; arg_kind = Positional } ]; - attr = No_attr; - } +let make_Pexpr_constant ~loc_ c = (Pexpr_constant { c; loc_ } : expr) +let make_Pexpr_ident ~loc_ id = (Pexpr_ident { id; loc_ } : expr) +let make_Pexpr_tuple ~loc_ exprs = (Pexpr_tuple { exprs; loc_ } : expr) + +let make_Pexpr_array ~loc_ (elems : Syntax.spreadable_elem list) = + (let exception To_spread in + try + Pexpr_array + { + exprs = + Basic_lst.map elems (function + | Elem_regular e -> e + | Elem_spread _ -> raise_notrace To_spread); + loc_; + } + with To_spread -> Pexpr_array_spread { elems; loc_ } + : expr) + +let make_interps c = + (Lst.map c (fun lit -> + match lit with + | Lex_literal.Interp_lit { c; repr; loc_ } -> + let loc_ = + Rloc.of_loc ~base:(Parsing_menhir_state.get_base_pos ()) loc_ + in + Syntax.Interp_lit { str = c; repr; loc_ } + | Interp_source s -> Syntax.Interp_source s) + : Syntax.interp_elem list) + +let make_Pexpr_interp ~loc_ c = + (let elems = make_interps c in + Pexpr_interp { elems; loc_ } + : expr) + +let make_Pexpr_record ~loc_ ~trailing type_name fs = + (Pexpr_record { type_name; fields = fs; loc_; trailing } : expr) + +let make_Ppat_alias ~loc_ (pat, alias) = + (Ppat_alias { pat; alias; loc_ } : pattern) + +let make_Ppat_constant ~loc_ c = (Ppat_constant { c; loc_ } : pattern) +let make_Ppat_tuple ~loc_ pats = (Ppat_tuple { pats; loc_ } : pattern) + +let make_Ppat_constr ~loc_ (constr, args, is_open) = + (Ppat_constr { constr; args; is_open; loc_ } : pattern) + +let make_Ptype_tuple ~loc_ tys = (Ptype_tuple { tys; loc_ } : typ) + +let make_Ptype_option ~loc_ ~constr_loc ty = + (Ptype_option { loc_; question_loc = constr_loc; ty } : typ) + +let make_field_pat ~loc_ label pattern is_pun = + (Field_pat { label; pattern; is_pun; loc_ } : field_pat) + +let make_uplus ~loc_ name (arg : expr) = + (match (name, arg) with + | "+", Pexpr_constant { c = Const_int _; _ } -> arg + | "+", Pexpr_constant { c = Const_double _; _ } -> arg + | _ -> + Pexpr_apply + { + loc_; + func = make_Pexpr_ident ~loc_ { var_name = Lident "~+"; loc_ }; + args = [ { arg_value = arg; arg_kind = Positional } ]; + attr = No_attr; + } + : expr) let make_uminus ~loc_ name (arg : expr) = match (name, arg) with @@ -130,160 +136,203 @@ let bracket_loc index = let _end = Rloc.shift_col _end 1 in Rloc.of_pos (start, _end) -let desugar_array_get ~loc_ obj index : expr = - Pexpr_dot_apply - { - self = obj; - method_name = - { - label_name = (Operators.find_exn "_[_]").method_name; - loc_ = bracket_loc index; - }; - args = [ { arg_value = index; arg_kind = Positional } ]; - return_self = false; - attr = No_attr; - loc_; - } - -let desugar_array_get_slice ~loc_ ~index_loc_ obj start_index end_index : expr = - let start_label : label = { label_name = "start"; loc_ = Rloc.no_location } in - let end_label : label = { label_name = "end"; loc_ = Rloc.no_location } in - let start_arg : argument = - match start_index with - | None -> - { - arg_value = - Pexpr_constant - { c = Const_int (Int.to_string 0); loc_ = Rloc.no_location }; - arg_kind = Labelled start_label; - } - | Some start_index -> - { arg_value = start_index; arg_kind = Labelled start_label } - in - let args = - match end_index with - | None -> [ start_arg ] - | Some arg_value -> - [ start_arg; { arg_value; arg_kind = Labelled end_label } ] - in - Pexpr_dot_apply - { - self = obj; - method_name = - { - label_name = (Operators.find_exn "_[_:_]").method_name; - loc_ = index_loc_; - }; - args; - return_self = false; - attr = No_attr; - loc_; - } - -let desugar_array_set ~loc_ obj index value : expr = - Pexpr_dot_apply - { - self = obj; - method_name = - { - label_name = (Operators.find_exn "_[_]=_").method_name; - loc_ = bracket_loc index; - }; - args = - [ - { arg_value = index; arg_kind = Positional }; - { arg_value = value; arg_kind = Positional }; - ]; - return_self = false; - attr = No_attr; - loc_; - } - -let desugar_array_augmented_set ~loc_ op array index value : expr = - let arr_name = - let i = Basic_uuid.next () in - ("*array_" ^ Int.to_string i : Stdlib.String.t) - in - let arr_loc = loc_of_expression array in - let arr_var : var = { var_name = Lident arr_name; loc_ = arr_loc } in - let arr_ident : expr = Pexpr_ident { id = arr_var; loc_ = arr_loc } in - let idx_name = - let i = Basic_uuid.next () in - ("*index_" ^ Int.to_string i : Stdlib.String.t) - in - let idx_loc = loc_of_expression index in - let idx_var : var = { var_name = Lident idx_name; loc_ = idx_loc } in - let idx_ident : expr = Pexpr_ident { id = idx_var; loc_ = idx_loc } in - Pexpr_let - { - pattern = Ppat_var { binder_name = arr_name; loc_ = Rloc.no_location }; - expr = array; - body = - Pexpr_let - { - pattern = - Ppat_var { binder_name = idx_name; loc_ = Rloc.no_location }; - expr = index; - body = - desugar_array_set ~loc_ arr_ident idx_ident - (Pexpr_infix - { - op; - lhs = desugar_array_get ~loc_ arr_ident idx_ident; - rhs = value; - loc_; - }); - loc_; - }; - loc_; - } - -let make_assign_opt ~loc_ (lhs : expr) (rhs : expr) : expr option = - match lhs with - | Pexpr_ident { id; _ } -> - Some (Pexpr_assign { var = id; expr = rhs; augmented_by = None; loc_ }) - | Pexpr_field { record; accessor; _ } -> - Some - (Pexpr_mutate - { record; accessor; field = rhs; augmented_by = None; loc_ }) - | Pexpr_array_get { array; index; loc_ } -> - Some (Pexpr_array_set { array; index; value = rhs; loc_ }) - | _ -> None - -let make_augmented_assign_opt ~loc_ (op : var) (lhs : expr) (rhs : expr) : - expr option = - match lhs with - | Pexpr_ident { id; _ } -> - Some (Pexpr_assign { var = id; expr = rhs; augmented_by = Some op; loc_ }) - | Pexpr_field { record; accessor; _ } -> - Some - (Pexpr_mutate - { record; accessor; field = rhs; augmented_by = Some op; loc_ }) - | Pexpr_array_get { array; index; loc_ } -> - Some (Pexpr_array_augmented_set { op; array; index; value = rhs; loc_ }) - | _ -> None - -let make_field_def ~loc_ label expr is_pun : field_def = - Field_def { label; expr; is_pun; loc_ } +let desugar_array_get ~loc_ obj index = + (Pexpr_dot_apply + { + self = obj; + method_name = + { + label_name = (Operators.find_exn "_[_]").method_name; + loc_ = bracket_loc index; + }; + args = [ { arg_value = index; arg_kind = Positional } ]; + return_self = false; + attr = No_attr; + loc_; + } + : expr) + +let desugar_array_get_slice ~loc_ ~index_loc_ obj start_index end_index = + (let start_label : label = + { label_name = "start"; loc_ = Rloc.no_location } + in + let end_label : label = { label_name = "end"; loc_ = Rloc.no_location } in + let end_arg : argument list = + match end_index with + | None -> [] + | Some arg_value -> [ { arg_value; arg_kind = Labelled end_label } ] + in + let args : argument list = + match start_index with + | None -> end_arg + | Some start_index -> + { arg_value = start_index; arg_kind = Labelled start_label } :: end_arg + in + Pexpr_dot_apply + { + self = obj; + method_name = + { + label_name = (Operators.find_exn "_[_:_]").method_name; + loc_ = index_loc_; + }; + args; + return_self = false; + attr = No_attr; + loc_; + } + : expr) + +let desugar_array_set ~loc_ obj index value = + (Pexpr_dot_apply + { + self = obj; + method_name = + { + label_name = (Operators.find_exn "_[_]=_").method_name; + loc_ = bracket_loc index; + }; + args = + [ + { arg_value = index; arg_kind = Positional }; + { arg_value = value; arg_kind = Positional }; + ]; + return_self = false; + attr = No_attr; + loc_; + } + : expr) + +let desugar_array_augmented_set ~loc_ op array index value = + (let arr_name = + let i = Basic_uuid.next () in + ("*array_" ^ Int.to_string i : Stdlib.String.t) + in + let arr_loc = loc_of_expression array in + let arr_var : var = { var_name = Lident arr_name; loc_ = arr_loc } in + let arr_ident : expr = Pexpr_ident { id = arr_var; loc_ = arr_loc } in + let idx_name = + let i = Basic_uuid.next () in + ("*index_" ^ Int.to_string i : Stdlib.String.t) + in + let idx_loc = loc_of_expression index in + let idx_var : var = { var_name = Lident idx_name; loc_ = idx_loc } in + let idx_ident : expr = Pexpr_ident { id = idx_var; loc_ = idx_loc } in + Pexpr_let + { + pattern = Ppat_var { binder_name = arr_name; loc_ = Rloc.no_location }; + expr = array; + body = + Pexpr_let + { + pattern = + Ppat_var { binder_name = idx_name; loc_ = Rloc.no_location }; + expr = index; + body = + desugar_array_set ~loc_ arr_ident idx_ident + (Pexpr_infix + { + op; + lhs = desugar_array_get ~loc_ arr_ident idx_ident; + rhs = value; + loc_; + }); + loc_; + }; + loc_; + } + : expr) + +let make_assign_opt ~loc_ (lhs : expr) (rhs : expr) = + (match lhs with + | Pexpr_ident { id; _ } -> + Some (Pexpr_assign { var = id; expr = rhs; augmented_by = None; loc_ }) + | Pexpr_field { record; accessor; _ } -> + Some + (Pexpr_mutate + { record; accessor; field = rhs; augmented_by = None; loc_ }) + | Pexpr_array_get { array; index; loc_ } -> + Some (Pexpr_array_set { array; index; value = rhs; loc_ }) + | _ -> None + : expr option) + +let make_augmented_assign_opt ~loc_ (op : var) (lhs : expr) (rhs : expr) = + (match lhs with + | Pexpr_ident { id; _ } -> + Some + (Pexpr_assign { var = id; expr = rhs; augmented_by = Some op; loc_ }) + | Pexpr_field { record; accessor; _ } -> + Some + (Pexpr_mutate + { record; accessor; field = rhs; augmented_by = Some op; loc_ }) + | Pexpr_array_get { array; index; loc_ } -> + Some (Pexpr_array_augmented_set { op; array; index; value = rhs; loc_ }) + | _ -> None + : expr option) + +let make_field_def ~loc_ label expr is_pun = + (Field_def { label; expr; is_pun; loc_ } : field_def) let label_to_expr ~loc_ (l : label) = make_Pexpr_ident ~loc_ { var_name = Lident l.label_name; loc_ } -let label_to_pat ~loc_ (l : label) : pattern = - Ppat_var { binder_name = l.label_name; loc_ } - -let make_int (i : string) : constant = - match Basic_strutil.ends_with_then_chop i "L" with - | Some i -> ( - match Basic_strutil.ends_with_then_chop i "U" with - | Some u64 -> Const_uint64 u64 - | None -> Const_int64 i) - | None -> ( - match Basic_strutil.ends_with_then_chop i "U" with - | Some u32 -> Const_uint u32 - | None -> ( - match Basic_strutil.ends_with_then_chop i "N" with - | Some bigint -> Const_bigint bigint - | None -> Const_int i)) - -let make_float (f : string) : constant = Const_double f +let label_to_pat ~loc_ (l : label) = + (Ppat_var { binder_name = l.label_name; loc_ } : pattern) + +let make_int (i : string) = + (match Basic_strutil.ends_with_then_chop i "L" with + | Some i -> ( + match Basic_strutil.ends_with_then_chop i "U" with + | Some u64 -> Const_uint64 u64 + | None -> Const_int64 i) + | None -> ( + match Basic_strutil.ends_with_then_chop i "U" with + | Some u32 -> Const_uint u32 + | None -> ( + match Basic_strutil.ends_with_then_chop i "N" with + | Some bigint -> Const_bigint bigint + | None -> Const_int i)) + : constant) + +let make_float (f : string) = (Const_double f : constant) + +let make_attribute ~loc_ str = + let diagnostics = Diagnostics.make () in + let start_pos = Lexing.dummy_pos in + let tokens = + Unicode_lex.tokens_of_string ~start_pos ~name:start_pos.pos_fname + ~diagnostics ~comment:false str + in + let lexbuf : Lexing.lexbuf = Lexing.from_string "" in + let next = ref 0 in + let lexer (_lexbuf : Lexing.lexbuf) = + (match Vec.get tokens !next with + | Menhir_token.EOF, _, _ -> Menhir_token.EOF + | tok, spos, epos -> + incr next; + lexbuf.lex_start_p <- spos; + lexbuf.lex_curr_p <- epos; + tok + : Menhir_token.token) + in + match Attribute_parser.attribute lexer lexbuf with + | exception Attribute_parser.Error -> + let tok, spos, epos = + let i = if !next = 0 then 0 else !next - 1 in + Vec.get tokens i + in + let expect_string = + Lex_menhir_token_util.token_kind_to_expect_string + (Menhir_token.kind_of_token tok) + in + Diagnostics.add_warning diagnostics + { + loc = Loc.of_menhir (spos, epos); + kind = + Invalid_attribute + (("unexpected " ^ expect_string ^ " here" + : Stdlib.String.t) + [@merlin.hide]); + }; + { Attribute.loc_; raw = str; parsed = None } + | expr -> { Attribute.loc_; raw = str; parsed = Some expr } diff --git a/src/pass_contification.ml b/src/pass_contification.ml index 810e9fc..0b53903 100644 --- a/src/pass_contification.ml +++ b/src/pass_contification.ml @@ -16,123 +16,94 @@ module Lst = Basic_lst module Ident = Basic_core_ident -let not_in (ident : Ident.t) (expr : Core.expr) = - let rec go : Core.expr -> bool = function - | Cexpr_break { arg; _ } -> ( - match arg with None -> true | Some arg -> go arg) - | Cexpr_continue { args; _ } -> Lst.for_all args go - | Cexpr_loop { body; args; _ } -> Lst.for_all args go && go body - | Cexpr_const _ | Cexpr_unit _ -> true - | Cexpr_var { id; _ } -> not (Ident.equal id ident) - | Cexpr_as { expr; _ } - | Cexpr_assign { expr; _ } - | Cexpr_field { record = expr; _ } -> - go expr - | Cexpr_array { exprs = args; _ } - | Cexpr_tuple { exprs = args; _ } - | Cexpr_prim { args; _ } -> - Lst.for_all args go - | Cexpr_sequence { expr1; expr2; _ } - | Cexpr_mutate { record = expr1; field = expr2; _ } -> - go expr1 && go expr2 - | Cexpr_let { name; rhs; body; _ } -> - Ident.equal name ident || (go rhs && go body) - | Cexpr_function { func; _ } -> go func.body - | Cexpr_apply { func; args; _ } -> - (not (Ident.equal func ident)) && Lst.for_all args go - | Cexpr_letrec { bindings; body; _ } -> - Lst.for_all bindings (fun (binder, fn) -> - Ident.equal binder ident || go fn.body) - && go body - | Cexpr_letfn { name; fn; body; _ } -> - Ident.equal name ident || (go fn.body && go body) - | Cexpr_constr { args; _ } -> Lst.for_all args go - | Cexpr_record { fields; _ } -> Lst.for_all fields (fun def -> go def.expr) - | Cexpr_record_update { record; fields; _ } -> - go record && Lst.for_all fields (fun def -> go def.expr) - | Cexpr_if { cond; ifso; ifnot; _ } -> ( - go cond && go ifso && match ifnot with None -> true | Some e -> go e) - | Cexpr_switch_constr { obj; cases; default; _ } -> ( - go obj - && Lst.for_all cases (fun (_, binder, expr) -> - (match binder with - | None -> false - | Some binder -> Ident.equal binder ident) - || go expr) - && match default with None -> true | Some default -> go default) - | Cexpr_switch_constant { obj; cases; default; _ } -> - go obj && Lst.for_all cases (fun (_, expr) -> go expr) && go default - | Cexpr_handle_error { obj; handle_kind = _; ty = _ } -> go obj - | Cexpr_return { expr; _ } -> go expr - in - go expr - type contify_result = | Never_called | Contifiable | Not_contifiable of { tail_called : bool } -let is_contifiable (ident : Ident.t) (expr : Core.expr) = +let is_contifiable (ident : Ident.t) (expr : Core.expr) ~treat_return_as_tail = let has_other_occurence = ref false in let tail_called = ref false in - let rec analyze_usage (expr : Core.expr) = - let got expr = - if (not !has_other_occurence) || not !tail_called then analyze_usage expr - [@@inline] - in + let rec analyze_usage (expr : Core.expr) ~is_tail ~in_nested_call = + let got expr = analyze_usage expr ~is_tail ~in_nested_call [@@inline] in let gon expr = - if not !has_other_occurence then - has_other_occurence := not (not_in ident expr) + analyze_usage expr ~is_tail:false ~in_nested_call [@@inline] in - match expr with - | Cexpr_apply { func; args; _ } when Ident.equal func ident -> - Lst.iter args gon; - tail_called := true - | Cexpr_let { name = _; rhs; body; _ } -> - gon rhs; - got body - | Cexpr_letrec { bindings; body; _ } -> - Lst.iter bindings (fun (_, fn) -> gon fn.body); - got body - | Cexpr_letfn { name = _; fn; body; kind; _ } -> ( - match kind with - | Tail_join | Nontail_join -> - got fn.body; - got body - | Nonrec | Rec -> - gon fn.body; - got body) - | Cexpr_if { cond; ifso; ifnot; _ } -> ( - gon cond; - got ifso; - match ifnot with None -> () | Some e -> got e) - | Cexpr_sequence { expr1; expr2; _ } -> - gon expr1; - got expr2 - | Cexpr_switch_constr { obj; cases; default; _ } -> ( - gon obj; - Lst.iter cases (fun (_, _, expr) -> got expr); - match default with None -> () | Some default -> got default) - | Cexpr_switch_constant { obj; cases; default; _ } -> - gon obj; - Lst.iter cases (fun (_, expr) -> got expr); - got default - | Cexpr_prim { prim = Psequand | Psequor; args = [ expr1; expr2 ]; ty = _ } - -> - gon expr1; - got expr2 - | Cexpr_loop { body; args; _ } -> - Lst.iter args gon; - got body - | Cexpr_return _ | Cexpr_break _ | Cexpr_tuple _ | Cexpr_constr _ - | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ - | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ | Cexpr_const _ - | Cexpr_unit _ | Cexpr_var _ | Cexpr_function _ | Cexpr_prim _ - | Cexpr_apply _ | Cexpr_as _ | Cexpr_handle_error _ -> - gon expr + if (not !has_other_occurence) || not !tail_called then + match expr with + | Cexpr_apply { func; args; _ } when Ident.equal func ident -> + if is_tail then tail_called := true else has_other_occurence := true; + Lst.iter args ~f:gon + | Cexpr_let { name = _; rhs; body; _ } -> + gon rhs; + got body + | Cexpr_letrec { bindings; body; _ } -> + Lst.iter bindings ~f:(fun (_, fn) -> + analyze_usage ~in_nested_call:true ~is_tail:false fn.body); + got body + | Cexpr_letfn { name = _; fn; body; kind; _ } -> ( + match kind with + | Tail_join | Nontail_join -> + got fn.body; + got body + | Nonrec | Rec -> + analyze_usage ~in_nested_call:true ~is_tail:false fn.body; + got body) + | Cexpr_function { func; _ } -> + analyze_usage ~in_nested_call:true ~is_tail:false func.body + | Cexpr_if { cond; ifso; ifnot; _ } -> ( + gon cond; + got ifso; + match ifnot with None -> () | Some e -> got e) + | Cexpr_sequence { exprs; last_expr; _ } -> + Lst.iter exprs ~f:gon; + got last_expr + | Cexpr_switch_constr { obj; cases; default; _ } -> ( + gon obj; + Lst.iter cases ~f:(fun (_, _, expr) -> got expr); + match default with None -> () | Some default -> got default) + | Cexpr_switch_constant { obj; cases; default; _ } -> + gon obj; + Lst.iter cases ~f:(fun (_, expr) -> got expr); + got default + | Cexpr_and { lhs; rhs; _ } | Cexpr_or { lhs; rhs; _ } -> + gon lhs; + got rhs + | Cexpr_loop { body; args; _ } -> + Lst.iter args ~f:gon; + got body + | Cexpr_return { expr; _ } -> + if treat_return_as_tail && not in_nested_call then + analyze_usage expr ~is_tail:true ~in_nested_call:false + else gon expr + | Cexpr_break { arg; _ } -> ( + match arg with None -> () | Some arg -> gon arg) + | Cexpr_tuple { exprs = args; _ } + | Cexpr_constr { args; _ } + | Cexpr_array { exprs = args; _ } + | Cexpr_continue { args; _ } + | Cexpr_prim { args; _ } + | Cexpr_apply { args; _ } -> + Lst.iter args ~f:gon + | Cexpr_record { fields; _ } -> + Lst.iter fields ~f:(fun def -> gon def.expr) + | Cexpr_record_update { record; fields; _ } -> + gon record; + Lst.iter fields ~f:(fun def -> gon def.expr) + | Cexpr_field { record = expr; _ } + | Cexpr_assign { expr; _ } + | Cexpr_as { expr; _ } + | Cexpr_handle_error { obj = expr; _ } -> + gon expr + | Cexpr_mutate { record; field; _ } -> + gon record; + gon field + | Cexpr_const _ | Cexpr_unit _ -> () + | Cexpr_var { id; _ } -> + if Ident.equal id ident then has_other_occurence := true in - analyze_usage expr; + analyze_usage expr ~is_tail:true ~in_nested_call:false; if !has_other_occurence then Not_contifiable { tail_called = !tail_called } else if !tail_called then Contifiable else Never_called @@ -146,79 +117,120 @@ let apply2joinapply ident join body = match kind with | Normal _ when Ident.equal func ident -> Core.apply ~loc:loc_ ~ty_args_ ~kind:Join ~ty ~prim join - (List.map (self#visit_expr ()) args) + (Lst.map args (self#visit_expr ())) | _ -> super#visit_Cexpr_apply () func args kind ty ty_args_ prim loc_ end in map#visit_expr () body -let rec tail_apply2continue ident label (expr : Core.expr) = - let go expr = tail_apply2continue ident label expr [@@inline] in - match expr with - | Cexpr_apply { func; args; ty; loc_; kind = _; prim = _ } - when Ident.equal func ident -> - Core.continue ~loc:loc_ args label ty - | Cexpr_let { name; rhs; body; ty = _; loc_ } -> - Core.let_ ~loc:loc_ name rhs (go body) - | Cexpr_letrec { bindings; body; ty = _; loc_ } -> - Core.letrec ~loc:loc_ bindings body - | Cexpr_letfn { name; fn; body; kind; ty = _; loc_ } -> ( - match kind with - | Tail_join | Nontail_join -> - Core.letfn ~loc:loc_ ~kind name - { fn with body = go fn.body } - (go body) - | Nonrec | Rec -> Core.letfn ~loc:loc_ ~kind name fn (go body)) - | Cexpr_if { cond; ifso; ifnot; ty = _; loc_ } -> - Core.if_ ~loc:loc_ cond ~ifso:(go ifso) ?ifnot:(Option.map go ifnot) - | Cexpr_sequence { expr1; expr2; ty = _; loc_ } -> - Core.sequence ~loc:loc_ expr1 (go expr2) - | Cexpr_switch_constr { obj; cases; default; ty = _; loc_ } -> - Core.switch_constr ~loc:loc_ ~default:(Option.map go default) obj - (Lst.map cases (fun (tag, binder, action) -> (tag, binder, go action))) - | Cexpr_switch_constant { obj; cases; default; ty = _; loc_ } -> - Core.switch_constant ~loc:loc_ ~default:(go default) obj - (Lst.map cases (fun (c, action) -> (c, go action))) - | Cexpr_prim - { prim = (Psequand | Psequor) as prim; args = [ expr1; expr2 ]; ty; loc_ } - -> - Core.prim ~loc:loc_ ~ty prim [ expr1; go expr2 ] - | Cexpr_loop { params; body; args; label; ty = _; loc_ } -> - Core.loop ~loc:loc_ params (go body) args label - | Cexpr_return _ | Cexpr_break _ | Cexpr_tuple _ | Cexpr_constr _ - | Cexpr_record _ | Cexpr_record_update _ | Cexpr_field _ | Cexpr_mutate _ - | Cexpr_array _ | Cexpr_assign _ | Cexpr_continue _ | Cexpr_const _ - | Cexpr_unit _ | Cexpr_var _ | Cexpr_function _ | Cexpr_prim _ | Cexpr_apply _ - | Cexpr_as _ | Cexpr_handle_error _ -> - expr - -let loopify (ident : Ident.t) (params : Core.param list) (body : Core.expr) : - Core.fn = - let label = Label.fresh (Ident.base_name ident) in - let fresh_params = - Lst.map params (fun p -> { p with binder = Ident.rename p.binder }) - in - let args = - Lst.map fresh_params (fun { binder = id; ty; loc_ } -> - Core.var ~loc:loc_ ~ty id) +let tail_apply2continue ident label (expr : Core.expr) = + let rec go (expr : Core.expr) ~is_tail = + let got expr = go expr ~is_tail [@@inline] in + let gon expr = go expr ~is_tail:false [@@inline] in + match expr with + | Cexpr_apply { func; args; ty; loc_; kind; prim; ty_args_ } -> + if is_tail && Ident.equal func ident then + Core.continue ~loc:loc_ (Lst.map args gon) label ty + else + Core.apply ~loc:loc_ ~ty_args_ ~kind ~ty ~prim func (Lst.map args gon) + | Cexpr_let { name; rhs; body; ty = _; loc_ } -> + Core.let_ ~loc:loc_ name (gon rhs) (got body) + | Cexpr_letrec { bindings; body; ty = _; loc_ } -> + Core.letrec ~loc:loc_ bindings (got body) + | Cexpr_letfn { name; fn; body; kind; ty = _; loc_ } -> ( + match kind with + | Tail_join | Nontail_join -> + Core.letfn ~loc:loc_ ~kind name + { fn with body = got fn.body } + (got body) + | Nonrec | Rec -> Core.letfn ~loc:loc_ ~kind name fn (got body)) + | Cexpr_if { cond; ifso; ifnot; ty = _; loc_ } -> + Core.if_ ~loc:loc_ (gon cond) ~ifso:(got ifso) + ?ifnot:(Option.map got ifnot) + | Cexpr_sequence { exprs; last_expr; ty = _; loc_ } -> + Core.sequence ~loc:loc_ (Lst.map exprs gon) (got last_expr) + | Cexpr_switch_constr { obj; cases; default; ty = _; loc_ } -> + Core.switch_constr ~loc:loc_ ~default:(Option.map got default) (gon obj) + (Lst.map cases (fun (tag, binder, action) -> + (tag, binder, got action))) + | Cexpr_switch_constant { obj; cases; default; ty = _; loc_ } -> + Core.switch_constant ~loc:loc_ ~default:(got default) (gon obj) + (Lst.map cases (fun (c, action) -> (c, got action))) + | Cexpr_and { lhs; rhs; loc_ } -> Core.and_ ~loc:loc_ (gon lhs) (got rhs) + | Cexpr_or { lhs; rhs; loc_ } -> Core.or_ ~loc:loc_ (gon lhs) (got rhs) + | Cexpr_loop { params; body; args; label; ty = _; loc_ } -> + Core.loop ~loc:loc_ params (got body) (Lst.map args gon) label + | Cexpr_return { expr; return_kind; ty; loc_ } -> + Core.return ~loc:loc_ ~return_kind ~ty (go expr ~is_tail:true) + | Cexpr_break { arg; loc_; label; ty } -> + Core.break ~loc_ (Option.map got arg) label ty + | Cexpr_tuple { exprs; loc_; ty } -> + Core.tuple ~loc:loc_ ~ty (Lst.map exprs gon) + | Cexpr_constr { tag; args; loc_; ty } -> + Core.constr ~loc:loc_ ~ty tag (Lst.map args gon) + | Cexpr_record { fields; loc_; ty } -> + Core.record ~loc:loc_ ~ty + (Lst.map fields (fun def -> { def with expr = gon def.expr })) + | Cexpr_record_update { record; fields; fields_num; loc_; ty = _ } -> + Core.record_update ~loc:loc_ record + (Lst.map fields (fun def -> { def with expr = gon def.expr })) + fields_num + | Cexpr_field { record; accessor; pos; loc_; ty } -> + Core.field ~loc:loc_ ~ty ~pos (gon record) accessor + | Cexpr_mutate { record; label; field; pos; loc_; ty = _ } -> + Core.mutate ~loc:loc_ ~pos (gon record) label (gon field) + | Cexpr_array { exprs; loc_; ty } -> + Core.array ~loc:loc_ ~ty (Lst.map exprs gon) + | Cexpr_assign { var; expr; loc_; ty = _ } -> + Core.assign ~loc:loc_ var (gon expr) + | Cexpr_continue { args; loc_; label; ty } -> + Core.continue ~loc:loc_ args label ty + | Cexpr_const _ | Cexpr_unit _ | Cexpr_var _ | Cexpr_function _ -> expr + | Cexpr_prim { prim; args; ty; loc_ } -> + Core.prim ~loc:loc_ ~ty prim (Lst.map args gon) + | Cexpr_as { expr; trait; obj_type; loc_ } -> + Core.as_ ~loc:loc_ (gon expr) ~trait ~obj_type + | Cexpr_handle_error { obj; handle_kind; ty; loc_ } -> + Core.handle_error ~loc:loc_ (gon obj) handle_kind ~ty in - { - params = fresh_params; - body = - Core.loop ~loc:(Core.loc_of_expr body) params - (tail_apply2continue ident label body) - args label; - } + go expr ~is_tail:true + +let loopify (ident : Ident.t) (params : Core.param list) (body : Core.expr) + ~is_async = + (let label = Label.fresh (Ident.base_name ident) in + let fresh_params = + Lst.map params (fun p -> { p with binder = Ident.rename p.binder }) + in + let args = + Lst.map fresh_params (fun { binder = id; ty; loc_ } -> + Core.var ~loc:loc_ ~ty id) + in + { + params = fresh_params; + body = + Core.loop ~loc:(Core.loc_of_expr body) params + (tail_apply2continue ident label body) + args label; + is_async; + } + : Core.fn) + +let transform_return (fn : Core.fn) = + { fn with body = Core_util.transform_return_in_fn_body fn.body } let contifier = (object (self) inherit [_] Core.Map.map as super method! visit_Ctop_fn () ({ binder; func; _ } as decl) = - match is_contifiable binder func.body with + match is_contifiable binder func.body ~treat_return_as_tail:true with | Contifiable | Not_contifiable { tail_called = true } -> super#visit_Ctop_fn () - { decl with func = loopify binder func.params func.body } + { + decl with + func = + loopify binder func.params func.body ~is_async:func.is_async; + } | Never_called | Not_contifiable { tail_called = false } -> super#visit_Ctop_fn () decl @@ -227,7 +239,7 @@ let contifier = let body = self#visit_expr () body in match kind with | Nonrec -> ( - match is_contifiable name body with + match is_contifiable name body ~treat_return_as_tail:false with | Contifiable -> let body = apply2joinapply name name body in Core.joinlet_tail ~loc:loc_ name fn.params @@ -236,26 +248,24 @@ let contifier = | Never_called -> body | Not_contifiable _ -> Core.letfn ~loc:loc_ ~kind name fn body) | Rec -> ( - match is_contifiable name fn.body with + match is_contifiable name fn.body ~treat_return_as_tail:true with | Contifiable -> ( - match is_contifiable name body with + match is_contifiable name body ~treat_return_as_tail:false with | Contifiable -> let fn = - loopify name fn.params - (Core_util.transform_return_in_fn_body fn.body) + transform_return + (loopify name fn.params fn.body ~is_async:fn.is_async) in let body = apply2joinapply name name body in Core.letfn ~loc:loc_ ~kind:Tail_join name fn body | Never_called -> body - | Not_contifiable { tail_called = true } -> - Core.letfn ~loc:loc_ ~kind:Rec name - (loopify name fn.params fn.body) - body - | Not_contifiable { tail_called = false } -> - Core.letfn ~loc:loc_ ~kind:Rec name fn body) + | Not_contifiable _ -> + Core.letfn ~loc:loc_ ~kind:Nonrec name + (loopify name fn.params fn.body ~is_async:fn.is_async) + body) | Not_contifiable { tail_called = true } -> Core.letfn ~loc:loc_ ~kind:Rec name - (loopify name fn.params fn.body) + (loopify name fn.params fn.body ~is_async:fn.is_async) body | Never_called -> Core.letfn ~loc:loc_ ~kind:Nonrec name fn body | Not_contifiable { tail_called = false } -> diff --git a/src/pass_inline_single_use_join.ml b/src/pass_inline_single_use_join.ml index c491c5e..9619e1b 100644 --- a/src/pass_inline_single_use_join.ml +++ b/src/pass_inline_single_use_join.ml @@ -46,9 +46,11 @@ let inline_single_use_join = method! visit_Cexpr_apply ctx func args kind ty ty_args prim loc = match Ident.Hash.find_opt ctx.func_def_tbl func with | Some (def : Core.fn) -> - Lst.fold_left2 def.params args def.body (fun param arg body -> - let arg = self#visit_expr ctx arg in - Core.let_ param.binder arg body) + Lst.fold_left2 def.params args def.body (fun param -> + fun arg -> + fun body -> + let arg = self#visit_expr ctx arg in + Core.let_ param.binder arg body) | _ -> super#visit_Cexpr_apply ctx func args kind ty ty_args prim loc method! visit_Cexpr_letfn ctx name fn body ty kind loc = diff --git a/src/pass_layout.ml b/src/pass_layout.ml index 7ab9ff1..9f68e6c 100644 --- a/src/pass_layout.ml +++ b/src/pass_layout.ml @@ -101,44 +101,43 @@ let optimizer = method! visit_Cexpr_prim (ctx : kind Ident.Map.t) prim args ty loc_ = match (prim, args) with - | Penum_field _, (Cexpr_var { id; _ } as v) :: [] -> ( + | Penum_field _, (Cexpr_var { id; ty = enum_ty; _ } as v) :: [] -> ( match Ident.Map.find_opt ctx id with | Some Int -> v | Some Int64 -> i64_to_i32 v | Some Null -> as_non_null v ty - | None -> super#visit_Cexpr_prim ctx prim args ty loc_) + | None -> ( + match Mtype.get_optimized_option_kind enum_ty with + | Optimized_to_int -> v + | Optimized_to_int64 -> i64_to_i32 v + | Optimized_ref -> as_non_null v ty + | Not_optimized -> super#visit_Cexpr_prim ctx prim args ty loc_)) + | Pcast { kind = Enum_to_constr }, v :: [] -> ( + match Mtype.get_optimized_option_kind (Mcore.type_of_expr v) with + | Optimized_to_int | Optimized_ref | Optimized_to_int64 -> + self#visit_expr ctx v + | Not_optimized -> super#visit_Cexpr_prim ctx prim args ty loc_) | _ -> super#visit_Cexpr_prim ctx prim args ty loc_ - method! visit_Cexpr_constr ctx constr tag arg ty loc_ = + method! visit_Cexpr_constr ctx tag arg ty loc_ = let index = tag.index in - match ty with - | T_optimized_option { elem } -> ( - match elem with - | T_char | T_byte | T_bool | T_unit -> ( - match (index, arg) with - | 0, _ -> minus_one - | 1, a :: [] -> upcast (self#visit_expr ctx a) ty - | _ -> assert false) - | T_int | T_uint -> ( - match (index, arg) with - | 0, _ -> max_i32_plus_one - | 1, a :: [] -> i32_to_i64 (self#visit_expr ctx a) - | _ -> assert false) - | T_int64 | T_uint64 | T_func _ -> assert false - | T_float | T_double | T_any _ | T_optimized_option _ - | T_maybe_uninit _ | T_error_value_result _ -> - assert false - | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ - | T_constr _ -> ( - match (index, arg) with - | 0, _ -> null ty - | 1, a :: [] -> upcast (self#visit_expr ctx a) ty - | _ -> assert false)) - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_func _ | T_tuple _ - | T_fixedarray _ | T_constr _ | T_trait _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> - super#visit_Cexpr_constr ctx constr tag arg ty loc_ + match Mtype.get_optimized_option_kind ty with + | Optimized_to_int -> ( + match (index, arg) with + | 0, _ -> minus_one + | 1, a :: [] -> upcast (self#visit_expr ctx a) ty + | _ -> assert false) + | Optimized_to_int64 -> ( + match (index, arg) with + | 0, _ -> max_i32_plus_one + | 1, a :: [] -> i32_to_i64 (self#visit_expr ctx a) + | _ -> assert false) + | Optimized_ref -> ( + match (index, arg) with + | 0, _ -> null ty + | 1, a :: [] -> upcast (self#visit_expr ctx a) ty + | _ -> assert false) + | Not_optimized -> super#visit_Cexpr_constr ctx tag arg ty loc_ method! visit_Cexpr_switch_constr ctx obj cases default ty loc_ = let ty_obj = Mcore.type_of_expr obj in @@ -147,34 +146,25 @@ let optimizer = ~visit_expr:self#visit_expr [@@inline] in - match ty_obj with - | T_optimized_option { elem } -> ( - match elem with - | T_char | T_byte | T_bool | T_unit -> replace_switch_constr Int - | T_int | T_uint -> replace_switch_constr Int64 - | T_int64 | T_uint64 | T_func _ -> assert false - | T_float | T_double | T_any _ | T_optimized_option _ - | T_maybe_uninit _ | T_error_value_result _ -> - assert false - | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ - | T_constr _ -> - replace_switch_constr Null) - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_func _ | T_tuple _ - | T_fixedarray _ | T_constr _ | T_trait _ | T_any _ | T_maybe_uninit _ - | T_error_value_result _ -> + match Mtype.get_optimized_option_kind ty_obj with + | Optimized_to_int -> replace_switch_constr Int + | Optimized_to_int64 -> replace_switch_constr Int64 + | Optimized_ref -> replace_switch_constr Null + | Not_optimized -> super#visit_Cexpr_switch_constr ctx obj cases default ty loc_ end -let optimize_layout (prog : Mcore.t) : Mcore.t = - { - Mcore.body = - Lst.map prog.body (fun top_item -> - optimizer#visit_top_item Ident.Map.empty top_item); - main = - (match prog.main with - | Some (expr, loc) -> Some (optimizer#visit_expr Ident.Map.empty expr, loc) - | None -> None); - types = prog.types; - object_methods = prog.object_methods; - } +let optimize_layout (prog : Mcore.t) = + ({ + Mcore.body = + Lst.map prog.body (fun top_item -> + optimizer#visit_top_item Ident.Map.empty top_item); + main = + (match prog.main with + | Some (expr, loc) -> + Some (optimizer#visit_expr Ident.Map.empty expr, loc) + | None -> None); + types = prog.types; + object_methods = prog.object_methods; + } + : Mcore.t) diff --git a/src/pass_let_alias.ml b/src/pass_let_alias.ml index 6a48fbf..1bd2602 100644 --- a/src/pass_let_alias.ml +++ b/src/pass_let_alias.ml @@ -43,7 +43,7 @@ let alias_obj = match Ident.Hash.find_opt context.alias_tbl func with | Some (Constant _) -> assert false | Some (Variable (v, ty_args_, prim)) -> - let args = List.map (self#visit_expr context) args in + let args = Lst.map args (self#visit_expr context) in Core.apply v args ~loc:loc_ ~ty_args_ ~ty:typ ~kind ~prim | None -> super#visit_Cexpr_apply context func args kind typ ty_args_ prim loc_ @@ -104,31 +104,41 @@ let remove_let_alias (prog : Core.program) = let alias_tbl = Ident.Hash.create 17 in let top_items = Vec.empty () in let ctx = { alias_tbl; top_items; name_hint = "" } in - Lst.iter prog (fun top_item -> + Lst.iter prog ~f:(fun top_item -> match top_item with - | Ctop_let - { - binder = Pdot _ as binder; - expr = - Cexpr_const - { - c = - (C_bool _ | C_char _ | C_int _ | C_int64 _ | C_double _) as - c; - _; - }; - is_pub_; - } -> - Ident.Hash.add ctx.alias_tbl binder (Constant c); - if is_pub_ then Vec.push top_items top_item | Ctop_expr _ -> let item = alias_obj#visit_top_item { ctx with name_hint = "*init*" } top_item in Vec.push top_items item | Ctop_fn { binder; _ } | Ctop_stub { binder; _ } | Ctop_let { binder; _ } - -> + -> ( let ctx = { ctx with name_hint = Ident.base_name binder } in let item = alias_obj#visit_top_item ctx top_item in - Vec.push top_items item); + match item with + | Ctop_let + { + binder; + expr = Cexpr_var { id = Pdot _ as id; ty_args_; prim; _ }; + is_pub_; + } -> + Ident.Hash.add ctx.alias_tbl binder + (Variable (id, ty_args_, prim)); + if is_pub_ then Vec.push top_items item + | Ctop_let + { + binder; + expr = + Cexpr_const + { + c = + (C_bool _ | C_char _ | C_int _ | C_int64 _ | C_double _) + as c; + _; + }; + is_pub_; + } -> + Ident.Hash.add ctx.alias_tbl binder (Constant c); + if is_pub_ then Vec.push top_items item + | _ -> Vec.push top_items item)); Vec.to_list top_items diff --git a/src/pass_propagate_constr.ml b/src/pass_propagate_constr.ml new file mode 100644 index 0000000..aea7327 --- /dev/null +++ b/src/pass_propagate_constr.ml @@ -0,0 +1,151 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ident = Basic_core_ident +module Lst = Basic_lst + +let bind_exprs (exprs : Core.expr list) (cont : Core.expr list -> Core.expr) = + (let rec go exprs k = + match exprs with + | [] -> k [] + | e1 :: es -> + Core.bind e1 (fun e1_id -> + let new_e1 = Core.var ~ty:(Core.type_of_expr e1) e1_id in + go es (fun es -> k (new_e1 :: es))) + in + go exprs cont + : Core.expr) + +type ctor_info = { mutable has_benefit_to_inline : bool } +type used_count_tbl = { ctor : ctor_info Ident.Hash.t; genv : Global_env.t } + +let all_field_immutable (genv : Global_env.t) ty = + match Stype.type_repr ty with + | T_constr { type_constructor; _ } -> + Core_util.all_fields_immutable genv type_constructor ~allow_enum:true + | _ -> false + +let analyze = + object + inherit [_] Core.Iter.iter as super + + method! visit_Cexpr_let used_count_tbl name rhs body ty loc = + (match rhs with + | (Cexpr_tuple _ | Cexpr_record _ | Cexpr_constr _) + when all_field_immutable used_count_tbl.genv (Core.type_of_expr rhs) -> + Ident.Hash.add used_count_tbl.ctor name + { has_benefit_to_inline = false } + | _ -> ()); + super#visit_Cexpr_let used_count_tbl name rhs body ty loc + + method! visit_Cexpr_switch_constr used_count_tbl obj cases default_case ty + loc = + (match obj with + | Cexpr_var { id; _ } -> ( + match Ident.Hash.find_opt used_count_tbl.ctor id with + | Some ctor_info -> ctor_info.has_benefit_to_inline <- true + | None -> ()) + | _ -> ()); + super#visit_Cexpr_switch_constr used_count_tbl obj cases default_case ty + loc + + method! visit_Cexpr_field used_count_tbl record accessor pos ty loc_ = + (match record with + | Cexpr_var { id; _ } -> ( + match Ident.Hash.find_opt used_count_tbl.ctor id with + | Some ctor_info -> ctor_info.has_benefit_to_inline <- true + | _ -> ()) + | _ -> ()); + super#visit_Cexpr_field used_count_tbl record accessor pos ty loc_ + end + +type ctx = { used_count_tbl : used_count_tbl; def_tbl : Core.expr Ident.Hash.t } + +let transform = + object (self) + inherit [_] Core.Map.map as super + + method! visit_Cexpr_let ctx name rhs body ty loc = + match Ident.Hash.find_opt ctx.used_count_tbl.ctor name with + | Some ctor_info when ctor_info.has_benefit_to_inline -> ( + match rhs with + | Cexpr_tuple { exprs; ty = ty_tuple; loc_ } -> + bind_exprs + (Lst.map exprs (self#visit_expr ctx)) + (fun new_exprs -> + let new_tuple = Core.tuple new_exprs ~ty:ty_tuple ~loc:loc_ in + Ident.Hash.add ctx.def_tbl name new_tuple; + super#visit_Cexpr_let ctx name new_tuple body ty loc) + | Cexpr_record { fields; ty = ty_record; loc_ } -> + let exprs = + Lst.map fields (fun field -> self#visit_expr ctx field.expr) + in + bind_exprs exprs (fun new_exprs -> + let new_fields = + Lst.map2 fields new_exprs (fun field -> + fun expr -> { field with expr }) + in + let new_record = + Core.record new_fields ~ty:ty_record ~loc:loc_ + in + Ident.Hash.add ctx.def_tbl name new_record; + super#visit_Cexpr_let ctx name new_record body ty loc) + | Cexpr_constr { tag; args; ty = ty_constr; loc_ } -> + bind_exprs + (Lst.map args (self#visit_expr ctx)) + (fun new_args -> + let new_constr = + Core.constr tag new_args ~ty:ty_constr ~loc:loc_ + in + Ident.Hash.add ctx.def_tbl name new_constr; + super#visit_Cexpr_let ctx name new_constr body ty loc) + | _ -> assert false) + | _ -> super#visit_Cexpr_let ctx name rhs body ty loc + + method! visit_Cexpr_switch_constr ctx obj cases default_case ty loc = + let new_obj = + match obj with + | Cexpr_var { id; _ } -> ( + match Ident.Hash.find_opt ctx.def_tbl id with + | Some expr -> expr + | None -> obj) + | _ -> obj + in + super#visit_Cexpr_switch_constr ctx new_obj cases default_case ty loc + + method! visit_Cexpr_field ctx record accessor pos ty loc_ = + let new_record = + match record with + | Cexpr_var { id; _ } -> ( + match Ident.Hash.find_opt ctx.def_tbl id with + | Some expr -> expr + | None -> record) + | _ -> record + in + super#visit_Cexpr_field ctx new_record accessor pos ty loc_ + end + +let propagate_constr (genv : Global_env.t) prog = + let used_count_tbl = { ctor = Ident.Hash.create 17; genv } in + let def_tbl = Ident.Hash.create 17 in + Lst.map prog (fun top_item -> + Ident.Hash.clear used_count_tbl.ctor; + analyze#visit_top_item used_count_tbl top_item; + if Ident.Hash.length used_count_tbl.ctor = 0 then top_item + else + let ctx = { used_count_tbl; def_tbl } in + let o = transform#visit_top_item ctx top_item in + Ident.Hash.clear def_tbl; + o) diff --git a/src/pass_shrink_wasm.ml b/src/pass_shrink_wasm.ml deleted file mode 100644 index 85cabd1..0000000 --- a/src/pass_shrink_wasm.ml +++ /dev/null @@ -1,130 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module StringSet = Basic_set_string -module Lst = Basic_lst - -type program_item = - | Binding of (string * W.t) - | Rec_type of (string list * W.t) - | Raw of W.t - -let is_ident name = String.starts_with ~prefix:"$" name - -let extract_item keep_types sexp : program_item = - match sexp with - | (List (Atom "func" :: Atom name :: _) : W.t) - | (List (Atom "global" :: Atom name :: _) : W.t) - | (List (Atom "data" :: Atom name :: _) : W.t) - | (List [ Atom "import"; _; _; List (Atom "func" :: Atom name :: _) ] : W.t) - -> - Binding (name, sexp) - | (List (Atom "type" :: Atom name :: _) : W.t) -> - if keep_types then Raw sexp else Binding (name, sexp) - | (List (Atom "rec" :: types) : W.t) -> - let names = - Lst.fold_right types [] (fun t acc -> - match t with - | (List (Atom "type" :: Atom name :: _) : W.t) -> name :: acc - | _ -> acc) - in - Rec_type (names, sexp) - | _ -> Raw sexp - -let get_all_ident ~(except : StringSet.t) (sexp : W.t) : StringSet.t = - let rec go (sexp : W.t) = - match sexp with - | Atom name -> - if is_ident name && not (StringSet.mem except name) then - StringSet.singleton name - else StringSet.empty - | List sexps -> - List.fold_left - (fun acc sexp -> StringSet.union (go sexp) acc) - StringSet.empty sexps - in - go sexp - -let get_exported (sexp : W.t list) : StringSet.t = - let exports = ref StringSet.empty in - let go sexp = - match sexp with - | (List (Atom "func" :: Atom name :: List [ Atom "export"; _ ] :: _) : W.t) - | (List (Atom "func" :: Atom name :: _ :: List [ Atom "export"; _ ] :: _) : - W.t) - | (List [ Atom "start"; Atom name ] : W.t) - | (List [ Atom "export"; _; List [ _; Atom name ] ] : W.t) - | (List (Atom "memory" :: Atom name :: List (Atom "export" :: _) :: _) : - W.t) -> - exports := StringSet.add !exports name - | (List [ Atom "table"; _; Atom "funcref"; List (Atom "elem" :: elems) ] : - W.t) - | (List (Atom "elem" :: Atom "declare" :: Atom "func" :: elems) : W.t) -> - exports := - StringSet.union !exports - (List.fold_left StringSet.union StringSet.empty - (Lst.map elems (get_all_ident ~except:StringSet.empty))) - | _ -> () - in - Basic_lst.iter sexp go; - !exports - -let slice_sexp_prog keep_types (body : W.t list) : program_item list = - Lst.map body (extract_item keep_types) - -let dependency_of_exports (items : program_item list) (exported : StringSet.t) : - StringSet.t = - let tbl = Hashtbl.create 50 in - let collect_item (item : program_item) = - match item with - | Binding (x, sexp) -> Hashtbl.add tbl x sexp - | Rec_type (names, sexp) -> - Lst.iter names (fun name -> Hashtbl.add tbl name sexp) - | Raw _ -> () - in - Lst.iter items collect_item; - let deps_of_exported = ref exported in - let update_bit = ref true in - let visited = ref StringSet.empty in - while !update_bit do - update_bit := false; - StringSet.iter !deps_of_exported (fun name -> - if not (StringSet.mem !visited name) then ( - visited := StringSet.add !visited name; - match Hashtbl.find_opt tbl name with - | Some sexp -> - let new_deps = get_all_ident ~except:!deps_of_exported sexp in - update_bit := !update_bit || not (StringSet.is_empty new_deps); - deps_of_exported := StringSet.union !deps_of_exported new_deps - | None -> ())) - done; - !deps_of_exported - -let rebuild_program items usage = - Lst.fold_right items [] (fun item acc -> - match item with - | Binding (name, sexp) -> - if StringSet.mem usage name then sexp :: acc else acc - | Rec_type (names, sexp) -> - if Lst.exists names (fun name -> StringSet.mem usage name) then - sexp :: acc - else acc - | Raw sexp -> sexp :: acc) - -let shrink ?(keep_types = false) (code : W.t list) : W.t list = - let items = slice_sexp_prog keep_types code in - let exported = get_exported code in - let usage = dependency_of_exports items exported in - rebuild_program items usage diff --git a/src/pass_stackalloc.ml b/src/pass_stackalloc.ml index db1c6f7..99c7f0a 100644 --- a/src/pass_stackalloc.ml +++ b/src/pass_stackalloc.ml @@ -20,7 +20,6 @@ type scope = int type analyze_ctx = { depth_of_vars : scope Ident.Hash.t; - loop_info : Label.Hashset.t; need_transform : bool ref; depth : int; } @@ -28,7 +27,6 @@ type analyze_ctx = { type transform_ctx = { depth_of_vars : scope Ident.Hash.t; fields_of_vars : (Ident.t * Stype.t) array Ident.Hash.t; - loop_info : Label.Hashset.t; } let analyze_stack_vars = @@ -67,26 +65,6 @@ let analyze_stack_vars = | _ -> super#visit_Cexpr_mutate ctx record label field pos ty loc method! visit_var ctx var = Ident.Hash.remove ctx.depth_of_vars var - - method! visit_Cexpr_loop ctx params body args label ty loc_ = - match params with - | { ty = T_constr { type_constructor = Tuple _; _ }; binder } :: [] -> - Label.Hashset.add ctx.loop_info label; - Ident.Hash.add ctx.depth_of_vars binder Int.max_int; - super#visit_Cexpr_loop ctx params body args label ty loc_; - if - Label.Hashset.mem ctx.loop_info label - && Ident.Hash.mem ctx.depth_of_vars binder - then ctx.need_transform := true - else Label.Hashset.remove ctx.loop_info label - | _ -> super#visit_Cexpr_loop ctx params body args label ty loc_ - - method! visit_Cexpr_continue ctx args label ty loc_ = - (if Label.Hashset.mem ctx.loop_info label then - match args with - | Cexpr_tuple _ :: [] -> () - | _ -> Label.Hashset.remove ctx.loop_info label); - super#visit_Cexpr_continue ctx args label ty loc_ end let transform = @@ -102,7 +80,10 @@ let transform = Lst.map fields (fun { is_mut; pos; expr; label } -> let name = if Array.length field_vars = 1 then base_name - else (base_name ^ "_" ^ label.label_name : Stdlib.String.t) + else + (base_name ^ "_" ^ label.label_name + : Stdlib.String.t) + [@merlin.hide] in let id = if is_mut then Ident.fresh_mut name else Ident.fresh name @@ -112,9 +93,11 @@ let transform = in Ident.Hash.add ctx.fields_of_vars name field_vars; let new_body = self#visit_expr ctx body in - Lst.fold_right2 new_vars fields new_body (fun var { expr; _ } body -> - let expr = self#visit_expr ctx expr in - Core.let_ var expr body) + Lst.fold_right2 new_vars fields new_body (fun var -> + fun { expr; _ } -> + fun body -> + let expr = self#visit_expr ctx expr in + Core.let_ var expr body) | _ -> super#visit_Cexpr_let ctx name rhs body ty loc method! visit_Cexpr_field ctx record accessor pos ty loc = @@ -135,59 +118,6 @@ let transform = Core.assign ~loc (fst fields.(pos)) (self#visit_expr ctx field) | None -> super#visit_Cexpr_mutate ctx record label field pos ty loc) | _ -> super#visit_Cexpr_mutate ctx record label field pos ty loc - - method! visit_Cexpr_loop ctx params body args label ty loc_ = - match params with - | { - ty = T_constr { type_constructor = Tuple n; tys } as ty_tuple; - binder; - } - :: [] -> - if - Label.Hashset.mem ctx.loop_info label - && Ident.Hash.mem ctx.depth_of_vars binder - then ( - let base_name = Ident.base_name binder in - let field_vars = Array.make n (binder, Stype.unit) in - let new_params = - Lst.mapi tys (fun i ty : Core.param -> - let name = - (base_name ^ "_" ^ Int.to_string i : Stdlib.String.t) - in - let binder = Ident.fresh name in - field_vars.(i) <- (binder, ty); - { binder; ty; loc_ = Rloc.no_location }) - in - Ident.Hash.add ctx.fields_of_vars binder field_vars; - match args with - | Cexpr_tuple { exprs; _ } :: [] -> - let args = Lst.map exprs (self#visit_expr ctx) in - Core.loop new_params (self#visit_expr ctx body) args label - ~loc:loc_ - | arg :: [] -> - Core.bind (self#visit_expr ctx arg) (fun id -> - let args = - Lst.mapi tys (fun i ty -> - let var : Core.expr = Core.var id ~ty:ty_tuple in - let index : Parsing_syntax.accessor = - Index { tuple_index = i; loc_ = Rloc.no_location } - in - Core.field var ~ty ~pos:i index) - in - Core.loop new_params (self#visit_expr ctx body) args label - ~loc:loc_) - | _ -> assert false) - else super#visit_Cexpr_loop ctx params body args label ty loc_ - | _ -> super#visit_Cexpr_loop ctx params body args label ty loc_ - - method! visit_Cexpr_continue ctx args label ty loc_ = - if Label.Hashset.mem ctx.loop_info label then - match args with - | Cexpr_tuple { exprs; _ } :: [] -> - let new_args = Lst.map exprs (self#visit_expr ctx) in - Core.continue new_args label ty - | _ -> super#visit_Cexpr_continue ctx args label ty loc_ - else super#visit_Cexpr_continue ctx args label ty loc_ end let unbox_mut_records (prog : Core.program) = @@ -195,7 +125,6 @@ let unbox_mut_records (prog : Core.program) = let analyze_ctx = { depth_of_vars = Ident.Hash.create 16; - loop_info = Label.Hashset.create 16; need_transform = ref false; depth = 0; } @@ -206,7 +135,6 @@ let unbox_mut_records (prog : Core.program) = { depth_of_vars = analyze_ctx.depth_of_vars; fields_of_vars = Ident.Hash.create 16; - loop_info = analyze_ctx.loop_info; } in transform#visit_top_item transform_ctx top diff --git a/src/pass_unbox_loop_params.ml b/src/pass_unbox_loop_params.ml new file mode 100644 index 0000000..92f162c --- /dev/null +++ b/src/pass_unbox_loop_params.ml @@ -0,0 +1,235 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Ident = Basic_core_ident +module Lst = Basic_lst + +type analyze_ctx = { + loop_params : Ident.Hashset.t; + loop_info : Label.Hashset.t; + need_transform : bool ref; + global_env : Global_env.t; +} + +type transform_ctx = { + loop_params : Ident.Hashset.t; + fields_of_vars : (Ident.t * Stype.t) array Ident.Hash.t; + loop_info : Label.Hashset.t; + global_env : Global_env.t; +} + +let analyze_loop_params = + object + inherit [_] Core.Iter.iter as super + + method! visit_var (ctx : analyze_ctx) var = + Ident.Hashset.remove ctx.loop_params var + + method! visit_Cexpr_field ctx record accessor pos ty loc = + match record with + | Cexpr_var _ -> () + | _ -> super#visit_Cexpr_field ctx record accessor pos ty loc + + method! visit_Cexpr_loop ctx params body args label ty loc_ = + match params with + | { ty = T_constr { type_constructor; _ }; binder } :: [] + when Core_util.all_fields_immutable ctx.global_env type_constructor + ~allow_enum:false -> + Label.Hashset.add ctx.loop_info label; + Ident.Hashset.add ctx.loop_params binder; + super#visit_Cexpr_loop ctx params body args label ty loc_; + if Ident.Hashset.mem ctx.loop_params binder then + ctx.need_transform := true + else Label.Hashset.remove ctx.loop_info label + | _ -> super#visit_Cexpr_loop ctx params body args label ty loc_ + end + +let transform = + object (self) + inherit [_] Core.Map.map as super + + method! visit_Cexpr_field ctx record accessor pos ty loc = + match record with + | Cexpr_var { id; _ } -> ( + match Ident.Hash.find_opt ctx.fields_of_vars id with + | Some fields -> + let id, ty = fields.(pos) in + Core.var ~loc ~ty id + | None -> super#visit_Cexpr_field ctx record accessor pos ty loc) + | _ -> super#visit_Cexpr_field ctx record accessor pos ty loc + + method! visit_Cexpr_loop ctx params body args label ty loc_ = + match params with + | { + ty = T_constr { type_constructor = Tuple n; tys } as ty_tuple; + binder; + } + :: [] + when Label.Hashset.mem ctx.loop_info label + && Ident.Hashset.mem ctx.loop_params binder -> ( + let base_name = Ident.base_name binder in + let field_vars = Array.make n (binder, Stype.unit) in + let new_params = + Lst.mapi tys (fun i -> + fun ty -> + (let name = + ((base_name ^ "_" ^ Int.to_string i + : Stdlib.String.t) + [@merlin.hide]) + in + let binder = Ident.fresh name in + field_vars.(i) <- (binder, ty); + { binder; ty; loc_ = Rloc.no_location } + : Core.param)) + in + Ident.Hash.add ctx.fields_of_vars binder field_vars; + match args with + | Cexpr_tuple { exprs; _ } :: [] -> + let args = Lst.map exprs (self#visit_expr ctx) in + Core.loop new_params (self#visit_expr ctx body) args label + ~loc:loc_ + | arg :: [] -> + Core.bind (self#visit_expr ctx arg) (fun id -> + let args = + Lst.mapi tys (fun i -> + fun ty -> + let var : Core.expr = Core.var id ~ty:ty_tuple in + let index : Parsing_syntax.accessor = + Index { tuple_index = i; loc_ = Rloc.no_location } + in + Core.field var ~ty ~pos:i index) + in + Core.loop new_params (self#visit_expr ctx body) args label + ~loc:loc_) + | _ -> assert false) + | { ty = T_constr { type_constructor; _ } as ty_record; binder } :: [] + when Label.Hashset.mem ctx.loop_info label + && Ident.Hashset.mem ctx.loop_params binder -> ( + let base_name = Ident.base_name binder in + let fields = + Core_util.get_fields_exn ctx.global_env type_constructor + in + let _, fields = + Poly_type.instantiate_record ~ty_record:(`Known ty_record) fields + in + let field_vars = + Array.make (List.length fields) (binder, Stype.unit) + in + let new_params = + Lst.map fields (fun field -> + (let name = + ((base_name ^ "_" ^ field.field_name + : Stdlib.String.t) + [@merlin.hide]) + in + let binder = Ident.fresh name in + field_vars.(field.pos) <- (binder, field.ty_field); + { binder; ty = field.ty_field; loc_ = Rloc.no_location } + : Core.param)) + in + Ident.Hash.add ctx.fields_of_vars binder field_vars; + match args with + | arg :: [] -> + Core.bind (self#visit_expr ctx arg) (fun arg_id -> + let arg = Core.var arg_id ~ty:(Core.type_of_expr arg) in + let new_args = + Lst.map fields (fun field -> + let index : Parsing_syntax.accessor = + Label + { + label_name = field.field_name; + loc_ = Rloc.no_location; + } + in + Core.field arg ~ty:field.ty_field ~pos:field.pos index) + in + Core.loop new_params (self#visit_expr ctx body) new_args label + ~loc:loc_) + | _ -> assert false) + | _ -> super#visit_Cexpr_loop ctx params body args label ty loc_ + + method! visit_Cexpr_continue ctx args label ty loc_ = + if Label.Hashset.mem ctx.loop_info label then + match args with + | Cexpr_tuple { exprs; _ } :: [] -> + let new_args = Lst.map exprs (self#visit_expr ctx) in + Core.continue new_args label ty + | Cexpr_record { fields; _ } :: [] -> + let new_args = + Lst.map fields (fun { expr; _ } -> self#visit_expr ctx expr) + in + Core.continue new_args label ty + | arg :: [] -> + Core.bind (self#visit_expr ctx arg) (fun arg_id -> + let arg_ty = Core.type_of_expr arg in + let arg = Core.var arg_id ~ty:arg_ty in + match arg_ty with + | T_constr { type_constructor = Tuple _; tys } -> + let new_args = + Lst.mapi tys (fun i -> + fun ty -> + let index : Parsing_syntax.accessor = + Index { tuple_index = i; loc_ = Rloc.no_location } + in + Core.field arg ~pos:i ~ty index) + in + Core.continue new_args label ty + | T_constr { type_constructor; _ } -> + let fields = + Core_util.get_fields_exn ctx.global_env type_constructor + in + let _, fields = + Poly_type.instantiate_record ~ty_record:(`Known arg_ty) + fields + in + let new_args = + Lst.map fields (fun field -> + let index : Parsing_syntax.accessor = + Label + { + label_name = field.field_name; + loc_ = Rloc.no_location; + } + in + Core.field arg ~ty:field.ty_field ~pos:field.pos index) + in + Core.continue new_args label ty + | _ -> assert false) + | _ -> assert false + else super#visit_Cexpr_continue ctx args label ty loc_ + end + +let unbox_loop_params (global_env : Global_env.t) (prog : Core.program) = + Lst.map prog (fun top -> + let analyze_ctx = + { + loop_params = Ident.Hashset.create 16; + loop_info = Label.Hashset.create 16; + need_transform = ref false; + global_env; + } + in + analyze_loop_params#visit_top_item analyze_ctx top; + if !(analyze_ctx.need_transform) then + let transform_ctx = + { + loop_params = analyze_ctx.loop_params; + fields_of_vars = Ident.Hash.create 16; + loop_info = analyze_ctx.loop_info; + global_env; + } + in + transform#visit_top_item transform_ctx top + else top) diff --git a/src/pass_unused_let.ml b/src/pass_unused_let.ml index fe4bb0b..c96b01e 100644 --- a/src/pass_unused_let.ml +++ b/src/pass_unused_let.ml @@ -19,126 +19,131 @@ module Ident_map = Ident.Map type usage_map = int ref Ident_map.t -let clean_usage_count (usage : usage_map) : unit = - Ident_map.iter usage (fun _name count -> count := 0) - -let get_impure_bindings (prog : Clam.prog) : Ident_set.t = - let impure_names = ref Ident_set.empty in - let obj = - object - inherit [_] Clam.iter as super - - method! visit_Llet () name e body = - if not (Check_purity.check e) then - impure_names := Ident_set.add !impure_names name; - super#visit_Llet () name e body - end - in - obj#visit_prog () prog; - !impure_names +let clean_usage_count (usage : usage_map) = + (Ident_map.iter usage (fun _name -> fun count -> count := 0) : unit) + +let get_impure_bindings (prog : Clam.prog) = + (let impure_names = ref Ident_set.empty in + let obj = + object + inherit [_] Clam.iter as super + + method! visit_Llet () name e body = + if not (Check_purity.check e) then + impure_names := Ident_set.add !impure_names name; + super#visit_Llet () name e body + end + in + obj#visit_prog () prog; + !impure_names + : Ident_set.t) let clean_and_build_usage_count (prog : Clam.prog) (dead_names : Ident_set.t) - (usage_map : usage_map ref) : unit = - clean_usage_count !usage_map; - let incr_usage var = - match Ident_map.find_opt !usage_map var with - | Some count -> incr count - | None -> usage_map := Ident_map.add !usage_map var (ref 1) - in - let register_name var = - match Ident_map.find_opt !usage_map var with - | None -> usage_map := Ident_map.add !usage_map var (ref 0) - | _ -> () - in - let obj = - object (self) - inherit [_] Clam.iter - method! visit_var () var = incr_usage var - method! visit_binder () name = register_name name - - method! visit_Llet () name e body = - if Ident_set.mem dead_names name then () - else ( - self#visit_binder () name; - self#visit_lambda () e); - self#visit_lambda () body - - method! visit_Lletrec () names fns body = - List.iter2 - (fun name fn -> - if Ident_set.mem dead_names name then () - else ( - self#visit_binder () name; - self#visit_closure () fn)) - names fns; - self#visit_lambda () body - end - in - obj#visit_prog () prog + (usage_map : usage_map ref) = + (clean_usage_count !usage_map; + let incr_usage var = + match Ident_map.find_opt !usage_map var with + | Some count -> incr count + | None -> usage_map := Ident_map.add !usage_map var (ref 1) + in + let register_name var = + match Ident_map.find_opt !usage_map var with + | None -> usage_map := Ident_map.add !usage_map var (ref 0) + | _ -> () + in + let obj = + object (self) + inherit [_] Clam.iter + method! visit_var () var = incr_usage var + method! visit_binder () name = register_name name + + method! visit_Llet () name e body = + if Ident_set.mem dead_names name then () + else ( + self#visit_binder () name; + self#visit_lambda () e); + self#visit_lambda () body + + method! visit_Lletrec () names fns body = + List.iter2 + (fun name -> + fun fn -> + if Ident_set.mem dead_names name then () + else ( + self#visit_binder () name; + self#visit_closure () fn)) + names fns; + self#visit_lambda () body + end + in + obj#visit_prog () prog + : unit) let update_dead_names (dead_names : Ident_set.t ref) - (impure_names : Ident_set.t) (usage : usage_map) : bool = - let old_dead_names = !dead_names in - let update_bit = ref false in - Ident_map.iter usage (fun name count -> - if - !count = 0 - && (not (Ident_set.mem impure_names name)) - && not (Ident_set.mem old_dead_names name) - then ( - dead_names := Ident_set.add !dead_names name; - update_bit := true)); - !update_bit - -let get_unused_names (usage : usage_map) : Ident_set.t = - Ident_map.fold usage Ident_set.empty (fun name count acc -> - if !count = 0 then Ident_set.add acc name else acc) + (impure_names : Ident_set.t) (usage : usage_map) = + (let old_dead_names = !dead_names in + let update_bit = ref false in + Ident_map.iter usage (fun name -> + fun count -> + if + !count = 0 + && (not (Ident_set.mem impure_names name)) + && not (Ident_set.mem old_dead_names name) + then ( + dead_names := Ident_set.add !dead_names name; + update_bit := true)); + !update_bit + : bool) + +let get_unused_names (usage : usage_map) = + (Ident_map.fold usage Ident_set.empty (fun name -> + fun count -> + fun acc -> if !count = 0 then Ident_set.add acc name else acc) + : Ident_set.t) let clean_up (prog : Clam.prog) ~(dead_names : Ident_set.t) - ~(unused_names : Ident_set.t) : Clam.prog = - let obj = - object (self) - inherit [_] Clam.map - - method! visit_Llet () name e body = - let body = self#visit_lambda () body in - if Ident_set.mem dead_names name then body - else if Ident_set.mem unused_names name then - Lsequence - { - expr1 = self#visit_lambda () e; - expr2 = body; - expr1_type_ = Ident.get_type name; - } - else Llet { name; e = self#visit_lambda () e; body } - - method! visit_Lletrec () names fns body = - let body = self#visit_lambda () body in - let names, fns = - Basic_lst.fold_right2 names fns ([], []) - (fun name fn (acc_names, acc_fns) -> - if Ident_set.mem dead_names name then (acc_names, acc_fns) - else (name :: acc_names, fn :: acc_fns)) - in - match (names, fns) with - | [], [] -> body - | _ -> Lletrec { names; fns; body } - end - in - obj#visit_prog () prog + ~(unused_names : Ident_set.t) = + (let obj = + object (self) + inherit [_] Clam.map + + method! visit_Llet () name e body = + let body = self#visit_lambda () body in + if Ident_set.mem dead_names name then body + else if Ident_set.mem unused_names name then + Lsequence { exprs = [ self#visit_lambda () e ]; last_expr = body } + else Llet { name; e = self#visit_lambda () e; body } + + method! visit_Lletrec () names fns body = + let body = self#visit_lambda () body in + let names, fns = + Basic_lst.fold_right2 names fns ([], []) (fun name -> + fun fn -> + fun (acc_names, acc_fns) -> + if Ident_set.mem dead_names name then (acc_names, acc_fns) + else (name :: acc_names, fn :: acc_fns)) + in + match (names, fns) with + | [], [] -> body + | _ -> Lletrec { names; fns; body } + end + in + obj#visit_prog () prog + : Clam.prog) let print_map map = - Ident_map.iter map (fun name count -> - Printf.printf "%s -> %d\n" (Ident.to_string name) !count) + Ident_map.iter map (fun name -> + fun count -> Printf.printf "%s -> %d\n" (Ident.to_string name) !count) [@@warning "-unused-value-declaration"] -let unused_let_opt (prog : Clam.prog) : Clam.prog = - let impure_names = get_impure_bindings prog in - let usage = ref Ident_map.empty in - let dead_names = ref Ident_set.empty in - let update_bit = ref true in - while !update_bit do - clean_and_build_usage_count prog !dead_names usage; - update_bit := update_dead_names dead_names impure_names !usage - done; - clean_up prog ~dead_names:!dead_names ~unused_names:(get_unused_names !usage) +let unused_let_opt (prog : Clam.prog) = + (let impure_names = get_impure_bindings prog in + let usage = ref Ident_map.empty in + let dead_names = ref Ident_set.empty in + let update_bit = ref true in + while !update_bit do + clean_and_build_usage_count prog !dead_names usage; + update_bit := update_dead_names dead_names impure_names !usage + done; + clean_up prog ~dead_names:!dead_names ~unused_names:(get_unused_names !usage) + : Clam.prog) diff --git a/src/pass_unused_let1.ml b/src/pass_unused_let1.ml deleted file mode 100644 index 6ba0516..0000000 --- a/src/pass_unused_let1.ml +++ /dev/null @@ -1,144 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Ident = Clam1_ident -module Ident_set = Ident.Set -module Ident_map = Ident.Map - -type usage_map = int ref Ident_map.t - -let clean_usage_count (usage : usage_map) : unit = - Ident_map.iter usage (fun _name count -> count := 0) - -let get_impure_bindings (prog : Clam1.prog) : Ident_set.t = - let impure_names = ref Ident_set.empty in - let obj = - object - inherit [_] Clam1.iter as super - - method! visit_Llet () name e body = - if not (Check_purity1.check e) then - impure_names := Ident_set.add !impure_names name; - super#visit_Llet () name e body - end - in - obj#visit_prog () prog; - !impure_names - -let clean_and_build_usage_count (prog : Clam1.prog) (dead_names : Ident_set.t) - (usage_map : usage_map ref) : unit = - clean_usage_count !usage_map; - let incr_usage var = - match Ident_map.find_opt !usage_map var with - | Some count -> incr count - | None -> usage_map := Ident_map.add !usage_map var (ref 1) - in - let register_name var = - match Ident_map.find_opt !usage_map var with - | None -> usage_map := Ident_map.add !usage_map var (ref 0) - | _ -> () - in - let obj = - object (self) - inherit [_] Clam1.iter - method! visit_var () var = incr_usage var - method! visit_binder () name = register_name name - - method! visit_Llet () name e body = - if Ident_set.mem dead_names name then () - else ( - self#visit_binder () name; - self#visit_lambda () e); - self#visit_lambda () body - - method! visit_Lletrec () names fns body = - List.iter2 - (fun name fn -> - if Ident_set.mem dead_names name then () - else ( - self#visit_binder () name; - self#visit_closure () fn)) - names fns; - self#visit_lambda () body - end - in - obj#visit_prog () prog - -let update_dead_names (dead_names : Ident_set.t ref) - (impure_names : Ident_set.t) (usage : usage_map) : bool = - let old_dead_names = !dead_names in - let update_bit = ref false in - Ident_map.iter usage (fun name count -> - if - !count = 0 - && (not (Ident_set.mem impure_names name)) - && not (Ident_set.mem old_dead_names name) - then ( - dead_names := Ident_set.add !dead_names name; - update_bit := true)); - !update_bit - -let get_unused_names (usage : usage_map) : Ident_set.t = - Ident_map.fold usage Ident_set.empty (fun name count acc -> - if !count = 0 then Ident_set.add acc name else acc) - -let clean_up (prog : Clam1.prog) ~(dead_names : Ident_set.t) - ~(unused_names : Ident_set.t) : Clam1.prog = - let obj = - object (self) - inherit [_] Clam1.map - - method! visit_Llet () name e body = - let body = self#visit_lambda () body in - if Ident_set.mem dead_names name then body - else if Ident_set.mem unused_names name then - Lsequence - { - expr1 = self#visit_lambda () e; - expr2 = body; - expr1_type_ = Ident.get_type name; - } - else Llet { name; e = self#visit_lambda () e; body } - - method! visit_Lletrec () names fns body = - let body = self#visit_lambda () body in - let names, fns = - Basic_lst.fold_right2 names fns ([], []) - (fun name fn (acc_names, acc_fns) -> - if Ident_set.mem dead_names name then (acc_names, acc_fns) - else (name :: acc_names, fn :: acc_fns)) - in - match (names, fns) with - | [], [] -> body - | _ -> Lletrec { names; fns; body } - end - in - obj#visit_prog () prog - -let print_map map = - Ident_map.iter map (fun name count -> - Printf.printf "%s -> %d\n" (Ident.to_string name) !count) -[@@warning "-unused-value-declaration"] - -let unused_let_opt (prog : Clam1.prog) : Clam1.prog = - let impure_names = get_impure_bindings prog in - let usage = ref Ident_map.empty in - let dead_names = ref Ident_set.empty in - let update_bit = ref true in - while !update_bit do - clean_and_build_usage_count prog !dead_names usage; - update_bit := update_dead_names dead_names impure_names !usage - done; - clean_up prog ~dead_names:!dead_names ~unused_names:(get_unused_names !usage) diff --git a/src/pat_path.ml b/src/pat_path.ml index 8cf0ee8..b557180 100644 --- a/src/pat_path.ml +++ b/src/pat_path.ml @@ -27,165 +27,195 @@ module Path_def = struct tag : Basic_constr_info.constr_tag; arg_index : int; } + | Codeunit_field of { index : int; rev : bool } include struct let _ = fun (_ : t) -> () let _ = fun (_ : access) -> () let rec equal = - (fun a__001_ b__002_ -> - Ppx_base.equal_list - (fun a__003_ b__004_ -> equal_access a__003_ b__004_) - a__001_ b__002_ + (fun a__001_ -> + fun b__002_ -> + Ppx_base.equal_list + (fun a__003_ -> fun b__004_ -> equal_access a__003_ b__004_) + a__001_ b__002_ : t -> t -> bool) and equal_access = - (fun a__005_ b__006_ -> - if Stdlib.( == ) a__005_ b__006_ then true - else - match (a__005_, b__006_) with - | Field _a__007_, Field _b__008_ -> - Stdlib.( = ) (_a__007_ : int) _b__008_ - | Field _, _ -> false - | _, Field _ -> false - | Constr_field _a__009_, Constr_field _b__010_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__009_.tag_index : int) _b__010_.tag_index) - (Stdlib.( = ) (_a__009_.arg_index : int) _b__010_.arg_index) - | Constr_field _, _ -> false - | _, Constr_field _ -> false - | Last_field _a__011_, Last_field _b__012_ -> - Stdlib.( = ) (_a__011_ : int) _b__012_ - | Last_field _, _ -> false - | _, Last_field _ -> false - | Field_slice, Field_slice -> true - | Field_slice, _ -> false - | _, Field_slice -> false - | Casted_constr _a__013_, Casted_constr _b__014_ -> - Stdlib.( = ) (_a__013_.tag_index : int) _b__014_.tag_index - | Casted_constr _, _ -> false - | _, Casted_constr _ -> false - | Map_elem _a__015_, Map_elem _b__016_ -> - Constant.equal _a__015_.key _b__016_.key - | Map_elem _, _ -> false - | _, Map_elem _ -> false - | Error_constr_field _a__017_, Error_constr_field _b__018_ -> - Stdlib.( && ) - (Basic_constr_info.equal_constr_tag _a__017_.tag _b__018_.tag) - (Stdlib.( = ) (_a__017_.arg_index : int) _b__018_.arg_index) + (fun a__005_ -> + fun b__006_ -> + if Stdlib.( == ) a__005_ b__006_ then true + else + match (a__005_, b__006_) with + | Field _a__007_, Field _b__008_ -> + Stdlib.( = ) (_a__007_ : int) _b__008_ + | Field _, _ -> false + | _, Field _ -> false + | Constr_field _a__009_, Constr_field _b__010_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__009_.tag_index : int) _b__010_.tag_index) + (Stdlib.( = ) (_a__009_.arg_index : int) _b__010_.arg_index) + | Constr_field _, _ -> false + | _, Constr_field _ -> false + | Last_field _a__011_, Last_field _b__012_ -> + Stdlib.( = ) (_a__011_ : int) _b__012_ + | Last_field _, _ -> false + | _, Last_field _ -> false + | Field_slice, Field_slice -> true + | Field_slice, _ -> false + | _, Field_slice -> false + | Casted_constr _a__013_, Casted_constr _b__014_ -> + Stdlib.( = ) (_a__013_.tag_index : int) _b__014_.tag_index + | Casted_constr _, _ -> false + | _, Casted_constr _ -> false + | Map_elem _a__015_, Map_elem _b__016_ -> + Constant.equal _a__015_.key _b__016_.key + | Map_elem _, _ -> false + | _, Map_elem _ -> false + | Error_constr_field _a__017_, Error_constr_field _b__018_ -> + Stdlib.( && ) + (Basic_constr_info.equal_constr_tag _a__017_.tag _b__018_.tag) + (Stdlib.( = ) (_a__017_.arg_index : int) _b__018_.arg_index) + | Error_constr_field _, _ -> false + | _, Error_constr_field _ -> false + | Codeunit_field _a__019_, Codeunit_field _b__020_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__019_.index : int) _b__020_.index) + (Stdlib.( = ) (_a__019_.rev : bool) _b__020_.rev) : access -> access -> bool) let _ = equal and _ = equal_access let rec compare = - (fun a__019_ b__020_ -> - Ppx_base.compare_list - (fun a__021_ b__022_ -> compare_access a__021_ b__022_) - a__019_ b__020_ + (fun a__021_ -> + fun b__022_ -> + Ppx_base.compare_list + (fun a__023_ -> fun b__024_ -> compare_access a__023_ b__024_) + a__021_ b__022_ : t -> t -> int) and compare_access = - (fun a__023_ b__024_ -> - if Stdlib.( == ) a__023_ b__024_ then 0 - else - match (a__023_, b__024_) with - | Field _a__025_, Field _b__026_ -> - Stdlib.compare (_a__025_ : int) _b__026_ - | Field _, _ -> -1 - | _, Field _ -> 1 - | Constr_field _a__027_, Constr_field _b__028_ -> ( - match - Stdlib.compare (_a__027_.tag_index : int) _b__028_.tag_index - with - | 0 -> - Stdlib.compare (_a__027_.arg_index : int) _b__028_.arg_index - | n -> n) - | Constr_field _, _ -> -1 - | _, Constr_field _ -> 1 - | Last_field _a__029_, Last_field _b__030_ -> - Stdlib.compare (_a__029_ : int) _b__030_ - | Last_field _, _ -> -1 - | _, Last_field _ -> 1 - | Field_slice, Field_slice -> 0 - | Field_slice, _ -> -1 - | _, Field_slice -> 1 - | Casted_constr _a__031_, Casted_constr _b__032_ -> - Stdlib.compare (_a__031_.tag_index : int) _b__032_.tag_index - | Casted_constr _, _ -> -1 - | _, Casted_constr _ -> 1 - | Map_elem _a__033_, Map_elem _b__034_ -> - Constant.compare _a__033_.key _b__034_.key - | Map_elem _, _ -> -1 - | _, Map_elem _ -> 1 - | Error_constr_field _a__035_, Error_constr_field _b__036_ -> ( - match - Basic_constr_info.compare_constr_tag _a__035_.tag _b__036_.tag - with - | 0 -> - Stdlib.compare (_a__035_.arg_index : int) _b__036_.arg_index - | n -> n) + (fun a__025_ -> + fun b__026_ -> + if Stdlib.( == ) a__025_ b__026_ then 0 + else + match (a__025_, b__026_) with + | Field _a__027_, Field _b__028_ -> + Stdlib.compare (_a__027_ : int) _b__028_ + | Field _, _ -> -1 + | _, Field _ -> 1 + | Constr_field _a__029_, Constr_field _b__030_ -> ( + match + Stdlib.compare (_a__029_.tag_index : int) _b__030_.tag_index + with + | 0 -> + Stdlib.compare (_a__029_.arg_index : int) _b__030_.arg_index + | n -> n) + | Constr_field _, _ -> -1 + | _, Constr_field _ -> 1 + | Last_field _a__031_, Last_field _b__032_ -> + Stdlib.compare (_a__031_ : int) _b__032_ + | Last_field _, _ -> -1 + | _, Last_field _ -> 1 + | Field_slice, Field_slice -> 0 + | Field_slice, _ -> -1 + | _, Field_slice -> 1 + | Casted_constr _a__033_, Casted_constr _b__034_ -> + Stdlib.compare (_a__033_.tag_index : int) _b__034_.tag_index + | Casted_constr _, _ -> -1 + | _, Casted_constr _ -> 1 + | Map_elem _a__035_, Map_elem _b__036_ -> + Constant.compare _a__035_.key _b__036_.key + | Map_elem _, _ -> -1 + | _, Map_elem _ -> 1 + | Error_constr_field _a__037_, Error_constr_field _b__038_ -> ( + match + Basic_constr_info.compare_constr_tag _a__037_.tag _b__038_.tag + with + | 0 -> + Stdlib.compare (_a__037_.arg_index : int) _b__038_.arg_index + | n -> n) + | Error_constr_field _, _ -> -1 + | _, Error_constr_field _ -> 1 + | Codeunit_field _a__039_, Codeunit_field _b__040_ -> ( + match Stdlib.compare (_a__039_.index : int) _b__040_.index with + | 0 -> Stdlib.compare (_a__039_.rev : bool) _b__040_.rev + | n -> n) : access -> access -> int) let _ = compare and _ = compare_access let rec sexp_of_t = - (fun x__037_ -> Moon_sexp_conv.sexp_of_list sexp_of_access x__037_ + (fun x__041_ -> Moon_sexp_conv.sexp_of_list sexp_of_access x__041_ : t -> S.t) and sexp_of_access = (function - | Field arg0__038_ -> - let res0__039_ = Moon_sexp_conv.sexp_of_int arg0__038_ in - S.List [ S.Atom "Field"; res0__039_ ] + | Field arg0__042_ -> + let res0__043_ = Moon_sexp_conv.sexp_of_int arg0__042_ in + S.List [ S.Atom "Field"; res0__043_ ] | Constr_field - { tag_index = tag_index__041_; arg_index = arg_index__043_ } -> - let bnds__040_ = ([] : _ Stdlib.List.t) in - let bnds__040_ = - let arg__044_ = Moon_sexp_conv.sexp_of_int arg_index__043_ in - (S.List [ S.Atom "arg_index"; arg__044_ ] :: bnds__040_ + { tag_index = tag_index__045_; arg_index = arg_index__047_ } -> + let bnds__044_ = ([] : _ Stdlib.List.t) in + let bnds__044_ = + let arg__048_ = Moon_sexp_conv.sexp_of_int arg_index__047_ in + (S.List [ S.Atom "arg_index"; arg__048_ ] :: bnds__044_ : _ Stdlib.List.t) in - let bnds__040_ = - let arg__042_ = Moon_sexp_conv.sexp_of_int tag_index__041_ in - (S.List [ S.Atom "tag_index"; arg__042_ ] :: bnds__040_ + let bnds__044_ = + let arg__046_ = Moon_sexp_conv.sexp_of_int tag_index__045_ in + (S.List [ S.Atom "tag_index"; arg__046_ ] :: bnds__044_ : _ Stdlib.List.t) in - S.List (S.Atom "Constr_field" :: bnds__040_) - | Last_field arg0__045_ -> - let res0__046_ = Moon_sexp_conv.sexp_of_int arg0__045_ in - S.List [ S.Atom "Last_field"; res0__046_ ] + S.List (S.Atom "Constr_field" :: bnds__044_) + | Last_field arg0__049_ -> + let res0__050_ = Moon_sexp_conv.sexp_of_int arg0__049_ in + S.List [ S.Atom "Last_field"; res0__050_ ] | Field_slice -> S.Atom "Field_slice" - | Casted_constr { tag_index = tag_index__048_ } -> - let bnds__047_ = ([] : _ Stdlib.List.t) in - let bnds__047_ = - let arg__049_ = Moon_sexp_conv.sexp_of_int tag_index__048_ in - (S.List [ S.Atom "tag_index"; arg__049_ ] :: bnds__047_ + | Casted_constr { tag_index = tag_index__052_ } -> + let bnds__051_ = ([] : _ Stdlib.List.t) in + let bnds__051_ = + let arg__053_ = Moon_sexp_conv.sexp_of_int tag_index__052_ in + (S.List [ S.Atom "tag_index"; arg__053_ ] :: bnds__051_ : _ Stdlib.List.t) in - S.List (S.Atom "Casted_constr" :: bnds__047_) - | Map_elem { key = key__051_ } -> - let bnds__050_ = ([] : _ Stdlib.List.t) in - let bnds__050_ = - let arg__052_ = Constant.sexp_of_t key__051_ in - (S.List [ S.Atom "key"; arg__052_ ] :: bnds__050_ + S.List (S.Atom "Casted_constr" :: bnds__051_) + | Map_elem { key = key__055_ } -> + let bnds__054_ = ([] : _ Stdlib.List.t) in + let bnds__054_ = + let arg__056_ = Constant.sexp_of_t key__055_ in + (S.List [ S.Atom "key"; arg__056_ ] :: bnds__054_ : _ Stdlib.List.t) in - S.List (S.Atom "Map_elem" :: bnds__050_) - | Error_constr_field { tag = tag__054_; arg_index = arg_index__056_ } -> - let bnds__053_ = ([] : _ Stdlib.List.t) in - let bnds__053_ = - let arg__057_ = Moon_sexp_conv.sexp_of_int arg_index__056_ in - (S.List [ S.Atom "arg_index"; arg__057_ ] :: bnds__053_ + S.List (S.Atom "Map_elem" :: bnds__054_) + | Error_constr_field { tag = tag__058_; arg_index = arg_index__060_ } -> + let bnds__057_ = ([] : _ Stdlib.List.t) in + let bnds__057_ = + let arg__061_ = Moon_sexp_conv.sexp_of_int arg_index__060_ in + (S.List [ S.Atom "arg_index"; arg__061_ ] :: bnds__057_ : _ Stdlib.List.t) in - let bnds__053_ = - let arg__055_ = Basic_constr_info.sexp_of_constr_tag tag__054_ in - (S.List [ S.Atom "tag"; arg__055_ ] :: bnds__053_ + let bnds__057_ = + let arg__059_ = Basic_constr_info.sexp_of_constr_tag tag__058_ in + (S.List [ S.Atom "tag"; arg__059_ ] :: bnds__057_ : _ Stdlib.List.t) in - S.List (S.Atom "Error_constr_field" :: bnds__053_) + S.List (S.Atom "Error_constr_field" :: bnds__057_) + | Codeunit_field { index = index__063_; rev = rev__065_ } -> + let bnds__062_ = ([] : _ Stdlib.List.t) in + let bnds__062_ = + let arg__066_ = Moon_sexp_conv.sexp_of_bool rev__065_ in + (S.List [ S.Atom "rev"; arg__066_ ] :: bnds__062_ + : _ Stdlib.List.t) + in + let bnds__062_ = + let arg__064_ = Moon_sexp_conv.sexp_of_int index__063_ in + (S.List [ S.Atom "index"; arg__064_ ] :: bnds__062_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Codeunit_field" :: bnds__062_) : access -> S.t) let _ = sexp_of_t diff --git a/src/patch.ml b/src/patch.ml new file mode 100644 index 0000000..cf27ce6 --- /dev/null +++ b/src/patch.ml @@ -0,0 +1,124 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +type t = + | PDrop of { file : string; index : int } + | PAdd of { name : string; content : string } + +include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (function + | PDrop { file = file__002_; index = index__004_ } -> + let bnds__001_ = ([] : _ Stdlib.List.t) in + let bnds__001_ = + let arg__005_ = Moon_sexp_conv.sexp_of_int index__004_ in + (S.List [ S.Atom "index"; arg__005_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__003_ = Moon_sexp_conv.sexp_of_string file__002_ in + (S.List [ S.Atom "file"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) + in + S.List (S.Atom "PDrop" :: bnds__001_) + | PAdd { name = name__007_; content = content__009_ } -> + let bnds__006_ = ([] : _ Stdlib.List.t) in + let bnds__006_ = + let arg__010_ = Moon_sexp_conv.sexp_of_string content__009_ in + (S.List [ S.Atom "content"; arg__010_ ] :: bnds__006_ + : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__008_ = Moon_sexp_conv.sexp_of_string name__007_ in + (S.List [ S.Atom "name"; arg__008_ ] :: bnds__006_ : _ Stdlib.List.t) + in + S.List (S.Atom "PAdd" :: bnds__006_) + : t -> S.t) + + let _ = sexp_of_t +end + +let push_pdrop ~(patches : t Basic_vec.t) (json : Json_types.t) = + (let exception Ret in + try + match json with + | Json_types.Obj { map; loc = _ } -> + let file = + match Basic_map_string.find_exn map "file" with + | Json_types.Str { str; loc = _ } -> str + | _ -> raise Ret + in + let index = + match Basic_map_string.find_exn map "index" with + | Json_types.Float { float; loc = _ } -> int_of_string float + | _ -> raise Ret + in + Basic_vec.push patches (PDrop { file; index }) + | _ -> raise Ret + with Ret -> () + : unit) + +let push_padd ~(patches : t Basic_vec.t) (json : Json_types.t) = + (let exception Ret in + try + match json with + | Json_types.Obj { map; loc = _ } -> + let name = + match Basic_map_string.find_exn map "name" with + | Json_types.Str { str; loc = _ } -> str + | _ -> raise Ret + in + let content = + match Basic_map_string.find_exn map "content" with + | Json_types.Str { str; loc = _ } -> str + | _ -> raise Ret + in + Basic_vec.push patches (PAdd { name; content }) + | _ -> raise Ret + with Ret -> () + : unit) + +let parse_patch_from_json (json : Json_types.t) = + (let patches = Basic_vec.empty () in + (match json with + | Json_types.Obj { map; loc = _ } -> + let drops = + match Basic_map_string.find_exn map "drops" with + | Json_types.Arr { content; loc = _ } -> content + | _ -> failwith "parse_patch: drops is not an array" + in + Array.iter (push_pdrop ~patches) drops; + let adds = + match Basic_map_string.find_exn map "patches" with + | Json_types.Arr { content; loc = _ } -> content + | _ -> failwith "parse_patch: patches is not an array" + in + Array.iter (push_padd ~patches) adds + | _ -> failwith "parse_patch: json is not a map"); + Basic_vec.to_list patches + : t list) + +let parse_patch_from_string ~(content : string) = + (let d = Diagnostics.make () in + let json = Json_parse.parse_json_from_string ~diagnostics:d content in + parse_patch_from_json json + : t list) + +let parse_patch_from_file ~(file_path : string) = + (let d = Diagnostics.make () in + let json = Json_parse.parse_json_from_file ~diagnostics:d file_path in + parse_patch_from_json json + : t list) diff --git a/src/patmatch_db.ml b/src/patmatch_db.ml index 972eb64..0a02667 100644 --- a/src/patmatch_db.ml +++ b/src/patmatch_db.ml @@ -15,12 +15,13 @@ module Path = Pat_path module StaticInfo = Patmatch_static_info +module Lst = Basic_lst type t = StaticInfo.t Path.Map.t type 'a eval_result = 'a Basic_case_set_intf.static_matching_result = - | For_sure_yes of { ok_db : 'a } - | For_sure_no of { fail_db : 'a } + | For_sure_yes + | For_sure_no | Uncertain of { ok_db : 'a; fail_db : 'a } type static_eval_result = t eval_result @@ -28,43 +29,190 @@ type static_eval_result = t eval_result let empty : t = Path.Map.empty let make_result (self : t) (path : Path.t) - ~info:(matched : StaticInfo.t eval_result) : static_eval_result = - match matched with - | For_sure_yes { ok_db } -> - For_sure_yes { ok_db = Path.Map.add self path ok_db } - | For_sure_no { fail_db } -> - For_sure_no { fail_db = Path.Map.add self path fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain - { - ok_db = Path.Map.add self path ok_db; - fail_db = Path.Map.add self path fail_db; - } - -let eval_constant self path constant : static_eval_result = - make_result self path - ~info:(StaticInfo.eval_constant (Path.Map.find_opt self path) constant) - -let eval_range self path lo hi ~inclusive : static_eval_result = - make_result self path - ~info:(StaticInfo.eval_range (Path.Map.find_opt self path) lo hi ~inclusive) - -let eval_constructor self path constr_tag ~used_error_subtyping : - static_eval_result = - make_result self path - ~info: - (StaticInfo.eval_constructor - (Path.Map.find_opt self path) - constr_tag ~used_error_subtyping) - -let eval_eq_array_len self path len : static_eval_result = - make_result self path - ~info:(StaticInfo.eval_eq_array_len (Path.Map.find_opt self path) len) - -let eval_geq_array_len self path len : static_eval_result = - make_result self path - ~info:(StaticInfo.eval_geq_array_len (Path.Map.find_opt self path) len) - -let eval_map_elem self path key ~elem_ty : t = - Path.Map.add self path - (StaticInfo.eval_map_elem (Path.Map.find_opt self path) key ~elem_ty) + ~info:(matched : StaticInfo.t eval_result) = + (match matched with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain + { + ok_db = Path.Map.add self path ok_db; + fail_db = Path.Map.add self path fail_db; + } + : static_eval_result) + +let eval_range self path lo hi ~inclusive = + (make_result self path + ~info: + (StaticInfo.eval_range (Path.Map.find_opt self path) lo hi ~inclusive) + : static_eval_result) + +let eval_constructor self path constr_tag ~used_error_subtyping = + (make_result self path + ~info: + (StaticInfo.eval_constructor + (Path.Map.find_opt self path) + constr_tag ~used_error_subtyping) + : static_eval_result) + +let eval_eq_array_len self path len = + (make_result self path + ~info:(StaticInfo.eval_eq_array_len (Path.Map.find_opt self path) len) + : static_eval_result) + +let eval_geq_array_len self path len = + (make_result self path + ~info:(StaticInfo.eval_geq_array_len (Path.Map.find_opt self path) len) + : static_eval_result) + +let eval_eq_array_len_string self path len = + (make_result self path + ~info: + (StaticInfo.eval_eq_array_len_string (Path.Map.find_opt self path) len) + : static_eval_result) + +let eval_geq_array_len_string self path len = + (make_result self path + ~info: + (StaticInfo.eval_geq_array_len_string (Path.Map.find_opt self path) len) + : static_eval_result) + +let eval_map_elem self path key ~elem_ty = + (Path.Map.add self path + (StaticInfo.eval_map_elem (Path.Map.find_opt self path) key ~elem_ty) + : t) + +type partial_result = For_sure_no | Uncertain + +let eval_entire_array_pat (self : t) (path : Pat_path.t) + (pats : (Typedtree.pat * Pat_path.access) list) (op : [ `Ge | `Eq ]) + (num_pats : int) = + (let exception For_sure_no in + try + (match op with + | `Ge -> ( + match + StaticInfo.eval_geq_array_len (Path.Map.find_opt self path) num_pats + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ()) + | `Eq -> ( + match + StaticInfo.eval_eq_array_len (Path.Map.find_opt self path) num_pats + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ())); + Lst.iter pats ~f:(fun (pat, pat_path) -> + match pat with + | Tpat_constant { c; _ } -> ( + let path = pat_path :: path in + match StaticInfo.eval_constant (Path.Map.find_opt self path) c with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ()) + | _ -> ()); + Uncertain + with For_sure_no -> For_sure_no + : partial_result) + +let eval_entire_array_pat_string (self : t) (path : Pat_path.t) + (pats : (Typedtree.pat * Pat_path.access) list) (op : [ `Ge | `Eq ]) + (num_pats : int) = + (let exception For_sure_no in + try + (match op with + | `Ge -> ( + match + StaticInfo.eval_geq_array_len_string + (Path.Map.find_opt self path) + num_pats + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ()) + | `Eq -> ( + match + StaticInfo.eval_eq_array_len_string + (Path.Map.find_opt self path) + num_pats + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ())); + Lst.iter pats ~f:(fun (pat, pat_path) -> + match pat with + | Tpat_constant { c; _ } -> ( + let path = pat_path :: path in + match StaticInfo.eval_constant (Path.Map.find_opt self path) c with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ | For_sure_yes -> ()) + | _ -> ()); + Uncertain + with For_sure_no -> For_sure_no + : partial_result) + +let eval_string_literal (self : t) (path : Pat_path.t) (str : string) + ~check_match = + (let path_db = Path.Map.find_opt self path in + match StaticInfo.eval_constant path_db (C_string str) with + | For_sure_no -> For_sure_no + | For_sure_yes -> For_sure_yes + | Uncertain { ok_db; fail_db } -> ( + let exception For_sure_no in + try + let is_all_yes = ref true in + let chars = Basic_utf8.from_string str in + let char_len = Basic_vec_int.length chars in + (match StaticInfo.eval_eq_array_len_string path_db char_len with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ -> is_all_yes := false + | For_sure_yes -> ()); + (if check_match then + Basic_vec_int.iteri chars (fun i -> + fun c -> + let c_const = Constant.C_char (Uchar.of_int c) in + let path = Path.Field i :: path in + match + StaticInfo.eval_constant + (Path.Map.find_opt self path) + c_const + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ -> is_all_yes := false + | For_sure_yes -> ()) + else + let utf16_index = ref 0 in + Basic_vec_int.iteri chars (fun i -> + fun c -> + let c_const = Constant.C_char (Uchar.of_int c) in + let cur_utf16_index = !utf16_index in + let path = + if c > 0xFFFF then Path.Field i :: path + else + Path.Codeunit_field + { index = cur_utf16_index; rev = false } + :: path + in + utf16_index := !utf16_index + if c > 0xFFFF then 2 else 1; + match + StaticInfo.eval_constant + (Path.Map.find_opt self path) + c_const + with + | For_sure_no -> raise_notrace For_sure_no + | Uncertain _ -> is_all_yes := false + | For_sure_yes -> ())); + if !is_all_yes then For_sure_yes + else + Uncertain + { + ok_db = Path.Map.add self path ok_db; + fail_db = Path.Map.add self path fail_db; + } + with For_sure_no -> For_sure_no) + : static_eval_result) + +let eval_constant self path (constant : Constant.t) = + (make_result self path + ~info:(StaticInfo.eval_constant (Path.Map.find_opt self path) constant) + : static_eval_result) + +let eval_string_constant self path (str : string) ~check_match = + (eval_string_literal self path str ~check_match : static_eval_result) diff --git a/src/patmatch_static_info.ml b/src/patmatch_static_info.ml index 533ee91..689cb49 100644 --- a/src/patmatch_static_info.ml +++ b/src/patmatch_static_info.ml @@ -34,17 +34,16 @@ module MakeSetEncodedCaseSet (CaseType : Basic_set_intf.OrderedType) : let full = Exclude Set.empty - let eval self case : t Basic_case_set_intf.static_matching_result = - match self with - | Include mycase -> - if CaseType.equal mycase case then For_sure_yes { ok_db = self } - else For_sure_no { fail_db = self } - | Exclude cases -> - if Set.mem cases case then - For_sure_no { fail_db = Exclude (Set.add cases case) } - else - Uncertain - { ok_db = Include case; fail_db = Exclude (Set.add cases case) } + let eval self case = + (match self with + | Include mycase -> + if CaseType.equal mycase case then For_sure_yes else For_sure_no + | Exclude cases -> + if Set.mem cases case then For_sure_no + else + Uncertain + { ok_db = Include case; fail_db = Exclude (Set.add cases case) } + : t Basic_case_set_intf.static_matching_result) end module BoolDB = struct @@ -52,18 +51,14 @@ module BoolDB = struct let full = Db_unknown - let eval (self : t) (case : bool) : - t Basic_case_set_intf.static_matching_result = - match self with - | Db_false -> - if case then For_sure_no { fail_db = Db_false } - else For_sure_yes { ok_db = Db_false } - | Db_true -> - if case then For_sure_yes { ok_db = Db_true } - else For_sure_no { fail_db = Db_true } - | Db_unknown -> - if case then Uncertain { ok_db = Db_true; fail_db = Db_false } - else Uncertain { ok_db = Db_false; fail_db = Db_true } + let eval (self : t) (case : bool) = + (match self with + | Db_false -> if case then For_sure_no else For_sure_yes + | Db_true -> if case then For_sure_yes else For_sure_no + | Db_unknown -> + if case then Uncertain { ok_db = Db_true; fail_db = Db_false } + else Uncertain { ok_db = Db_false; fail_db = Db_true } + : t Basic_case_set_intf.static_matching_result) end module MakeIntCaseSet (Elt : sig @@ -79,30 +74,31 @@ struct let full = Diet.singleton Elt.min_int Elt.max_int - let eval (self : Diet.t) (case : Elt.t) : - Diet.t Basic_case_set_intf.static_matching_result = - let ok_db = Diet.singleton case case in - let fail_db () = Diet.diff self ok_db in - if Diet.mem case self then - if Diet.has_single_element self then For_sure_yes { ok_db } - else Uncertain { ok_db; fail_db = fail_db () } - else For_sure_no { fail_db = fail_db () } + let eval (self : Diet.t) (case : Elt.t) = + (let ok_db = Diet.singleton case case in + let fail_db () = Diet.diff self ok_db in + if Diet.mem case self then + if Diet.has_single_element self then For_sure_yes + else Uncertain { ok_db; fail_db = fail_db () } + else For_sure_no + : Diet.t Basic_case_set_intf.static_matching_result) let eval_range (self : Diet.t) (lo : Elt.t option) (hi : Elt.t option) - ~inclusive : Diet.t Basic_case_set_intf.static_matching_result = - let lo = Option.value lo ~default:Elt.min_int in - let hi = - match hi with - | None -> Elt.max_int - | Some hi -> if inclusive then hi else Elt.pred hi - in - let fail_db = Diet.diff self (Diet.singleton lo hi) in - let ok_db = Diet.diff self fail_db in - match (Diet.is_empty ok_db, Diet.is_empty fail_db) with - | true, true -> assert false - | true, false -> For_sure_no { fail_db } - | false, true -> For_sure_yes { ok_db } - | false, false -> Uncertain { ok_db; fail_db } + ~inclusive = + (let lo = Option.value lo ~default:Elt.min_int in + let hi = + match hi with + | None -> Elt.max_int + | Some hi -> if inclusive then hi else Elt.pred hi + in + let fail_db = Diet.diff self (Diet.singleton lo hi) in + let ok_db = Diet.diff self fail_db in + match (Diet.is_empty ok_db, Diet.is_empty fail_db) with + | true, true -> assert false + | true, false -> For_sure_no + | false, true -> For_sure_yes + | false, false -> Uncertain { ok_db; fail_db } + : Diet.t Basic_case_set_intf.static_matching_result) end module IntCaseSet = MakeIntCaseSet (Int32) @@ -114,8 +110,10 @@ let full_arr_len = IntCaseSet.Diet.singleton 0l Int32.max_int let full_uchar = IntCaseSet.Diet.singleton - (Uchar.to_int Uchar.min |> Int32.of_int) - (Uchar.to_int Uchar.max |> Int32.of_int) + (Int32.of_int (Uchar.to_int Uchar.min)) + (Int32.of_int (Uchar.to_int Uchar.max)) + +let full_byte = IntCaseSet.Diet.singleton 0l 255l module DoubleCaseSet = MakeSetEncodedCaseSet (struct include Float @@ -141,15 +139,16 @@ type t = | Bool of BoolDB.t | Uchar of IntCaseSet.t | Int of IntCaseSet.t + | Byte of IntCaseSet.t | UInt of UIntCaseSet.t | Int64 of Int64CaseSet.t | UInt64 of UInt64CaseSet.t | Bigint of BigintCaseSet.t | Float of DoubleCaseSet.t | Double of DoubleCaseSet.t - | String of StringCaseSet.t + | String of { literals : StringCaseSet.t; arr_len : IntCaseSet.t } | Bytes of StringCaseSet.t - | Constr of IntCaseSet.t + | Constr of Constr_info.Index_set.t | ErrorConstr of StringCaseSet.t | Array of { arr_len : IntCaseSet.t } | Map of { fetched : ConstantSet.t; elem_ty : Stype.t } @@ -158,639 +157,821 @@ let full_by_constant = function | Constant.C_bool _ -> Bool BoolDB.full | C_char _ -> Uchar full_uchar | C_int _ -> Int IntCaseSet.full + | C_byte _ -> Byte full_byte | C_int64 _ -> Int64 Int64CaseSet.full | C_uint _ -> UInt UIntCaseSet.full | C_uint64 _ -> UInt64 UInt64CaseSet.full | C_bigint _ -> Bigint BigintCaseSet.full | C_float _ -> Float DoubleCaseSet.full | C_double _ -> Double DoubleCaseSet.full - | C_string _ -> String StringCaseSet.full + | C_string _ -> + String { literals = StringCaseSet.full; arr_len = full_arr_len } | C_bytes _ -> Bytes StringCaseSet.full -let full_by_constr total = - Constr (IntCaseSet.Diet.singleton 0l (Int32.sub (Int32.of_int total) 1l)) - let full_by_extensible_constr = ErrorConstr StringCaseSet.full -let eval_constant self_opt constant : - t Basic_case_set_intf.static_matching_result = - let self = - match self_opt with Some self -> self | None -> full_by_constant constant - in - match (self, constant) with - | Bool cases, Constant.C_bool case -> ( - match BoolDB.eval cases case with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Bool ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Bool fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Bool ok_db; fail_db = Bool fail_db }) - | Uchar cases, C_char case -> ( - match IntCaseSet.eval cases (Uchar.to_int case |> Int32.of_int) with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Uchar ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Uchar fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Uchar ok_db; fail_db = Uchar fail_db }) - | Int cases, C_int case -> ( - match IntCaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Int ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Int fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Int ok_db; fail_db = Int fail_db }) - | Int64 cases, C_int64 case -> ( - match Int64CaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Int64 ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Int64 fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Int64 ok_db; fail_db = Int64 fail_db }) - | UInt cases, C_uint case -> ( - match UIntCaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = UInt ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = UInt fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = UInt ok_db; fail_db = UInt fail_db }) - | UInt64 cases, C_uint64 case -> ( - match UInt64CaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = UInt64 ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = UInt64 fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = UInt64 ok_db; fail_db = UInt64 fail_db }) - | Bigint cases, C_bigint case -> ( - match BigintCaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Bigint ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Bigint fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Bigint ok_db; fail_db = Bigint fail_db }) - | Double cases, C_double case -> ( - match DoubleCaseSet.eval cases case.v with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Double ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Double fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Double ok_db; fail_db = Double fail_db }) - | String cases, C_string case -> ( - match StringCaseSet.eval cases case with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = String ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = String fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = String ok_db; fail_db = String fail_db }) - | _ -> For_sure_no { fail_db = self } - -let eval_range self_opt lo hi ~inclusive : - t Basic_case_set_intf.static_matching_result = - let self = - match self_opt with - | Some self -> self - | None -> ( - match lo with - | Some c -> full_by_constant c - | None -> ( - match hi with Some c -> full_by_constant c | None -> assert false)) - in - match self with - | Uchar cases -> ( - let lo = - match lo with - | Some (C_char c) -> Some (Int32.of_int (Uchar.to_int c)) - | _ -> None - in - let hi = - match hi with - | Some (C_char c) -> Some (Int32.of_int (Uchar.to_int c)) - | _ -> None - in - match IntCaseSet.eval_range cases lo hi ~inclusive with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Uchar ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Uchar fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Uchar ok_db; fail_db = Uchar fail_db }) - | Int cases -> ( - let lo = - match lo with Some (C_int { v; repr = _ }) -> Some v | _ -> None - in - let hi = - match hi with Some (C_int { v; repr = _ }) -> Some v | _ -> None - in - match IntCaseSet.eval_range cases lo hi ~inclusive with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Int ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Int fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Int ok_db; fail_db = Int fail_db }) - | Int64 cases -> ( - let lo = - match lo with Some (C_int64 { v; repr = _ }) -> Some v | _ -> None - in - let hi = - match hi with Some (C_int64 { v; repr = _ }) -> Some v | _ -> None - in - match Int64CaseSet.eval_range cases lo hi ~inclusive with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Int64 ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Int64 fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = Int64 ok_db; fail_db = Int64 fail_db }) - | UInt cases -> ( - let lo = - match lo with Some (C_uint { v; repr = _ }) -> Some v | _ -> None - in - let hi = - match hi with Some (C_uint { v; repr = _ }) -> Some v | _ -> None - in - match UIntCaseSet.eval_range cases lo hi ~inclusive with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = UInt ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = UInt fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = UInt ok_db; fail_db = UInt fail_db }) - | UInt64 cases -> ( - let lo = - match lo with Some (C_uint64 { v; repr = _ }) -> Some v | _ -> None - in - let hi = - match hi with Some (C_uint64 { v; repr = _ }) -> Some v | _ -> None - in - match UInt64CaseSet.eval_range cases lo hi ~inclusive with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = UInt64 ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = UInt64 fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain { ok_db = UInt64 ok_db; fail_db = UInt64 fail_db }) - | _ -> For_sure_no { fail_db = self } +let eval_constant self_opt constant = + (let self = + match self_opt with Some self -> self | None -> full_by_constant constant + in + match (self, constant) with + | Bool cases, Constant.C_bool case -> ( + match BoolDB.eval cases case with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Bool ok_db; fail_db = Bool fail_db }) + | Uchar cases, C_char case -> ( + match IntCaseSet.eval cases (Int32.of_int (Uchar.to_int case)) with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Uchar ok_db; fail_db = Uchar fail_db }) + | Int cases, C_int case -> ( + match IntCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Int ok_db; fail_db = Int fail_db }) + | Byte cases, C_byte case -> ( + match IntCaseSet.eval cases (Int32.of_int case.v) with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Byte ok_db; fail_db = Byte fail_db }) + | Int64 cases, C_int64 case -> ( + match Int64CaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Int64 ok_db; fail_db = Int64 fail_db }) + | UInt cases, C_uint case -> ( + match UIntCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = UInt ok_db; fail_db = UInt fail_db }) + | UInt64 cases, C_uint64 case -> ( + match UInt64CaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = UInt64 ok_db; fail_db = UInt64 fail_db }) + | Bigint cases, C_bigint case -> ( + match BigintCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Bigint ok_db; fail_db = Bigint fail_db }) + | Double cases, C_double case -> ( + match DoubleCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Double ok_db; fail_db = Double fail_db }) + | Float cases, C_float case -> ( + match DoubleCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Float ok_db; fail_db = Float fail_db }) + | String { literals; arr_len }, C_string case -> ( + match StringCaseSet.eval literals case with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> ( + match + IntCaseSet.eval arr_len (Int32.of_int (Basic_utf8.length case)) + with + | For_sure_no -> For_sure_no + | For_sure_yes -> + Uncertain + { + ok_db = String { literals = ok_db; arr_len }; + fail_db = String { literals = fail_db; arr_len }; + } + | Uncertain { ok_db = ok_db_len; fail_db = _ } -> + Uncertain + { + ok_db = String { literals = ok_db; arr_len = ok_db_len }; + fail_db = String { literals = fail_db; arr_len }; + })) + | Bytes cases, C_bytes case -> ( + match StringCaseSet.eval cases case.v with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Bytes ok_db; fail_db = Bytes fail_db }) + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) + +let eval_range self_opt lo hi ~inclusive = + (let self = + match self_opt with + | Some self -> self + | None -> ( + match lo with + | Some c -> full_by_constant c + | None -> ( + match hi with Some c -> full_by_constant c | None -> assert false)) + in + match self with + | Uchar cases -> ( + let lo = + match lo with + | Some (C_char c) -> Some (Int32.of_int (Uchar.to_int c)) + | _ -> None + in + let hi = + match hi with + | Some (C_char c) -> Some (Int32.of_int (Uchar.to_int c)) + | _ -> None + in + match IntCaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Uchar ok_db; fail_db = Uchar fail_db }) + | Byte cases -> ( + let lo = + match lo with + | Some (C_byte { v; repr = _ }) -> Some (Int32.of_int v) + | _ -> None + in + let hi = + match hi with + | Some (C_byte { v; repr = _ }) -> Some (Int32.of_int v) + | _ -> None + in + match IntCaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Byte ok_db; fail_db = Byte fail_db }) + | Int cases -> ( + let lo = + match lo with Some (C_int { v; repr = _ }) -> Some v | _ -> None + in + let hi = + match hi with Some (C_int { v; repr = _ }) -> Some v | _ -> None + in + match IntCaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Int ok_db; fail_db = Int fail_db }) + | Int64 cases -> ( + let lo = + match lo with Some (C_int64 { v; repr = _ }) -> Some v | _ -> None + in + let hi = + match hi with Some (C_int64 { v; repr = _ }) -> Some v | _ -> None + in + match Int64CaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = Int64 ok_db; fail_db = Int64 fail_db }) + | UInt cases -> ( + let lo = + match lo with Some (C_uint { v; repr = _ }) -> Some v | _ -> None + in + let hi = + match hi with Some (C_uint { v; repr = _ }) -> Some v | _ -> None + in + match UIntCaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = UInt ok_db; fail_db = UInt fail_db }) + | UInt64 cases -> ( + let lo = + match lo with Some (C_uint64 { v; repr = _ }) -> Some v | _ -> None + in + let hi = + match hi with Some (C_uint64 { v; repr = _ }) -> Some v | _ -> None + in + match UInt64CaseSet.eval_range cases lo hi ~inclusive with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain { ok_db = UInt64 ok_db; fail_db = UInt64 fail_db }) + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) let eval_constructor self_opt (constr_tag : Constr_info.constr_tag) - ~(used_error_subtyping : bool) : - t Basic_case_set_intf.static_matching_result = - let eval_constr_index cases index : - t Basic_case_set_intf.static_matching_result = - match IntCaseSet.eval cases (Int32.of_int index) with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = Constr ok_db } - | For_sure_no { fail_db } -> For_sure_no { fail_db = Constr fail_db } - | Uncertain { ok_db; fail_db } -> + ~(used_error_subtyping : bool) = + (let eval_constr_index cases index = + (if not (Constr_info.Index_set.mem index cases) then For_sure_no + else if Constr_info.Index_set.has_single_element cases then For_sure_yes + else + let ok_db = Constr_info.Index_set.singleton index index in + let fail_db = Constr_info.Index_set.diff cases ok_db in Uncertain { ok_db = Constr ok_db; fail_db = Constr fail_db } - [@@local] - in - match constr_tag with - | Constr_tag_regular { index = case; total; _ } -> ( - let self = - match self_opt with Some self -> self | None -> full_by_constr total - in - match self with - | Constr cases -> eval_constr_index cases case - | _ -> For_sure_no { fail_db = self }) - | Extensible_tag { pkg; type_name; name; index; total } -> ( - let tag_str = Basic_constr_info.ext_tag_to_str ~pkg ~type_name ~name in - let self = - match self_opt with - | Some self -> self - | None -> - if used_error_subtyping then full_by_extensible_constr - else full_by_constr total - in - match self with - | ErrorConstr cases -> ( - match StringCaseSet.eval cases tag_str with - | For_sure_yes { ok_db } -> For_sure_yes { ok_db = ErrorConstr ok_db } - | For_sure_no { fail_db } -> - For_sure_no { fail_db = ErrorConstr fail_db } - | Uncertain { ok_db; fail_db } -> - Uncertain - { ok_db = ErrorConstr ok_db; fail_db = ErrorConstr fail_db }) - | Constr cases -> eval_constr_index cases index - | _ -> For_sure_no { fail_db = self }) - -let eval_eq_array_len self_opt len : - t Basic_case_set_intf.static_matching_result = - let len = Int32.of_int len in - let self = - match self_opt with - | Some self -> self - | None -> Array { arr_len = full_arr_len } - in - match self with - | Array { arr_len } -> - let ok_db = Array { arr_len = IntCaseSet.Diet.singleton len len } in - let fail_db () = - Array - { - arr_len = - IntCaseSet.Diet.diff arr_len (IntCaseSet.Diet.singleton len len); - } - in - if IntCaseSet.Diet.mem len arr_len then - if IntCaseSet.Diet.has_single_element arr_len then - For_sure_yes { ok_db } - else Uncertain { ok_db; fail_db = fail_db () } - else For_sure_no { fail_db = fail_db () } - | _ -> For_sure_no { fail_db = self } - -let eval_geq_array_len self_opt len : - t Basic_case_set_intf.static_matching_result = - let len = Int32.of_int len in - let self = - match self_opt with - | Some self -> self - | None -> Array { arr_len = full_arr_len } - in - match self with - | Array { arr_len } -> ( - match IntCaseSet.eval_range arr_len (Some len) None ~inclusive:false with - | For_sure_yes { ok_db } -> - For_sure_yes { ok_db = Array { arr_len = ok_db } } - | For_sure_no { fail_db } -> - For_sure_no { fail_db = Array { arr_len = fail_db } } - | Uncertain { ok_db; fail_db } -> - Uncertain - { - ok_db = Array { arr_len = ok_db }; - fail_db = Array { arr_len = fail_db }; - }) - | _ -> For_sure_no { fail_db = self } - -let eval_map_elem self_opt key ~elem_ty : t = - match self_opt with - | None -> Map { fetched = ConstantSet.singleton key; elem_ty } - | Some (Map { fetched; elem_ty }) -> - Map { fetched = ConstantSet.add fetched key; elem_ty } - | Some _ -> assert false + : t Basic_case_set_intf.static_matching_result) + [@@local] + in + match constr_tag with + | Constr_tag_regular { index = case; total; _ } -> ( + let self = + match self_opt with Some self -> self | None -> Constr total + in + match self with + | Constr cases -> eval_constr_index cases case + | _ -> For_sure_no) + | Extensible_tag { pkg; type_name; name; index; total } -> ( + let tag_str = Basic_constr_info.ext_tag_to_str ~pkg ~type_name ~name in + let self = + match self_opt with + | Some self -> self + | None -> + if used_error_subtyping then full_by_extensible_constr + else Constr total + in + match self with + | ErrorConstr cases -> ( + match StringCaseSet.eval cases tag_str with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain + { ok_db = ErrorConstr ok_db; fail_db = ErrorConstr fail_db }) + | Constr cases -> eval_constr_index cases index + | _ -> For_sure_no) + : t Basic_case_set_intf.static_matching_result) + +let eval_eq_array_len self_opt len = + (let len = Int32.of_int len in + let self = + match self_opt with + | Some self -> self + | None -> Array { arr_len = full_arr_len } + in + match self with + | Array { arr_len } -> + let ok_db = Array { arr_len = IntCaseSet.Diet.singleton len len } in + let fail_db () = + Array + { + arr_len = + IntCaseSet.Diet.diff arr_len (IntCaseSet.Diet.singleton len len); + } + in + if IntCaseSet.Diet.mem len arr_len then + if IntCaseSet.Diet.has_single_element arr_len then For_sure_yes + else Uncertain { ok_db; fail_db = fail_db () } + else For_sure_no + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) + +let eval_geq_array_len self_opt len = + (let len = Int32.of_int len in + let self = + match self_opt with + | Some self -> self + | None -> Array { arr_len = full_arr_len } + in + match self with + | Array { arr_len } -> ( + match IntCaseSet.eval_range arr_len (Some len) None ~inclusive:false with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain + { + ok_db = Array { arr_len = ok_db }; + fail_db = Array { arr_len = fail_db }; + }) + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) + +let eval_eq_array_len_string self_opt len = + (let len = Int32.of_int len in + let self = + match self_opt with + | Some self -> self + | None -> String { arr_len = full_arr_len; literals = StringCaseSet.full } + in + match self with + | String { arr_len; literals } -> + let ok_db = + String { arr_len = IntCaseSet.Diet.singleton len len; literals } + in + let fail_db () = + String + { + arr_len = + IntCaseSet.Diet.diff arr_len (IntCaseSet.Diet.singleton len len); + literals; + } + in + if IntCaseSet.Diet.mem len arr_len then + if IntCaseSet.Diet.has_single_element arr_len then For_sure_yes + else Uncertain { ok_db; fail_db = fail_db () } + else For_sure_no + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) + +let eval_geq_array_len_string self_opt len = + (let len = Int32.of_int len in + let self = + match self_opt with + | Some self -> self + | None -> String { arr_len = full_arr_len; literals = StringCaseSet.full } + in + match self with + | String { arr_len; literals } -> ( + match IntCaseSet.eval_range arr_len (Some len) None ~inclusive:false with + | For_sure_yes -> For_sure_yes + | For_sure_no -> For_sure_no + | Uncertain { ok_db; fail_db } -> + Uncertain + { + ok_db = String { arr_len = ok_db; literals }; + fail_db = String { arr_len = fail_db; literals }; + }) + | _ -> For_sure_no + : t Basic_case_set_intf.static_matching_result) + +let eval_map_elem self_opt key ~elem_ty = + (match self_opt with + | None -> Map { fetched = ConstantSet.singleton key; elem_ty } + | Some (Map { fetched; elem_ty }) -> + Map { fetched = ConstantSet.add fetched key; elem_ty } + | Some _ -> assert false + : t) let synthesize_missing_case_pattern (db : t Pat_path.Map.t) - ~(genv : Global_env.t) ~(empty_match : bool) (ty : Stype.t) : - Syntax.pattern list = - let pat_any : Syntax.pattern = Ppat_any { loc_ = Loc.no_location } in - let pat_const c : Syntax.pattern = - Ppat_constant { c; loc_ = Loc.no_location } - in - let pat_range lo hi : Syntax.pattern = - Ppat_range { lhs = lo; rhs = hi; inclusive = false; loc_ = Loc.no_location } - in - let pat_or ps = - match ps with - | [] -> None - | p0 :: ps -> - Lst.fold_right ps p0 (fun pat1 pat2 : Syntax.pattern -> - Ppat_or { pat1; pat2; loc_ = Loc.no_location }) - |> Option.some - in - let rec pat_for_path path ty = - let ty = Stype.type_repr ty in - match Pat_path.Map.find_opt db path with - | Some (Bool Db_unknown) -> - if empty_match then - pat_or [ pat_const (Const_bool true); pat_const (Const_bool false) ] - else Some pat_any - | Some (Bool Db_true) -> Some (pat_const (Const_bool true)) - | Some (Bool Db_false) -> Some (pat_const (Const_bool false)) - | Some (Uchar cases) -> ( - match Iter.head (IntCaseSet.Diet.iter cases) with - | Some code -> - let c = code |> Int32.to_int |> Uchar.of_int in - Some - (pat_const - (Const_char - { - char_val = c; - char_repr = Basic_uchar_utils.uchar_to_string c; - })) - | None -> None) - | Some (Int cases) -> - IntCaseSet.Diet.iter_range cases - |> Iter.map ~f:(fun (lo, hi) : Syntax.pattern -> - if Int32.equal lo hi then - pat_const (Const_int (Int32.to_string lo)) - else - let lo = - if Int32.equal lo Int32.min_int then pat_any - else pat_const (Const_int (Int32.to_string lo)) - in - let hi = - if Int32.equal hi Int32.max_int then pat_any - else pat_const (Const_int (Int32.to_string (Int32.succ hi))) - in - pat_range lo hi) - |> Iter.to_rev_list |> pat_or - | Some (Int64 cases) -> - Int64CaseSet.Diet.iter_range cases - |> Iter.map ~f:(fun (lo, hi) : Syntax.pattern -> - if Int64.equal lo hi then - pat_const (Const_int (Int64.to_string lo)) - else - let lo = - if Int64.equal lo Int64.min_int then pat_any - else pat_const (Const_int (Int64.to_string lo)) - in - let hi = - if Int64.equal hi Int64.max_int then pat_any - else pat_const (Const_int (Int64.to_string (Int64.succ hi))) - in - pat_range lo hi) - |> Iter.to_rev_list |> pat_or - | Some (UInt cases) -> - UIntCaseSet.Diet.iter_range cases - |> Iter.map ~f:(fun (lo, hi) : Syntax.pattern -> - if UInt32.equal lo hi then - pat_const (Const_int (UInt32.to_string lo)) - else - let lo = - if UInt32.equal lo UInt32.min_int then pat_any - else pat_const (Const_int (UInt32.to_string lo)) - in - let hi = - if UInt32.equal hi UInt32.max_int then pat_any - else - pat_const (Const_int (UInt32.to_string (UInt32.succ hi))) - in - pat_range lo hi) - |> Iter.to_rev_list |> pat_or - | Some (UInt64 cases) -> - UInt64CaseSet.Diet.iter_range cases - |> Iter.map ~f:(fun (lo, hi) : Syntax.pattern -> - if UInt64.equal lo hi then - pat_const (Const_int (UInt64.to_string lo)) - else - let lo = - if UInt64.equal lo UInt64.min_int then pat_any - else pat_const (Const_int (UInt64.to_string lo)) - in - let hi = - if UInt64.equal hi UInt64.max_int then pat_any + ~(genv : Global_env.t) ~(empty_match : bool) (ty : Stype.t) = + (let pat_any : Syntax.pattern = Ppat_any { loc_ = Loc.no_location } in + let pat_const c = + (Ppat_constant { c; loc_ = Loc.no_location } : Syntax.pattern) + in + let pat_range lo hi = + (Ppat_range + { lhs = lo; rhs = hi; inclusive = false; loc_ = Loc.no_location } + : Syntax.pattern) + in + let pat_or ps = + match ps with + | [] -> None + | p0 :: ps -> + Some + (Lst.fold_right ps p0 (fun pat1 -> + fun pat2 -> + (Ppat_or { pat1; pat2; loc_ = Loc.no_location } + : Syntax.pattern))) + in + let arr_len_is_full db = + IntCaseSet.Diet.is_empty (IntCaseSet.Diet.diff full_arr_len db) + in + let rec pat_for_path path ty ~empty_match = + let ty = Stype.type_repr ty in + match Pat_path.Map.find_opt db path with + | Some (Bool Db_unknown) -> + if empty_match then + pat_or [ pat_const (Const_bool true); pat_const (Const_bool false) ] + else Some pat_any + | Some (Bool Db_true) -> Some (pat_const (Const_bool true)) + | Some (Bool Db_false) -> Some (pat_const (Const_bool false)) + | Some (Byte cases) -> ( + match Iter.head (IntCaseSet.Diet.iter cases) with + | Some v -> + let byte_repr = Printf.sprintf "\\x%02x" (Int32.to_int v) in + Some + (pat_const (Const_byte { byte_val = Int32.to_int v; byte_repr })) + | None -> None) + | Some (Uchar cases) -> ( + match Iter.head (IntCaseSet.Diet.iter cases) with + | Some code -> + let c = Uchar.of_int (Int32.to_int code) in + Some + (pat_const + (Const_char + { + char_val = c; + char_repr = + String.escaped (Basic_uchar_utils.uchar_to_string c); + })) + | None -> None) + | Some (Int cases) -> + pat_or + (Iter.to_rev_list + (Iter.map + ~f:(fun (lo, hi) -> + (if Int32.equal lo hi then + pat_const (Const_int (Int32.to_string lo)) + else + let lo = + if Int32.equal lo Int32.min_int then pat_any + else pat_const (Const_int (Int32.to_string lo)) + in + let hi = + if Int32.equal hi Int32.max_int then pat_any + else + pat_const + (Const_int (Int32.to_string (Int32.succ hi))) + in + pat_range lo hi + : Syntax.pattern)) + (IntCaseSet.Diet.iter_range cases))) + | Some (Int64 cases) -> + pat_or + (Iter.to_rev_list + (Iter.map + ~f:(fun (lo, hi) -> + (if Int64.equal lo hi then + pat_const (Const_int (Int64.to_string lo)) + else + let lo = + if Int64.equal lo Int64.min_int then pat_any + else pat_const (Const_int (Int64.to_string lo)) + in + let hi = + if Int64.equal hi Int64.max_int then pat_any + else + pat_const + (Const_int (Int64.to_string (Int64.succ hi))) + in + pat_range lo hi + : Syntax.pattern)) + (Int64CaseSet.Diet.iter_range cases))) + | Some (UInt cases) -> + pat_or + (Iter.to_rev_list + (Iter.map + ~f:(fun (lo, hi) -> + (if UInt32.equal lo hi then + pat_const (Const_int (UInt32.to_string lo)) + else + let lo = + if UInt32.equal lo UInt32.min_int then pat_any + else pat_const (Const_int (UInt32.to_string lo)) + in + let hi = + if UInt32.equal hi UInt32.max_int then pat_any + else + pat_const + (Const_int (UInt32.to_string (UInt32.succ hi))) + in + pat_range lo hi + : Syntax.pattern)) + (UIntCaseSet.Diet.iter_range cases))) + | Some (UInt64 cases) -> + pat_or + (Iter.to_rev_list + (Iter.map + ~f:(fun (lo, hi) -> + (if UInt64.equal lo hi then + pat_const (Const_int (UInt64.to_string lo)) + else + let lo = + if UInt64.equal lo UInt64.min_int then pat_any + else pat_const (Const_int (UInt64.to_string lo)) + in + let hi = + if UInt64.equal hi UInt64.max_int then pat_any + else + pat_const + (Const_int (UInt64.to_string (UInt64.succ hi))) + in + pat_range lo hi + : Syntax.pattern)) + (UInt64CaseSet.Diet.iter_range cases))) + | Some (Float _cases) -> Some pat_any + | Some (Double _cases) -> Some pat_any + | Some (String { arr_len; _ }) when arr_len_is_full arr_len -> Some pat_any + | Some (Bytes _cases) -> Some pat_any + | Some (ErrorConstr _cases) -> Some pat_any + | Some (Bigint _cases) -> Some pat_any + | Some (Constr constr_cases) -> + let module Hash_int = Basic_hash_int in + let constrs = + Result.get_ok + (Global_env.constrs_of_variant genv ty ~loc:Loc.no_location + ~creating_value:false) + in + let index_to_constr = + Hash_int.of_list_map constrs (fun constr -> + let index = + match constr.cs_tag with + | Constr_tag_regular { index; _ } -> index + | Extensible_tag { index; _ } -> index + in + (index, constr)) + in + pat_or + (Iter.to_rev_list + (Iter.take 3 + (Iter.filter_map + ~f:(fun index -> + pat_for_constr ~ty path + (Hash_int.find_exn index_to_constr index) + ~with_payload:true) + (Constr_info.Index_set.iter constr_cases)))) + | Some (Array { arr_len } | String { arr_len; _ }) -> + let elem_ty = + match ty with + | T_constr { type_constructor; tys = elem_ty :: [] } + when Type_path.can_use_array_pattern type_constructor -> + elem_ty + | T_constr { type_constructor; _ } + when Type_path.is_bytesview type_constructor -> + Stype.byte + | T_builtin T_string -> Stype.char + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_stringview -> + Stype.char + | _ -> assert false + in + pat_or + (Iter.to_rev_list + (Iter.filter_map + ~f:(fun (min, max) -> + let len = Int32.to_int min in + let rec loop ~rev index acc = + if index >= len then + if rev then Some acc else Some (List.rev acc) + else + let p = + if rev then Pat_path.Last_field index else Field index + in + match + pat_for_path ~empty_match:false (p :: path) elem_ty + with + | None -> None + | Some elem_pat -> + loop ~rev (index + 1) (Syntax.Pattern elem_pat :: acc) + in + let make_open_arr_pat head_pats tail_pats = + (let rec trim pats n = + if n <= 0 then (pats, 0) + else + match pats with + | [] -> ([], n) + | Syntax.Pattern (Ppat_any _) :: pats -> + trim pats (n - 1) + | _ -> (pats, n) + in + let trimmed_tail_pats, rest_len = trim tail_pats len in + match trimmed_tail_pats with + | [] -> Open (head_pats, [], None) + | _ :: _ -> ( + let trimmed_head_pats, _ = + trim (List.rev head_pats) rest_len + in + match List.rev trimmed_head_pats with + | [] -> Open ([], trimmed_tail_pats, None) + | trimmed_head_pats -> + Open (trimmed_head_pats, trimmed_tail_pats, None)) + : Syntax.array_patterns) + in + if Int32.equal max Int32.max_int then + match loop ~rev:false 0 [] with + | None -> None + | Some head_pats -> ( + match loop ~rev:true 0 [] with + | None -> None + | Some tail_pats -> + Some + (Syntax.Ppat_array + { + pats = make_open_arr_pat head_pats tail_pats; + loc_ = Loc.no_location; + })) else - pat_const (Const_int (UInt64.to_string (UInt64.succ hi))) - in - pat_range lo hi) - |> Iter.to_rev_list |> pat_or - | Some (Float _cases) -> Some pat_any - | Some (Double _cases) -> Some pat_any - | Some (String _cases) -> Some pat_any - | Some (Bytes _cases) -> Some pat_any - | Some (ErrorConstr _cases) -> Some pat_any - | Some (Bigint _cases) -> Some pat_any - | Some (Constr constr_cases) -> - let module Hash_int = Basic_hash_int in - let constrs = - Global_env.constrs_of_variant genv ty ~loc:Loc.no_location - ~creating_value:false - |> Result.get_ok - in - let index_to_constr = - Hash_int.of_list_map constrs (fun constr -> - let index = - match constr.cs_tag with - | Constr_tag_regular { index; _ } -> index - | Extensible_tag { index; _ } -> index - in - (index, constr)) - in - IntCaseSet.Diet.iter constr_cases - |> Iter.filter_map ~f:(fun index -> - let index = Int32.to_int index in - pat_for_constr ~ty path (Hash_int.find_exn index_to_constr index)) - |> Iter.take 3 |> Iter.to_rev_list |> pat_or - | Some (Array { arr_len }) -> - let elem_ty = - match ty with - | T_constr { type_constructor; tys = elem_ty :: [] } - when Type_path.can_use_array_pattern type_constructor -> - elem_ty - | _ -> assert false - in - IntCaseSet.Diet.iter_range arr_len - |> Iter.filter_map ~f:(fun (min, max) -> - let len = Int32.to_int min in - let rec loop ~rev index acc = - if index >= len then - if rev then Some acc else Some (List.rev acc) - else - let p = - if rev then Pat_path.Last_field index else Field index + match loop ~rev:false 0 [] with + | Some pats -> + Some + (Syntax.Ppat_array + { pats = Closed pats; loc_ = Loc.no_location }) + | None -> None) + (IntCaseSet.Diet.iter_range arr_len))) + | Some (Map { fetched; elem_ty }) -> + let missing_case_for_present_fields = ref [] in + if + ConstantSet.for_all fetched (fun key -> + match + pat_for_path ~empty_match:false + (Pat_path.Map_elem { key } :: path) + elem_ty + with + | None -> false + | Some (Ppat_any _) -> true + | Some pat -> + let pat, match_absent = + match pat with + | Ppat_constr + { + constr = { constr_name = { name = "Some" }; _ }; + args = Some (Constr_pat_arg { pat; kind = _ } :: []); + is_open = _; + } -> + (pat, false) + | _ -> (pat, true) in - match pat_for_path (p :: path) elem_ty with + missing_case_for_present_fields := + Syntax.Map_pat_elem + { + key = Typeutil.typed_constant_to_syntax_constant key; + pat; + match_absent; + key_loc_ = Loc.no_location; + loc_ = Loc.no_location; + } + :: !missing_case_for_present_fields; + true) + then + Some + (Ppat_map + { + elems = !missing_case_for_present_fields; + is_closed = false; + loc_ = Loc.no_location; + }) + else + Some + (Ppat_map { elems = []; is_closed = false; loc_ = Loc.no_location }) + | None -> ( + match ty with + | T_constr { type_constructor = Tuple _; tys } -> + let rec loop index prev_pats_rev tys = + match tys with + | [] + when Lst.for_all prev_pats_rev (function + | Syntax.Ppat_any _ -> true + | _ -> false) -> + Some pat_any + | [] -> + Some + (Ppat_tuple + { + pats = List.rev prev_pats_rev; + loc_ = Loc.no_location; + }) + | ty :: tys -> ( + match pat_for_path ~empty_match (Field index :: path) ty with | None -> None - | Some elem_pat -> loop ~rev (index + 1) (elem_pat :: acc) - in - let make_open_arr_pat head_pats tail_pats : Syntax.array_pattern - = - let rec trim pats n = - if n <= 0 then (pats, 0) - else - match pats with - | [] -> ([], n) - | Syntax.Ppat_any _ :: pats -> trim pats (n - 1) - | _ -> (pats, n) + | Some elem_pat -> + loop (index + 1) (elem_pat :: prev_pats_rev) tys) + in + loop 0 [] tys + | T_constr { type_constructor; tys = _ } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_fixedarray -> + Some + (Ppat_array + { pats = Open ([], [], None); loc_ = Loc.no_location }) + | T_constr { type_constructor; tys = _ } -> ( + match Global_env.find_type_by_path genv type_constructor with + | None -> Some pat_any + | Some + { + ty_desc = + ( Variant_type (c :: []) + | ErrorEnum_type (c :: []) + | Error_type c + | New_type { newtype_constr = c; _ } ); + _; + } -> + pat_for_constr ~ty path c ~with_payload:(not empty_match) + | Some { ty_desc = Variant_type [] | ErrorEnum_type []; _ } -> None + | Some { ty_desc = Variant_type cs | ErrorEnum_type cs; _ } + when empty_match -> + pat_or + (Lst.fold_left cs [] (fun acc -> + fun c -> + match + pat_for_constr ~ty path c ~with_payload:false + with + | None -> acc + | Some p -> p :: acc)) + | Some + { + ty_desc = + ( Extern_type | Abstract_type | Variant_type _ + | ErrorEnum_type _ ); + _; + } -> + Some pat_any + | Some { ty_desc = Record_type { fields }; _ } -> + let _, fields = + Poly_type.instantiate_record ~ty_record:(`Known ty) fields in - let trimmed_tail_pats, rest_len = trim tail_pats len in - match trimmed_tail_pats with - | [] -> Open (head_pats, [], None) - | _ :: _ -> ( - let trimmed_head_pats, _ = - trim (List.rev head_pats) rest_len - in - match List.rev trimmed_head_pats with - | [] -> Open ([], trimmed_tail_pats, None) - | trimmed_head_pats -> - Open (trimmed_head_pats, trimmed_tail_pats, None)) - in - if Int32.equal max Int32.max_int then - match loop ~rev:false 0 [] with - | None -> None - | Some head_pats -> ( - match loop ~rev:true 0 [] with - | None -> None - | Some tail_pats -> + let rec loop prev_field_pats_rev fields = + match fields with + | [] -> + let fields, any_count = + Lst.fold_left prev_field_pats_rev ([], 0) + (fun (fields, any_count) -> + fun (field_pat : Syntax.field_pat) -> + match field_pat with + | Field_pat { pattern = Ppat_any _; _ } -> + (fields, any_count + 1) + | _ -> (field_pat :: fields, any_count)) + in + if fields = [] then Some pat_any + else Some - (Syntax.Ppat_array + (Ppat_record { - pats = make_open_arr_pat head_pats tail_pats; + fields; + is_closed = any_count = 0; loc_ = Loc.no_location; - })) + }) + | (field : Typedecl_info.field) :: fields -> ( + match + pat_for_path ~empty_match:false + (Field field.pos :: path) field.ty_field + with + | None -> None + | Some pattern -> + loop + (Syntax.Field_pat + { + label = + { + label_name = field.field_name; + loc_ = Loc.no_location; + }; + pattern; + is_pun = false; + loc_ = Loc.no_location; + } + :: prev_field_pats_rev) + fields) + in + loop [] fields) + | _ -> Some pat_any) + and pat_for_constr ~ty path (constr : Typedecl_info.constructor) + ~(with_payload : bool) = + let index = + match constr.cs_tag with + | Constr_tag_regular { index; _ } -> index + | Extensible_tag _ -> 0 + in + let arity = constr.cs_arity_ in + let ty_res, arg_tys = Poly_type.instantiate_constr constr in + Ctype.unify_exn ty_res ty; + let constr_name : Syntax.constr_name = + { name = constr.constr_name; loc_ = Loc.no_location } + in + let constr : Syntax.constructor = + { constr_name; extra_info = No_extra_info; loc_ = Loc.no_location } + in + let mk_pat ~is_open args = + (Some (Ppat_constr { constr; args; loc_ = Loc.no_location; is_open }) + : Syntax.pattern option) + in + match arg_tys with + | [] -> mk_pat ~is_open:false None + | arg_tys -> + let param_kinds = Fn_arity.to_list_map arity Fun.id in + let rec loop ~is_open arg_index prev_pats_rev arg_tys param_kinds = + match (arg_tys, param_kinds) with + | [], _ -> + if with_payload then + mk_pat ~is_open (Some (List.rev prev_pats_rev)) else - match loop ~rev:false 0 [] with - | Some pats -> - Some - (Syntax.Ppat_array - { pats = Closed pats; loc_ = Loc.no_location }) - | None -> None) - |> Iter.to_rev_list |> pat_or - | Some (Map { fetched; elem_ty }) -> - let missing_case_for_present_fields = ref [] in - if - ConstantSet.for_all fetched (fun key -> - match - pat_for_path (Pat_path.Map_elem { key } :: path) elem_ty - with - | None -> false - | Some (Ppat_any _) -> true - | Some pat -> - let pat, match_absent = - match pat with - | Ppat_constr - { - constr = { constr_name = { name = "Some" }; _ }; - args = Some (Constr_pat_arg { pat; kind = _ } :: []); - is_open = _; - } -> - (pat, false) - | _ -> (pat, true) - in - missing_case_for_present_fields := - Syntax.Map_pat_elem - { - key = Typeutil.typed_constant_to_syntax_constant key; - pat; - match_absent; - key_loc_ = Loc.no_location; - loc_ = Loc.no_location; - } - :: !missing_case_for_present_fields; - true) - then - Some - (Ppat_map - { - elems = !missing_case_for_present_fields; - loc_ = Loc.no_location; - }) - else Some (Ppat_map { elems = []; loc_ = Loc.no_location }) - | None -> ( - match ty with - | T_constr { type_constructor = Tuple _; tys } -> - let rec loop index prev_pats_rev tys = - match tys with - | [] - when Lst.for_all prev_pats_rev (function - | Syntax.Ppat_any _ -> true - | _ -> false) -> - Some pat_any - | [] -> - Some - (Ppat_tuple - { pats = List.rev prev_pats_rev; loc_ = Loc.no_location }) - | ty :: tys -> ( - match pat_for_path (Field index :: path) ty with - | None -> None - | Some elem_pat -> - loop (index + 1) (elem_pat :: prev_pats_rev) tys) - in - loop 0 [] tys - | T_constr { type_constructor; tys = _ } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_fixedarray -> - Some - (Ppat_array { pats = Open ([], [], None); loc_ = Loc.no_location }) - | T_constr { type_constructor; tys = _ } -> ( - match Global_env.find_type_by_path genv type_constructor with - | None -> Some pat_any - | Some - { - ty_desc = - ( Extern_type | Abstract_type | Variant_type _ | New_type _ - | Error_type _ | ErrorEnum_type _ ); - _; - } -> - Some pat_any - | Some { ty_desc = Record_type { fields }; _ } -> - let _, fields = - Poly_type.instantiate_record ~ty_record:(`Known ty) fields - in - let rec loop prev_field_pats_rev fields = - match fields with - | [] -> - let fields, any_count = - Lst.fold_left prev_field_pats_rev ([], 0) - (fun - (fields, any_count) - (field_pat : Syntax.field_pat) - -> - match field_pat with - | Field_pat { pattern = Ppat_any _; _ } -> - (fields, any_count + 1) - | _ -> (field_pat :: fields, any_count)) - in - if fields = [] then Some pat_any - else - Some - (Ppat_record - { - fields; - is_closed = any_count = 0; - loc_ = Loc.no_location; - }) - | (field : Typedecl_info.field) :: fields -> ( - match - pat_for_path (Field field.pos :: path) field.ty_field - with - | None -> None - | Some pattern -> - loop - (Syntax.Field_pat - { - label = - { - label_name = field.field_name; - loc_ = Loc.no_location; - }; - pattern; - is_pun = false; - loc_ = Loc.no_location; - } - :: prev_field_pats_rev) - fields) - in - loop [] fields) - | _ -> Some pat_any) - and pat_for_constr ~ty path (constr : Typedecl_info.constructor) = - let index = - match constr.cs_tag with - | Constr_tag_regular { index; _ } -> index - | Extensible_tag _ -> 0 - in - let arity = constr.cs_arity_ in - let ty_res, arg_tys = Poly_type.instantiate_constr constr in - Ctype.unify_exn ty_res ty; - let constr_name : Syntax.constr_name = - { name = constr.constr_name; loc_ = Loc.no_location } - in - let constr : Syntax.constructor = - { constr_name; extra_info = No_extra_info; loc_ = Loc.no_location } - in - let mk_pat ~is_open args : Syntax.pattern option = - Some (Ppat_constr { constr; args; loc_ = Loc.no_location; is_open }) - in - match arg_tys with - | [] -> mk_pat ~is_open:false None - | arg_tys -> - let param_kinds = Fn_arity.to_list_map arity Fun.id in - let rec loop ~is_open arg_index prev_pats_rev arg_tys param_kinds = - match (arg_tys, param_kinds) with - | [], _ -> mk_pat ~is_open (Some (List.rev prev_pats_rev)) - | arg_ty :: arg_tys, param_kind :: param_kinds -> ( - let kind : Syntax.argument_kind = - match (param_kind : Fn_arity.param_kind) with - | Positional _ -> Positional - | Labelled { label = label_name; _ } - | Optional { label = label_name; _ } - | Autofill { label = label_name } - | Question_optional { label = label_name } -> - Labelled { label_name; loc_ = Loc.no_location } - in - let arg_path : Pat_path.t = - Constr_field { tag_index = index; arg_index } :: path - in - match (kind, pat_for_path arg_path arg_ty) with - | _, None -> None - | ( ( Labelled _ | Labelled_pun _ | Labelled_option _ - | Labelled_option_pun _ ), - Some (Ppat_any _) ) -> - loop ~is_open:true (arg_index + 1) prev_pats_rev arg_tys - param_kinds - | _, Some arg_pat -> - loop ~is_open (arg_index + 1) - (Constr_pat_arg { pat = arg_pat; kind } :: prev_pats_rev) - arg_tys param_kinds) - | _ -> assert false - in - loop ~is_open:false 0 [] arg_tys param_kinds - in - match pat_for_path [] ty with - | None -> [] - | Some pat -> - let rec break_or_pat (p : Syntax.pattern) = - match p with - | Ppat_or { pat1; pat2 } -> pat1 :: break_or_pat pat2 - | _ -> [ p ] - in - break_or_pat pat + mk_pat ~is_open:false + (Some [ Constr_pat_arg { pat = pat_any; kind = Positional } ]) + | arg_ty :: arg_tys, param_kind :: param_kinds -> ( + let kind : Syntax.argument_kind = + match (param_kind : Fn_arity.param_kind) with + | Positional _ -> Positional + | Labelled { label = label_name; _ } + | Optional { label = label_name; _ } + | Autofill { label = label_name } + | Question_optional { label = label_name } -> + Labelled { label_name; loc_ = Loc.no_location } + in + let arg_path : Pat_path.t = + Constr_field { tag_index = index; arg_index } :: path + in + match + (kind, pat_for_path ~empty_match:false arg_path arg_ty) + with + | _, None -> None + | ( ( Labelled _ | Labelled_pun _ | Labelled_option _ + | Labelled_option_pun _ ), + Some (Ppat_any _) ) -> + loop ~is_open:true (arg_index + 1) prev_pats_rev arg_tys + param_kinds + | _, Some arg_pat -> + loop ~is_open (arg_index + 1) + (Constr_pat_arg { pat = arg_pat; kind } :: prev_pats_rev) + arg_tys param_kinds) + | _ -> assert false + in + loop ~is_open:false 0 [] arg_tys param_kinds + in + match pat_for_path ~empty_match [] ty with + | None -> [] + | Some pat -> + let rec break_or_pat (p : Syntax.pattern) = + match p with + | Ppat_or { pat1; pat2 } -> pat1 :: break_or_pat pat2 + | _ -> [ p ] + in + break_or_pat pat + : Syntax.pattern list) diff --git a/src/pattern_id.ml b/src/pattern_id.ml index 694aa39..71f56a1 100644 --- a/src/pattern_id.ml +++ b/src/pattern_id.ml @@ -22,10 +22,12 @@ module Pattern_id_map = Basic_mapf.Make (struct let _ = fun (_ : t) -> () let compare = - (fun a__001_ b__002_ -> - Ppx_base.compare_list - (fun a__003_ b__004_ -> Stdlib.compare (a__003_ : int) b__004_) - a__001_ b__002_ + (fun a__001_ -> + fun b__002_ -> + Ppx_base.compare_list + (fun a__003_ -> + fun b__004_ -> Stdlib.compare (a__003_ : int) b__004_) + a__001_ b__002_ : t -> t -> int) let _ = compare @@ -38,10 +40,11 @@ module Pattern_id_map = Basic_mapf.Make (struct let _ = sexp_of_t let equal = - (fun a__006_ b__007_ -> - Ppx_base.equal_list - (fun a__008_ b__009_ -> Stdlib.( = ) (a__008_ : int) b__009_) - a__006_ b__007_ + (fun a__006_ -> + fun b__007_ -> + Ppx_base.equal_list + (fun a__008_ -> fun b__009_ -> Stdlib.( = ) (a__008_ : int) b__009_) + a__006_ b__007_ : t -> t -> bool) let _ = equal @@ -50,7 +53,7 @@ end) type t = bool Pattern_id_map.t ref -let create () : t = ref Pattern_id_map.empty +let create () = (ref Pattern_id_map.empty : t) let is_unreachable (self : t) (pat_id : key) = Pattern_id_map.find_default !self pat_id true diff --git a/src/pattern_typer.ml b/src/pattern_typer.ml index 03e2d81..aac64d9 100644 --- a/src/pattern_typer.ml +++ b/src/pattern_typer.ml @@ -19,732 +19,880 @@ module I = Basic_ident module Constr_info = Basic_constr_info module Syntax = Parsing_syntax module Operators = Parsing_operators +module Type_path = Basic_type_path let add_error = Typeutil.add_local_typing_error let store_error = Typeutil.store_error let take_info_partial = Typeutil.take_info_partial let add_pat_binder (b : Typedtree.pat_binder) (binders : Typedtree.pat_binders) - : _ Local_diagnostics.partial_info = - if - Lst.exists binders (fun a -> - I.same_local_name a.binder.binder_id b.binder.binder_id) - then - let error = - Errors.non_linear_pattern - ~name:(I.base_name b.binder.binder_id) - ~loc:b.binder.loc_ - in - Partial (binders, [ error ]) - else Ok (b :: binders) + = + (if + Lst.exists binders (fun a -> + I.same_local_name a.binder.binder_id b.binder.binder_id) + then + let error = + Errors.non_linear_pattern + ~name:(I.base_name b.binder.binder_id) + ~loc:b.binder.loc_ + in + Partial (binders, [ error ]) + else Ok (b :: binders) + : _ Local_diagnostics.partial_info) let combine_pat_binders ~(new_binders : Typedtree.pat_binders) - ~(binders : Typedtree.pat_binders) : _ Local_diagnostics.partial_info = - let duplicated = ref [] in - let add_binder (acc : Typedtree.pat_binders) (b : Typedtree.pat_binder) = - if - Lst.exists acc (fun a -> - I.same_local_name a.binder.binder_id b.binder.binder_id) - then ( - duplicated := b :: !duplicated; - acc) - else b :: acc - in - let res = List.fold_left add_binder new_binders binders in - match !duplicated with - | [] -> Ok res - | dups -> - let errors = - Lst.map dups (fun b -> - Errors.non_linear_pattern - ~name:(I.base_name b.binder.binder_id) - ~loc:b.binder.loc_) - in - Partial (res, errors) + ~(binders : Typedtree.pat_binders) = + (let duplicated = ref [] in + let add_binder (acc : Typedtree.pat_binders) (b : Typedtree.pat_binder) = + if + Lst.exists acc (fun a -> + I.same_local_name a.binder.binder_id b.binder.binder_id) + then ( + duplicated := b :: !duplicated; + acc) + else b :: acc + in + let res = List.fold_left add_binder new_binders binders in + match !duplicated with + | [] -> Ok res + | dups -> + let errors = + Lst.map dups (fun b -> + Errors.non_linear_pattern + ~name:(I.base_name b.binder.binder_id) + ~loc:b.binder.loc_) + in + Partial (res, errors) + : _ Local_diagnostics.partial_info) let merge_pat_binders (binders1 : Typedtree.pat_binders) - (binders2 : Typedtree.pat_binders) : - Typedtree.pat_binders Local_diagnostics.partial_info = - let binder_compare (b1 : Typedtree.pat_binder) (b2 : Typedtree.pat_binder) = - String.compare - (I.base_name b1.binder.binder_id) - (I.base_name b2.binder.binder_id) - in - let sorted_binders1 = Lst.stable_sort binders1 binder_compare in - let sorted_binders2 = Lst.stable_sort binders2 binder_compare in - let errors = ref [] in - let rec go (bs1 : Typedtree.pat_binders) bs2 : Typedtree.pat_binders = - match (bs1, bs2) with - | [], [] -> [] - | [], b :: _ | b :: _, [] -> - let name = I.base_name b.binder.binder_id in - errors := - Errors.inconsistent_or_pattern ~name ~loc:b.binder.loc_ :: !errors; - bs1 - | b1 :: rest1, b2 :: rest2 -> - let name1 = I.base_name b1.binder.binder_id in - let name2 = I.base_name b2.binder.binder_id in - if name1 = name2 then - let ty1, tag1 = Type.deref_constr_type b1.binder_typ in - let ty2, tag2 = Type.deref_constr_type b2.binder_typ in - match - Ctype.unify_pat ~expect_ty:ty1 ~actual_ty:ty2 b2.binder.loc_ - with - | Some err -> - errors := err :: !errors; - { b1 with binder_typ = ty1 } :: go rest1 rest2 - | None -> - (match (tag1, tag2) with - | Some tag1, Some tag2 when Constr_info.equal tag1 tag2 -> b1 - | Some _, _ -> { b1 with binder_typ = ty1 } - | None, _ -> b1) - :: go rest1 rest2 - else if name1 < name2 then ( + (binders2 : Typedtree.pat_binders) = + (let binder_compare (b1 : Typedtree.pat_binder) (b2 : Typedtree.pat_binder) = + String.compare + (I.base_name b1.binder.binder_id) + (I.base_name b2.binder.binder_id) + in + let sorted_binders1 = Lst.stable_sort binders1 binder_compare in + let sorted_binders2 = Lst.stable_sort binders2 binder_compare in + let errors = ref [] in + let rec go (bs1 : Typedtree.pat_binders) bs2 = + (match (bs1, bs2) with + | [], [] -> [] + | [], b :: _ | b :: _, [] -> + let name = I.base_name b.binder.binder_id in errors := - Errors.inconsistent_or_pattern ~name:name1 ~loc:b1.binder.loc_ - :: !errors; - bs1) - else ( - errors := - Errors.inconsistent_or_pattern ~name:name2 ~loc:b2.binder.loc_ - :: !errors; - bs1) - in - let binders = go sorted_binders1 sorted_binders2 in - match !errors with [] -> Ok binders | errs -> Partial (binders, errs) + Errors.inconsistent_or_pattern ~name ~loc:b.binder.loc_ :: !errors; + bs1 + | b1 :: rest1, b2 :: rest2 -> + let name1 = I.base_name b1.binder.binder_id in + let name2 = I.base_name b2.binder.binder_id in + if name1 = name2 then + let ty1, tag1 = Type.deref_constr_type b1.binder_typ in + let ty2, tag2 = Type.deref_constr_type b2.binder_typ in + match + Ctype.unify_pat ~expect_ty:ty1 ~actual_ty:ty2 b2.binder.loc_ + with + | Some err -> + errors := err :: !errors; + { b1 with binder_typ = ty1 } :: go rest1 rest2 + | None -> + (match (tag1, tag2) with + | Some tag1, Some tag2 when Constr_info.equal tag1 tag2 -> b1 + | Some _, _ -> { b1 with binder_typ = ty1 } + | None, _ -> b1) + :: go rest1 rest2 + else if name1 < name2 then ( + errors := + Errors.inconsistent_or_pattern ~name:name1 ~loc:b1.binder.loc_ + :: !errors; + bs1) + else ( + errors := + Errors.inconsistent_or_pattern ~name:name2 ~loc:b2.binder.loc_ + :: !errors; + bs1) + : Typedtree.pat_binders) + in + let binders = go sorted_binders1 sorted_binders2 in + match !errors with [] -> Ok binders | errs -> Partial (binders, errs) + : Typedtree.pat_binders Local_diagnostics.partial_info) -let get_view_type (env : Global_env.t) (ty : Stype.t) : Stype.t option = - match Stype.type_repr ty with - | T_constr { type_constructor = p; _ } -> ( - match - Global_env.find_dot_method env ~type_name:p ~method_name:"op_as_view" - with - | method_ :: [] -> ( - let func_ty, _ = Poly_type.instantiate_method_no_constraint method_ in - match func_ty with - | Tarrow { params_ty = ty_self :: _; ret_ty; err_ty = _ } -> - Ctype.unify_exn ty_self ty; - Some ret_ty - | _ -> None) - | _ -> None) - | _ -> None +let get_view_type (env : Global_env.t) (ty : Stype.t) = + (let find_by_path p = + match + Global_env.find_dot_method env ~type_name:p ~method_name:"op_as_view" + with + | method_ :: [] -> ( + let func_ty, _, _ = + Poly_type.instantiate_method_no_constraint method_ + in + match func_ty with + | Tarrow { params_ty = ty_self :: _; ret_ty; err_ty = _; is_async = _ } + -> + Ctype.unify_exn ty_self ty; + Some ret_ty + | _ -> None) + | _ -> None + [@@inline] + in + match Stype.type_repr ty with + | T_constr { type_constructor = p; _ } -> find_by_path p + | T_builtin T_string -> find_by_path Basic_type_path.Builtin.type_path_string + | _ -> None + : Stype.t option) -let get_key_value_type ~global_env ~cenv ~tvar_env (ty : Stype.t) ~loc : - (Stype.t * Stype.t * (I.t * Stype.t * Stype.t array)) Local_diagnostics.info - = - match - Type_constraint.resolve_method_by_type ty Operators.op_get_info.method_name - ~loc ~src:Dot_src_direct ~tvar_env ~global_env - with - | Error _ -> - Error - (Errors.cannot_use_map_pattern_no_method - ~ty:(Printer.type_to_string ty) - ~loc) - | Ok method_info -> ( - let check_method_ty method_id method_ty method_arity ~ty_args : - _ Local_diagnostics.info = - let ty_key = Stype.new_type_var Tvar_normal in - let ty_value = Builtin.type_option (Stype.new_type_var Tvar_normal) in - if - Ctype.try_unify method_ty - (Builtin.type_arrow [ ty; ty_key ] ty_value ~err_ty:None) - && Fn_arity.equal method_arity (Fn_arity.simple 2) - then Ok (ty_key, ty_value, (method_id, method_ty, ty_args)) - else - Error - (Errors.cannot_use_map_pattern_method_type_mismatch - ~ty:(Printer.type_to_string ty) - ~actual_ty: - (Printer.toplevel_function_type_to_string ~arity:method_arity - method_ty) - ~loc) - [@@local] - in - match method_info with - | Promised_method { method_ty; method_arity; method_id; prim = _ } -> - check_method_ty method_id method_ty method_arity ~ty_args:[||] - | Known_method mi -> - let method_ty, ty_args = Poly_type.instantiate_method ~cenv ~loc mi in - check_method_ty (I.of_qual_ident mi.id) method_ty mi.arity_ ~ty_args) +let get_key_value_type ~global_env ~cenv ~tvar_env (ty : Stype.t) ~loc = + (match + Type_constraint.resolve_method_by_type ty Operators.op_get_info.method_name + ~loc ~src:Dot_src_direct ~tvar_env ~global_env + with + | Error _ -> + Error + (Errors.cannot_use_map_pattern_no_method + ~ty:(Printer.type_to_string ty) + ~loc) + | Ok method_info -> ( + let check_method_ty method_id method_ty method_arity ~ty_args = + (let ty_key = Stype.new_type_var Tvar_normal in + let ty_value = Builtin.type_option (Stype.new_type_var Tvar_normal) in + if + Ctype.try_unify method_ty + (Builtin.type_arrow [ ty; ty_key ] ty_value ~err_ty:None + ~is_async:false) + && Fn_arity.equal method_arity (Fn_arity.simple 2) + then Ok (ty_key, ty_value, (method_id, method_ty, ty_args)) + else + Error + (Errors.cannot_use_map_pattern_method_type_mismatch + ~ty:(Printer.type_to_string ty) + ~actual_ty: + (Printer.toplevel_function_type_to_string ~arity:method_arity + method_ty) + ~loc) + : _ Local_diagnostics.info) + [@@local] + in + match method_info with + | Promised_method { method_ty; method_arity; method_id; prim = _ } -> + check_method_ty method_id method_ty method_arity ~ty_args:[||] + | Known_method mi -> + let method_ty, ty_args = + Poly_type.instantiate_method ~cenv ~loc mi + in + check_method_ty (I.of_qual_ident mi.id) method_ty mi.arity_ ~ty_args) + : (Stype.t * Stype.t * (I.t * Stype.t * Stype.t array)) + Local_diagnostics.info) + +let fields_of_struct ~global_env p = + match Global_env.find_type_by_path global_env p with + | None -> None + | Some info -> ( + match info.ty_desc with + | Record_type { fields; _ } -> + Some (Lst.map fields (fun f -> f.field_name)) + | _ -> None) let rec type_guided_record_pat_check (fields : Syntax.field_pat list) (labels : Typedecl_info.field list) is_closed record_ty ~tvar_env ~cenv - ~global_env ~diagnostics ~loc : Typedtree.pat_binders * Typedtree.pat = - let _ = - Typeutil.validate_record ~context:`Pattern ~expected:labels - (Lst.map fields (fun (Field_pat { label; _ }) -> label)) - ~record_ty ~is_strict:is_closed ~loc - |> take_info_partial ~diagnostics - in - let binders = ref [] in - let check_field_pat (Field_pat { label; pattern; is_pun } : Syntax.field_pat) - : Typedtree.field_pat = - let ty, pos = - match - Lst.find_first labels (fun { field_name; _ } -> - field_name = label.label_name) - with - | None -> (Stype.new_type_var Tvar_error, Typeutil.unknown_pos) - | Some field_info -> (field_info.ty_field, field_info.pos) - in - let new_binders, pat = - check_pat pattern ty ~tvar_env ~cenv ~global_env ~diagnostics - in - binders := - combine_pat_binders ~new_binders ~binders:!binders - |> take_info_partial ~diagnostics; - Field_pat { label; pat; is_pun; pos } - [@@inline] - in - let fields = List.map check_field_pat fields in - (!binders, Tpat_record { fields; ty = record_ty; loc_ = loc; is_closed }) + ~global_env ~diagnostics ~loc = + (let _ = + Typeutil.validate_record ~context:`Pattern ~expected:labels + (Lst.map fields (fun (Field_pat { label; _ }) -> label)) + ~record_ty ~is_strict:is_closed ~loc ~diagnostics + in + let binders = ref [] in + let check_field_pat (Field_pat { label; pattern; is_pun } : Syntax.field_pat) + = + (let ty, pos = + match + Lst.find_first labels (fun { field_name; _ } -> + field_name = label.label_name) + with + | None -> (Stype.new_type_var Tvar_error, Typeutil.unknown_pos) + | Some field_info -> (field_info.ty_field, field_info.pos) + in + let new_binders, pat = + check_pat pattern ty ~tvar_env ~cenv ~global_env ~diagnostics + in + binders := + take_info_partial ~diagnostics + (combine_pat_binders ~new_binders ~binders:!binders); + Field_pat { label; pat; is_pun; pos } + : Typedtree.field_pat) + [@@inline] + in + let fields = Lst.map fields check_field_pat in + (!binders, Tpat_record { fields; ty = record_ty; loc_ = loc; is_closed }) + : Typedtree.pat_binders * Typedtree.pat) and infer_record_pat (fields : Syntax.field_pat list) (ty : Stype.t) is_closed - ~tvar_env ~cenv ~global_env ~diagnostics ~loc : - Typedtree.pat_binders * Typedtree.pat = - let handle_error err : Typedtree.pat_binders * Typedtree.pat = - add_error diagnostics err; - let go (pat_binders_acc, pat_acc) - (Field_pat { label; pattern; is_pun } : Syntax.field_pat) = - let ty = Stype.new_type_var Tvar_error in - let pat_binders, pat = - check_pat pattern ty ~tvar_env ~cenv ~global_env ~diagnostics + ~tvar_env ~cenv ~global_env ~diagnostics ~loc = + (let handle_error err = + (add_error diagnostics err; + let go (pat_binders_acc, pat_acc) + (Field_pat { label; pattern; is_pun } : Syntax.field_pat) = + let ty = Stype.new_type_var Tvar_error in + let pat_binders, pat = + check_pat pattern ty ~tvar_env ~cenv ~global_env ~diagnostics + in + ( pat_binders @ pat_binders_acc, + Typedtree.Field_pat { label; pat; is_pun; pos = Typeutil.unknown_pos } + :: pat_acc ) in - ( pat_binders @ pat_binders_acc, - Typedtree.Field_pat { label; pat; is_pun; pos = Typeutil.unknown_pos } - :: pat_acc ) - in - let pat_binders, fields = List.fold_left go ([], []) fields in - ( pat_binders, - Tpat_record { fields = List.rev fields; ty; loc_ = loc; is_closed } ) - in - if fields = [] then handle_error (Errors.record_type_missing loc) - else - let labels = Lst.map fields (fun (Field_pat { label; _ }) -> label) in - match Lst.check_duplicate_opt labels ~equal:Syntax.equal_label with - | Some { label_name = label; loc_ = loc } -> - handle_error - (Errors.duplicate_record_field ~context:`Pattern ~label ~loc) - | None -> ( - match Global_env.resolve_record global_env ~labels ~loc with - | Error err -> handle_error err - | Ok (ty_params, ty_record, labels) -> - let ty, labels = - Poly_type.instantiate_record - ~ty_record:(`Generic (ty_params, ty_record)) - labels - in - type_guided_record_pat_check fields labels is_closed ty ~tvar_env - ~cenv ~global_env ~diagnostics ~loc) + let pat_binders, fields = List.fold_left go ([], []) fields in + ( pat_binders, + Tpat_record { fields = List.rev fields; ty; loc_ = loc; is_closed } ) + : Typedtree.pat_binders * Typedtree.pat) + in + if fields = [] then handle_error (Errors.record_type_missing loc) + else + let labels = Lst.map fields (fun (Field_pat { label; _ }) -> label) in + match + Basic_duplicate_check.check_duplicate_by labels (fun x -> x.label_name) + with + | Some { label_name = label; loc_ = loc } -> + handle_error + (Errors.duplicate_record_field ~context:`Pattern ~label ~loc) + | None -> ( + match Global_env.resolve_record global_env ~labels ~loc with + | Error err -> handle_error err + | Ok (ty_params, ty_record, labels) -> + let ty, labels = + Poly_type.instantiate_record + ~ty_record:(`Generic (ty_params, ty_record)) + labels + in + type_guided_record_pat_check fields labels is_closed ty ~tvar_env + ~cenv ~global_env ~diagnostics ~loc) + : Typedtree.pat_binders * Typedtree.pat) and check_constr_pat (constr : Syntax.constructor) (args : Syntax.constr_pat_arg list option) (constr_desc : Typedecl_info.constructor) (expect_ty : Stype.t) - ~(is_open : bool) ~tvar_env ~cenv ~global_env ~diagnostics ~loc : - Typedtree.pat_binders * Typedtree.pat = - let name = constr.constr_name.name in - let cs_tag = constr_desc.cs_tag in - let ty_res, ty_args = Poly_type.instantiate_constr constr_desc in - (if Typeutil.is_tvar (Stype.type_repr expect_ty) then - if Type.is_suberror ty_res then Ctype.unify_exn expect_ty Stype.error - else Ctype.unify_exn expect_ty ty_res - else - try Ctype.unify_exn expect_ty ty_res - with _ -> - if not (Type.is_super_error expect_ty && Type.is_suberror ty_res) then - let expected = Printer.type_to_string expect_ty in - let actual = Printer.type_to_string ty_res in - add_error diagnostics - (Errors.constr_unify ~name ~expected ~actual ~loc)); - let is_super_error = Type.is_super_error expect_ty in - let do_check args = - let arity = constr_desc.cs_arity_ in - let typ_of_args = - let pos = ref (-1) in - Fn_arity.to_hashtbl arity ty_args (fun _ ty -> - incr pos; - (!pos, ty)) - in - let seen_labels = Basic_hash_string.create 17 in - let last_positional_index = ref (-1) in - let lookup_positional_arg () = - incr last_positional_index; - match - Fn_arity.Hash.find_opt typ_of_args (Positional !last_positional_index) - with - | Some info -> info - | None -> (Typeutil.unknown_pos, Stype.new_type_var Tvar_error) - in - let lookup_labelled_arg (label : Syntax.label) = - (match Basic_hash_string.find_opt seen_labels label.label_name with - | Some _first_loc -> + ~(is_open : bool) ~(type_name : Typedtree.type_name option) ~tvar_env ~cenv + ~global_env ~diagnostics ~loc = + (let name = constr.constr_name.name in + let cs_tag = constr_desc.cs_tag in + let ty_res, ty_args = Poly_type.instantiate_constr constr_desc in + (if Typeutil.is_tvar (Stype.type_repr expect_ty) then + if Type.is_suberror ty_res then Ctype.unify_exn expect_ty Stype.error + else Ctype.unify_exn expect_ty ty_res + else + try Ctype.unify_exn expect_ty ty_res + with _ -> + if not (Type.is_super_error expect_ty && Type.is_suberror ty_res) then + let expected = Printer.type_to_string expect_ty in + let actual = Printer.type_to_string ty_res in add_error diagnostics - (Errors.duplicated_fn_label ~label:label.label_name - ~second_loc:label.loc_) - | None -> Basic_hash_string.add seen_labels label.label_name label.loc_); - match Fn_arity.Hash.find_opt typ_of_args (Labelled label.label_name) with - | Some typ -> typ - | None -> - add_error diagnostics - (Errors.superfluous_arg_label ~label:label.label_name - ~kind:"constructor" ~loc:label.loc_); - (Typeutil.unknown_pos, Stype.new_type_var Tvar_error) - in - let rec check_args ~pat_binders ~targs_rev - (args : Syntax.constr_pat_arg list) = - match args with - | [] -> - ( pat_binders, - Typedtree.Tpat_constr - { - constr; - args = List.rev targs_rev; - tag = cs_tag; - ty = ty_res; - used_error_subtyping = is_super_error; - loc_ = loc; - } ) - | Constr_pat_arg { pat; kind } :: args -> - let pos, ty = - match kind with - | Positional -> lookup_positional_arg () - | Labelled label - | Labelled_pun label - | Labelled_option { label; _ } - | Labelled_option_pun { label; _ } -> - lookup_labelled_arg label - in - let new_binders, tpat = - check_pat pat ty ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders = - combine_pat_binders ~binders:pat_binders ~new_binders - |> take_info_partial ~diagnostics - in - let targ : Typedtree.constr_pat_arg = - Constr_pat_arg { pat = tpat; kind; pos } - in - check_args ~pat_binders ~targs_rev:(targ :: targs_rev) args - in - let result = check_args ~pat_binders:[] ~targs_rev:[] args in - let () = - let actual = !last_positional_index + 1 in - let expected = Fn_arity.count_positional arity in - if actual <> expected then - add_error diagnostics - (Errors.constr_arity_mismatch ~name:constr.constr_name.name ~expected - ~actual - ~has_label: - ((not (Fn_arity.is_simple arity)) - || Lst.exists args (fun (Constr_pat_arg { pat = _; kind }) -> - match kind with - | Positional -> false - | Labelled_pun _ | Labelled _ | Labelled_option _ - | Labelled_option_pun _ -> - true)) - ~loc) - in - if not is_open then ( - let missing = Vec.empty () in - Fn_arity.iter arity (fun param_kind -> - match param_kind with - | Positional _ | Optional _ | Autofill _ | Question_optional _ -> () - | Labelled { label; _ } -> - if not (Basic_hash_string.mem seen_labels label) then - Vec.push missing label); - if not (Vec.is_empty missing) then - Local_diagnostics.add_warning diagnostics - { - kind = - Omitted_constr_argument - { - labels = Vec.to_list missing; - constr = constr.constr_name.name; - }; - loc; - }); - result - [@@local] - in - match args with - | Some (Constr_pat_arg { pat = Ppat_any _; kind = Positional } :: []) -> - ( [], - Tpat_constr - { - constr; - args = []; - tag = cs_tag; - ty = ty_res; - used_error_subtyping = is_super_error; - loc_ = loc; - } ) - | None -> do_check [] - | Some args -> do_check args + (Errors.constr_unify ~name ~expected ~actual ~loc)); + let is_super_error = Type.is_super_error expect_ty in + let do_check args = + let arity = constr_desc.cs_arity_ in + let typ_of_args = + let pos = ref (-1) in + Fn_arity.to_hashtbl arity ty_args (fun _ -> + fun ty -> + incr pos; + (!pos, ty)) + in + let seen_labels = Basic_hash_string.create 17 in + let last_positional_index = ref (-1) in + let lookup_positional_arg () = + incr last_positional_index; + match + Fn_arity.Hash.find_opt typ_of_args (Positional !last_positional_index) + with + | Some info -> info + | None -> (Typeutil.unknown_pos, Stype.new_type_var Tvar_error) + in + let lookup_labelled_arg (label : Syntax.label) = + (match Basic_hash_string.find_opt seen_labels label.label_name with + | Some _first_loc -> + add_error diagnostics + (Errors.duplicated_fn_label ~label:label.label_name + ~second_loc:label.loc_) + | None -> Basic_hash_string.add seen_labels label.label_name label.loc_); + match Fn_arity.Hash.find_opt typ_of_args (Labelled label.label_name) with + | Some typ -> typ + | None -> + add_error diagnostics + (Errors.superfluous_arg_label ~label:label.label_name + ~kind:"constructor" ~loc:label.loc_); + (Typeutil.unknown_pos, Stype.new_type_var Tvar_error) + in + let rec check_args ~pat_binders ~targs_rev + (args : Syntax.constr_pat_arg list) = + match args with + | [] -> + ( pat_binders, + Typedtree.Tpat_constr + { + type_name; + constr = constr.constr_name; + args = List.rev targs_rev; + tag = cs_tag; + ty = ty_res; + used_error_subtyping = is_super_error; + arity_ = constr_desc.cs_arity_; + all_args_ = ty_args; + loc_ = loc; + } ) + | Constr_pat_arg { pat; kind } :: args -> + let pos, ty = + match kind with + | Positional -> lookup_positional_arg () + | Labelled label + | Labelled_pun label + | Labelled_option { label; _ } + | Labelled_option_pun { label; _ } -> + lookup_labelled_arg label + in + let new_binders, tpat = + check_pat pat ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders = + take_info_partial ~diagnostics + (combine_pat_binders ~binders:pat_binders ~new_binders) + in + let targ : Typedtree.constr_pat_arg = + Constr_pat_arg { pat = tpat; kind; pos } + in + check_args ~pat_binders ~targs_rev:(targ :: targs_rev) args + in + let result = check_args ~pat_binders:[] ~targs_rev:[] args in + let () = + let actual = !last_positional_index + 1 in + let expected = Fn_arity.count_positional arity in + if actual <> expected then + add_error diagnostics + (Errors.constr_arity_mismatch ~name:constr.constr_name.name ~expected + ~actual + ~has_label: + ((not (Fn_arity.is_simple arity)) + || Lst.exists args (fun (Constr_pat_arg { pat = _; kind }) -> + match kind with + | Positional -> false + | Labelled_pun _ | Labelled _ | Labelled_option _ + | Labelled_option_pun _ -> + true)) + ~loc) + in + if not is_open then ( + let missing = Vec.empty () in + Fn_arity.iter arity (fun param_kind -> + match param_kind with + | Positional _ | Optional _ | Autofill _ | Question_optional _ -> () + | Labelled { label; _ } -> + if not (Basic_hash_string.mem seen_labels label) then + Vec.push missing label); + if not (Vec.is_empty missing) then + Local_diagnostics.add_warning diagnostics + { + kind = + Omitted_constr_argument + { + labels = Vec.to_list missing; + constr = constr.constr_name.name; + }; + loc; + }); + result + [@@local] + in + match args with + | Some (Constr_pat_arg { pat = Ppat_any _; kind = Positional } :: []) -> + ( [], + Tpat_constr + { + type_name; + constr = constr.constr_name; + args = []; + tag = cs_tag; + ty = ty_res; + used_error_subtyping = is_super_error; + arity_ = constr_desc.cs_arity_; + all_args_ = ty_args; + loc_ = loc; + } ) + | None -> do_check [] + | Some args -> do_check args + : Typedtree.pat_binders * Typedtree.pat) and check_pat (pat : Syntax.pattern) (ty : Stype.t) ~(tvar_env : Tvar_env.t) - ~(cenv : Poly_type.t) ~(global_env : Global_env.t) ~diagnostics : - Typedtree.pat_binders * Typedtree.pat = - let make_json_pat constr args ~loc = - Json_literal.make_json_pat ~global_env ~diagnostics constr args ~loc - [@@inline] - in - match pat with - | Ppat_alias { pat = p; alias = a; loc_ } -> - let alias = Typeutil.fresh_binder a in - let binders, tp = - check_pat p ty ~tvar_env ~cenv ~global_env ~diagnostics - in - let binder_typ : Stype.t = - match tp with - | Tpat_constr { tag; ty = pat_ty; _ } -> - Type.make_constr_type pat_ty ~tag - | _ -> ty - in - let new_binder : Typedtree.pat_binder = { binder = alias; binder_typ } in - let binders = - add_pat_binder new_binder binders |> take_info_partial ~diagnostics - in - (binders, Tpat_alias { pat = tp; alias; ty; loc_ }) - | Ppat_any { loc_ } -> ([], Tpat_any { ty; loc_ }) - | Ppat_array { pats; loc_; _ } -> - let is_json, ty_array = - if Type.same_type ty Stype.json then - (true, Builtin.type_array Stype.json) - else (false, ty) - in - let ty_elem = - Type.filter_array_like_pattern ty_array loc_ - |> take_info_partial ~diagnostics - in - let go (binders, pat_acc) pat = - let new_binders, tp = - check_pat pat ty_elem ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders = - combine_pat_binders ~new_binders ~binders - |> take_info_partial ~diagnostics - in - (pat_binders, tp :: pat_acc) - in - let pat_binders, pats = - match pats with - | Closed pats -> - let pat_binders, pats = Lst.fold_left pats ([], []) go in - (pat_binders, Typedtree.Closed (List.rev pats)) - | Open (pats1, pats2, dotdot_binder) -> - let pat_binders, pats1 = Lst.fold_left pats1 ([], []) go in - let pat_binders, pats2 = Lst.fold_left pats2 (pat_binders, []) go in - let pat_binders, dotdot_binder = - match dotdot_binder with - | Some binder -> - let binder = Typeutil.fresh_binder binder in - let ty_view = - match get_view_type global_env ty_array with - | Some ty_view -> ty_view - | None -> - let error = - Errors.no_op_as_view - ~ty:(Printer.type_to_string ty_array) - ~loc:(Syntax.loc_of_pattern pat) - in - add_error diagnostics error; - Stype.new_type_var Tvar_error - in - let new_binder : Typedtree.pat_binder = - { binder; binder_typ = ty_view } - in - let pat_binders = - add_pat_binder new_binder pat_binders - |> take_info_partial ~diagnostics - in - (pat_binders, Some (binder, ty_view)) - | None -> (pat_binders, None) - in - (pat_binders, Open (List.rev pats1, List.rev pats2, dotdot_binder)) - in - let array_pat : Typedtree.pat = - Tpat_array { pats; ty = ty_array; loc_ } - in - let result : Typedtree.pat = - if is_json then make_json_pat Json_literal.array [ array_pat ] ~loc:loc_ - else array_pat - in - (pat_binders, result) - | Ppat_constant { c = Const_bool b; loc_ } when Type.same_type ty Stype.json - -> - ( [], - make_json_pat - (if b then Json_literal.true_ else Json_literal.false_) - [] ~loc:loc_ ) - | Ppat_constant { c = Const_string lit; loc_ } - when Type.same_type ty Stype.json -> - let const_pat : Typedtree.pat = - Tpat_constant - { c = C_string lit.string_val; ty = Stype.string; name_ = None; loc_ } - in - ([], make_json_pat Json_literal.string [ const_pat ] ~loc:loc_) - | Ppat_constant { c = Const_int rep | Const_double rep; loc_ } - when Type.same_type ty Stype.json -> - let const_pat : Typedtree.pat = - Tpat_constant - { - c = - Typeutil.typing_constant (Const_double rep) ~expect_ty:None - ~loc:loc_ - |> take_info_partial ~diagnostics - |> snd; - ty = Stype.double; - name_ = None; - loc_; - } - in - ([], make_json_pat Json_literal.number [ const_pat ] ~loc:loc_) - | Ppat_constant { c; loc_ } -> - let actual_ty, c = - Typeutil.typing_constant ~expect_ty:(Some ty) c ~loc:loc_ - |> take_info_partial ~diagnostics - in - Ctype.unify_pat ~expect_ty:ty ~actual_ty loc_ |> store_error ~diagnostics; - ([], Tpat_constant { c; ty; name_ = None; loc_ }) - | Ppat_constr { constr; args; is_open; loc_ } -> ( - let handle_error error = - (match Stype.type_repr ty with - | Tvar { contents = Tnolink Tvar_error } -> () - | _ -> add_error diagnostics error); - let tag = Typeutil.unknown_tag in - let rec infer_args ~pat_binders ~targs_rev args = - match args with - | [] -> - ( pat_binders, - Typedtree.Tpat_constr - { - constr; - args = List.rev targs_rev; - tag; - ty; - used_error_subtyping = false; - loc_; - } ) - | Syntax.Constr_pat_arg { pat; kind } :: args -> - let new_binders, tpat = - check_pat pat - (Stype.new_type_var Tvar_error) - ~tvar_env ~cenv ~global_env ~diagnostics - in - let targ : Typedtree.constr_pat_arg = - Constr_pat_arg { pat = tpat; kind; pos = Typeutil.unknown_pos } - in - let pat_binders = - combine_pat_binders ~binders:pat_binders ~new_binders - |> take_info_partial ~diagnostics - in - infer_args ~pat_binders ~targs_rev:(targ :: targs_rev) args - in - let args = match args with None -> [] | Some args -> args in - infer_args ~pat_binders:[] ~targs_rev:[] args - [@@local] - in - match - Global_env.resolve_constr_or_constant global_env ~expect_ty:(Some ty) - ~constr ~creating_value:false - with - | Ok (`Constr constr_desc) -> - check_constr_pat constr args constr_desc ty ~is_open ~tvar_env ~cenv - ~global_env ~diagnostics ~loc:loc_ - | Ok (`Constant _) when Option.is_some args -> - handle_error - (Errors.constant_pat_with_args ~name:constr.constr_name.name - ~loc:constr.loc_) - | Ok (`Constant { id; kind; typ; _ }) -> ( - Ctype.unify_pat ~expect_ty:ty ~actual_ty:typ loc_ - |> store_error ~diagnostics; - match kind with - | Const c -> - ( [], - Tpat_constant - { - c; - ty; - name_ = Some { var_id = I.of_qual_ident id; loc_ }; - loc_; - } ) - | Normal | Prim _ -> ([], Tpat_any { ty; loc_ })) - | Error error -> handle_error error) - | Ppat_constraint { pat = p; ty = te; loc_ } -> - let ty' = - Typeutil.typing_type ~allow_private:true te ~tvar_env ~is_toplevel:false - ~types:(Global_env.get_all_types global_env) - |> take_info_partial ~diagnostics - in - let stype' = Typedtree_util.stype_of_typ ty' in - let pat_binders, tp = - check_pat p stype' ~tvar_env ~cenv ~global_env ~diagnostics - in - Ctype.unify_pat ~expect_ty:ty ~actual_ty:stype' loc_ - |> store_error ~diagnostics; - ( pat_binders, - Tpat_constraint { pat = tp; konstraint = ty'; ty = stype'; loc_ } ) - | Ppat_or { pat1; pat2; loc_ } -> - let pat_binders1, tp1 = - check_pat pat1 ty ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders2, tp2 = - check_pat pat2 ty ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders = - merge_pat_binders pat_binders1 pat_binders2 - |> take_info_partial ~diagnostics - in - ( pat_binders, - Tpat_or - { pat1 = tp1; pat2 = Or_pat.rename_pat tp2 pat_binders1; ty; loc_ } ) - | Ppat_tuple { pats; loc_ } -> - let arity = List.length pats in - let go (binders, pat_acc) pat pat_ty = - let new_binders, tp = - check_pat pat pat_ty ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders = - combine_pat_binders ~new_binders ~binders - |> take_info_partial ~diagnostics - in - (pat_binders, tp :: pat_acc) - in - let ty_tuple = - Type.filter_product ~blame:Filter_itself ~arity:(Some arity) ty loc_ - |> take_info_partial ~diagnostics - in - let pat_binders, tps = List.fold_left2 go ([], []) pats ty_tuple in - (pat_binders, Tpat_tuple { pats = List.rev tps; ty; loc_ }) - | Ppat_var v -> - let binder = Typeutil.fresh_binder v in - let new_binder : Typedtree.pat_binder = { binder; binder_typ = ty } in - ([ new_binder ], Tpat_var { binder; ty; loc_ = binder.loc_ }) - | Ppat_record { fields; loc_; is_closed } -> ( - if Typeutil.is_tvar ty then - infer_record_pat fields ty is_closed ~tvar_env ~cenv ~global_env - ~diagnostics ~loc:loc_ - else - match - Global_env.labels_of_record global_env ty ~loc:loc_ ~context:`Pattern - with - | Ok labels -> - let _, labels = - Poly_type.instantiate_record ~ty_record:(`Known ty) labels - in - type_guided_record_pat_check fields labels is_closed ty ~tvar_env - ~cenv ~global_env ~diagnostics ~loc:loc_ - | Error error -> - let ty = Stype.new_type_var Tvar_error in - add_error diagnostics error; - let pat_binders, fields_rev = - Lst.fold_left fields ([], []) - (fun - (pat_binders_acc, fields_rev) - (Field_pat { label; pattern; is_pun }) - -> - let ty = Stype.new_type_var Tvar_error in - let pat_binders, pat = - check_pat pattern ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - ( pat_binders @ pat_binders_acc, - Typedtree.Field_pat - { label; pat; is_pun; pos = Typeutil.unknown_pos } - :: fields_rev )) - in - ( pat_binders, - Tpat_record { fields = List.rev fields_rev; ty; loc_; is_closed } - )) - | Ppat_map { elems; loc_ } -> - let is_json, ty_map = - if Type.same_type ty Stype.json then - (true, Builtin.type_map Stype.string Stype.json) - else (false, ty) - in - let ty_key, ty_value, op_get_info_ = - match - get_key_value_type ~global_env ~cenv ~tvar_env ty_map ~loc:loc_ - with - | Ok result -> result - | Error err -> - add_error diagnostics err; - ( Stype.new_type_var Tvar_error, - Builtin.type_option (Stype.new_type_var Tvar_error), - (I.fresh "op_get", Stype.new_type_var Tvar_error, [||]) ) - in - let rec check_elems pat_binders (elems : Syntax.map_pat_elem list) = - match elems with - | [] -> (pat_binders, []) - | Map_pat_elem { key; pat; match_absent; key_loc_; loc_ } :: elems -> - let pat : Syntax.pattern = - if match_absent then pat - else - Ppat_constr - { - constr = - { - constr_name = { name = "Some"; loc_ = Rloc.no_location }; - extra_info = No_extra_info; - loc_ = Rloc.no_location; - }; - args = Some [ Constr_pat_arg { pat; kind = Positional } ]; - is_open = false; - loc_; - } - in - let actual_ty_key, key = - Typeutil.typing_constant ~expect_ty:(Some ty_key) ~loc:key_loc_ - key - |> take_info_partial ~diagnostics - in - Ctype.unify_pat ~expect_ty:ty_key ~actual_ty:actual_ty_key key_loc_ - |> store_error ~diagnostics; - let new_binders, tpat = - check_pat pat ty_value ~tvar_env ~cenv ~global_env ~diagnostics - in - let pat_binders = - combine_pat_binders ~new_binders ~binders:pat_binders - |> take_info_partial ~diagnostics - in - let pat_binders, elems = check_elems pat_binders elems in - (pat_binders, (key, tpat) :: elems) - in - let pat_binders, elems = check_elems [] elems in - let result : Typedtree.pat = - let map_pat : Typedtree.pat = - Tpat_map { elems; ty = ty_map; op_get_info_; loc_ } - in - if is_json then make_json_pat Json_literal.object_ [ map_pat ] ~loc:loc_ - else map_pat - in - (pat_binders, result) - | Ppat_range { lhs; rhs; inclusive; loc_ } -> - let _, tlhs = check_pat lhs ty ~tvar_env ~cenv ~global_env ~diagnostics in - let _, trhs = check_pat rhs ty ~tvar_env ~cenv ~global_env ~diagnostics in - let invalid_type () = - add_error diagnostics - (Errors.range_pattern_unsupported_type - ~ty:(Printer.type_to_string ty) - ~loc:loc_) - [@@local] - in - (match Stype.type_repr ty with - | T_builtin b -> ( - match b with - | T_byte | T_char | T_int | T_int64 | T_uint | T_uint64 -> () - | T_float | T_double | T_unit | T_bool | T_bytes | T_string -> - invalid_type ()) - | _ -> invalid_type ()); - (match (tlhs, trhs) with - | Tpat_constant { c = c1; _ }, Tpat_constant { c = c2; _ } -> ( - match Constant.eval_compare c1 c2 with - | Some compare_result -> - if compare_result > 0 || (compare_result = 0 && not inclusive) - then - add_error diagnostics - (Errors.range_pattern_invalid_range ~inclusive ~loc:loc_) - | None -> ()) - | _ -> ()); - ([], Tpat_range { lhs = tlhs; rhs = trhs; inclusive; ty; loc_ }) + ~(cenv : Poly_type.t) ~(global_env : Global_env.t) ~diagnostics = + (let make_json_pat constr args ~loc = + Json_literal.make_json_pat ~global_env ~diagnostics constr args ~loc + [@@inline] + in + match pat with + | Ppat_alias { pat = p; alias = a; loc_ } -> + let alias = Typeutil.fresh_binder a in + let binders, tp = + check_pat p ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let binder_typ : Stype.t = + match tp with + | Tpat_constr { tag; ty = pat_ty; _ } + when not (Global_env.is_newtype global_env pat_ty) -> + Type.make_constr_type pat_ty ~tag + | _ -> ty + in + let new_binder : Typedtree.pat_binder = { binder = alias; binder_typ } in + let binders = + take_info_partial ~diagnostics (add_pat_binder new_binder binders) + in + (binders, Tpat_alias { pat = tp; alias; ty; loc_ }) + | Ppat_any { loc_ } -> ([], Tpat_any { ty; loc_ }) + | Ppat_array { pats; loc_; _ } -> + let is_json, ty_array = + if Type.same_type ty Stype.json then + (true, Builtin.type_array Stype.json) + else (false, ty) + in + let ty_elem = + take_info_partial ~diagnostics + (Type.filter_array_like_pattern ty_array loc_) + in + let go (binders, pat_acc) (pat : Syntax.array_pattern) = + let break_string_literal str name_ = + let v = Basic_utf8.from_string str in + Basic_vec_int.map_into_list + ~unorder:(fun i -> + Typedtree.Tpat_constant + { c = C_char (Uchar.of_int i); ty = Stype.char; name_; loc_ }) + v + in + match pat with + | Pattern pat -> + let new_binders, tp = + check_pat pat ty_elem ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders = + take_info_partial ~diagnostics + (combine_pat_binders ~new_binders ~binders) + in + (pat_binders, tp :: pat_acc) + | String_spread str -> + store_error ~diagnostics + (Ctype.unify_pat ~expect_ty:Stype.char ~actual_ty:ty_elem loc_); + let ps = break_string_literal str.string_val None in + (binders, List.rev_append ps pat_acc) + | String_spread_const { binder; pkg; loc_ } -> ( + let name_ : Typedtree.var option = + match pkg with + | None -> + Some + { + var_id = + I.of_qual_ident + (Basic_qual_ident.make + ~pkg:!Basic_config.current_package + ~name:binder.binder_name); + loc_; + } + | Some _ -> None + in + match + Typeutil.resolve_constant ~global_env ~pkg ~constant_name:binder + ~loc:loc_ ~diagnostics + with + | Some c -> ( + match c.kind with + | Const (C_string str) -> + let ps = break_string_literal str name_ in + (binders, List.rev_append ps pat_acc) + | Const const -> + Local_diagnostics.add_error diagnostics + (Errors.type_mismatch ~expected:"String" + ~actual:(Printer.type_to_string c.typ) + ~loc:loc_); + ( binders, + Tpat_constant { c = const; ty = c.typ; name_; loc_ } + :: pat_acc ) + | Normal | Prim _ -> assert false) + | None -> (binders, pat_acc)) + in + let pat_binders, pats = + match pats with + | Closed pats -> + let pat_binders, pats = Lst.fold_left pats ([], []) go in + (pat_binders, Typedtree.Closed (List.rev pats)) + | Open (pats1, pats2, dotdot_binder) -> + let pat_binders, pats1 = Lst.fold_left pats1 ([], []) go in + let pat_binders, pats2 = + Lst.fold_left pats2 (pat_binders, []) go + in + let pat_binders, dotdot_binder = + match dotdot_binder with + | Some binder -> + let binder = Typeutil.fresh_binder binder in + let ty_view = + match get_view_type global_env ty_array with + | Some ty_view -> ty_view + | None -> + let error = + Errors.no_op_as_view + ~ty:(Printer.type_to_string ty_array) + ~loc:(Syntax.loc_of_pattern pat) + in + add_error diagnostics error; + Stype.new_type_var Tvar_error + in + let new_binder : Typedtree.pat_binder = + { binder; binder_typ = ty_view } + in + let pat_binders = + take_info_partial ~diagnostics + (add_pat_binder new_binder pat_binders) + in + (pat_binders, Some (binder, ty_view)) + | None -> (pat_binders, None) + in + (pat_binders, Open (List.rev pats1, List.rev pats2, dotdot_binder)) + in + let array_pat : Typedtree.pat = + Tpat_array { pats; ty = ty_array; loc_ } + in + let result : Typedtree.pat = + if is_json then + make_json_pat Json_literal.array [ array_pat ] ~loc:loc_ + else array_pat + in + (pat_binders, result) + | Ppat_constant { c = Const_bool b; loc_ } when Type.same_type ty Stype.json + -> + ( [], + make_json_pat + (if b then Json_literal.true_ else Json_literal.false_) + [] ~loc:loc_ ) + | Ppat_constant { c = Const_string lit; loc_ } + when Type.same_type ty Stype.json -> + let const_pat : Typedtree.pat = + Tpat_constant + { + c = C_string lit.string_val; + ty = Stype.string; + name_ = None; + loc_; + } + in + ([], make_json_pat Json_literal.string [ const_pat ] ~loc:loc_) + | Ppat_constant { c = Const_int rep | Const_double rep; loc_ } + when Type.same_type ty Stype.json -> + let const_pat : Typedtree.pat = + Tpat_constant + { + c = + snd + (Typeutil.typing_constant (Const_double rep) ~expect_ty:None + ~loc:loc_ ~diagnostics); + ty = Stype.double; + name_ = None; + loc_; + } + in + ([], make_json_pat Json_literal.number [ const_pat ] ~loc:loc_) + | Ppat_constant { c; loc_ } -> + let actual_ty, c = + Typeutil.typing_constant ~expect_ty:(Some ty) c ~loc:loc_ ~diagnostics + in + store_error ~diagnostics (Ctype.unify_pat ~expect_ty:ty ~actual_ty loc_); + ([], Tpat_constant { c; ty; name_ = None; loc_ }) + | Ppat_constr { constr; args; is_open; loc_ } -> ( + let handle_error type_name = + let tag = Typeutil.unknown_tag in + let rec infer_args ~type_name ~pat_binders ~targs_rev args = + match args with + | [] -> + let args = List.rev targs_rev in + ( pat_binders, + Typedtree.Tpat_constr + { + type_name; + constr = constr.constr_name; + args; + tag; + ty; + used_error_subtyping = false; + arity_ = Fn_arity.simple (List.length args); + all_args_ = + Lst.map args (fun (Constr_pat_arg { pat; _ }) -> + Typedtree_util.type_of_pat pat); + loc_; + } ) + | Syntax.Constr_pat_arg { pat; kind } :: args -> + let new_binders, tpat = + check_pat pat + (Stype.new_type_var Tvar_error) + ~tvar_env ~cenv ~global_env ~diagnostics + in + let targ : Typedtree.constr_pat_arg = + Constr_pat_arg { pat = tpat; kind; pos = Typeutil.unknown_pos } + in + let pat_binders = + take_info_partial ~diagnostics + (combine_pat_binders ~binders:pat_binders ~new_binders) + in + infer_args ~type_name ~pat_binders ~targs_rev:(targ :: targs_rev) + args + in + let args = match args with None -> [] | Some args -> args in + infer_args ~type_name ~pat_binders:[] ~targs_rev:[] args + [@@local] + in + match + Typeutil.resolve_constr_or_constant ~global_env ~tvar_env + ~expect_ty:(Some ty) ~constr ~creating_value:false ~diagnostics + with + | Some (`Constr constr_desc), type_name -> + check_constr_pat constr args constr_desc ty ~is_open ~type_name + ~tvar_env ~cenv ~global_env ~diagnostics ~loc:loc_ + | Some (`Constant _), type_name + when match args with Some _ -> true | _ -> false -> + (match Stype.type_repr ty with + | Tvar { contents = Tnolink Tvar_error } -> () + | _ -> + add_error diagnostics + (Errors.constant_pat_with_args ~name:constr.constr_name.name + ~loc:constr.loc_)); + handle_error type_name + | Some (`Constant { id; kind; typ; _ }), _ -> ( + store_error ~diagnostics + (Ctype.unify_pat ~expect_ty:ty ~actual_ty:typ loc_); + match kind with + | Const c -> + ( [], + Tpat_constant + { + c; + ty; + name_ = Some { var_id = I.of_qual_ident id; loc_ }; + loc_; + } ) + | Normal | Prim _ -> ([], Tpat_any { ty; loc_ })) + | None, type_name -> handle_error type_name) + | Ppat_constraint { pat = p; ty = te; loc_ } -> + let ty' = + Typeutil.typing_type ~allow_private:true te ~tvar_env + ~allow_partial:true + ~types:(Global_env.get_all_types global_env) + ~local_type_env:(Global_env.get_cur_local_type_env global_env) + ~diagnostics + in + let stype' = Typedtree_util.stype_of_typ ty' in + let pat_binders, tp = + check_pat p stype' ~tvar_env ~cenv ~global_env ~diagnostics + in + store_error ~diagnostics + (Ctype.unify_pat ~expect_ty:ty ~actual_ty:stype' loc_); + ( pat_binders, + Tpat_constraint { pat = tp; konstraint = ty'; ty = stype'; loc_ } ) + | Ppat_or { pat1; pat2; loc_ } -> + let pat_binders1, tp1 = + check_pat pat1 ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders2, tp2 = + check_pat pat2 ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders = + take_info_partial ~diagnostics + (merge_pat_binders pat_binders1 pat_binders2) + in + ( pat_binders, + Tpat_or + { pat1 = tp1; pat2 = Or_pat.rename_pat tp2 pat_binders1; ty; loc_ } + ) + | Ppat_tuple { pats; loc_ } -> + let arity = List.length pats in + let go (binders, pat_acc) pat pat_ty = + let new_binders, tp = + check_pat pat pat_ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders = + take_info_partial ~diagnostics + (combine_pat_binders ~new_binders ~binders) + in + (pat_binders, tp :: pat_acc) + in + let ty_tuple = + take_info_partial ~diagnostics + (Type.filter_product ~blame:Filter_itself ~arity:(Some arity) ty loc_) + in + let pat_binders, tps = List.fold_left2 go ([], []) pats ty_tuple in + (pat_binders, Tpat_tuple { pats = List.rev tps; ty; loc_ }) + | Ppat_var v -> + let binder = Typeutil.fresh_binder v in + let new_binder : Typedtree.pat_binder = { binder; binder_typ = ty } in + ([ new_binder ], Tpat_var { binder; ty; loc_ = binder.loc_ }) + | Ppat_record { fields = []; is_closed; loc_ } -> ( + let default () = + ((match + get_key_value_type ~global_env ~cenv ~tvar_env ty ~loc:loc_ + with + | Error e -> add_error diagnostics e + | Ok _ -> + if is_closed then + Local_diagnostics.add_warning diagnostics + { kind = Closed_map_pattern; loc = loc_ }); + ([], Tpat_any { ty; loc_ }) + : Typedtree.pat_binders * Typedtree.pat) + in + match Stype.type_repr ty with + | T_constr { type_constructor; tys = []; _ } + when Type_path.equal type_constructor Type_path.Builtin.type_path_json + -> + ([], make_json_pat Json_literal.object_ [] ~loc:loc_) + | T_constr { type_constructor; _ } -> ( + match fields_of_struct ~global_env type_constructor with + | None -> default () + | Some [] -> + if not is_closed then + add_error diagnostics (Errors.record_pattern_only_dotdot loc_); + ([], Tpat_record { fields = []; ty; loc_; is_closed = true }) + | Some labels -> + if is_closed then + Local_diagnostics.add_error diagnostics + (Errors.missing_fields_in_record ~labels + ~ty:(Printer.type_to_string ty) + ~context:`Pattern ~loc:loc_) + else + add_error diagnostics (Errors.record_pattern_only_dotdot loc_); + ([], Tpat_record { fields = []; ty; loc_; is_closed = true })) + | _ -> default ()) + | Ppat_record { fields; loc_; is_closed } -> ( + if Typeutil.is_tvar ty then + infer_record_pat fields ty is_closed ~tvar_env ~cenv ~global_env + ~diagnostics ~loc:loc_ + else + match + Global_env.labels_of_record global_env ty ~loc:loc_ ~context:`Pattern + with + | Ok labels -> + let _, labels = + Poly_type.instantiate_record ~ty_record:(`Known ty) labels + in + type_guided_record_pat_check fields labels is_closed ty ~tvar_env + ~cenv ~global_env ~diagnostics ~loc:loc_ + | Error error -> + let ty = Stype.new_type_var Tvar_error in + add_error diagnostics error; + let pat_binders, fields_rev = + Lst.fold_left fields ([], []) + (fun (pat_binders_acc, fields_rev) -> + fun (Field_pat { label; pattern; is_pun }) -> + let ty = Stype.new_type_var Tvar_error in + let pat_binders, pat = + check_pat pattern ty ~tvar_env ~cenv ~global_env + ~diagnostics + in + ( pat_binders @ pat_binders_acc, + Typedtree.Field_pat + { label; pat; is_pun; pos = Typeutil.unknown_pos } + :: fields_rev )) + in + ( pat_binders, + Tpat_record { fields = List.rev fields_rev; ty; loc_; is_closed } + )) + | Ppat_map { elems; is_closed; loc_ } -> + if is_closed then + Local_diagnostics.add_warning diagnostics + { kind = Closed_map_pattern; loc = loc_ }; + let is_json, ty_map = + if Type.same_type ty Stype.json then + (true, Builtin.type_map Stype.string Stype.json) + else (false, ty) + in + let ty_key, ty_value, op_get_info_ = + match + get_key_value_type ~global_env ~cenv ~tvar_env ty_map ~loc:loc_ + with + | Ok result -> result + | Error err -> + add_error diagnostics err; + ( Stype.new_type_var Tvar_error, + Builtin.type_option (Stype.new_type_var Tvar_error), + (I.fresh "op_get", Stype.new_type_var Tvar_error, [||]) ) + in + let rec check_elems pat_binders (elems : Syntax.map_pat_elem list) = + match elems with + | [] -> (pat_binders, []) + | Map_pat_elem { key; pat; match_absent; key_loc_; loc_ } :: elems -> + let pat : Syntax.pattern = + if match_absent then pat + else + Ppat_constr + { + constr = + { + constr_name = + { name = "Some"; loc_ = Rloc.no_location }; + extra_info = No_extra_info; + loc_ = Rloc.no_location; + }; + args = Some [ Constr_pat_arg { pat; kind = Positional } ]; + is_open = false; + loc_; + } + in + let actual_ty_key, key = + Typeutil.typing_constant ~expect_ty:(Some ty_key) ~loc:key_loc_ + key ~diagnostics + in + store_error ~diagnostics + (Ctype.unify_pat ~expect_ty:ty_key ~actual_ty:actual_ty_key + key_loc_); + let new_binders, tpat = + check_pat pat ty_value ~tvar_env ~cenv ~global_env ~diagnostics + in + let pat_binders = + take_info_partial ~diagnostics + (combine_pat_binders ~new_binders ~binders:pat_binders) + in + let pat_binders, elems = check_elems pat_binders elems in + (pat_binders, (key, tpat) :: elems) + in + let pat_binders, elems = check_elems [] elems in + let result : Typedtree.pat = + let map_pat : Typedtree.pat = + Tpat_map { elems; ty = ty_map; op_get_info_; loc_ } + in + if is_json then + make_json_pat Json_literal.object_ [ map_pat ] ~loc:loc_ + else map_pat + in + (pat_binders, result) + | Ppat_range { lhs; rhs; inclusive; loc_ } -> + let _, tlhs = + check_pat lhs ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let _, trhs = + check_pat rhs ty ~tvar_env ~cenv ~global_env ~diagnostics + in + let invalid_type () = + add_error diagnostics + (Errors.range_pattern_unsupported_type + ~ty:(Printer.type_to_string ty) + ~loc:loc_) + [@@local] + in + (match Stype.type_repr ty with + | T_builtin b -> ( + match b with + | T_byte | T_int16 | T_uint16 | T_char | T_int | T_int64 | T_uint + | T_uint64 -> + () + | T_float | T_double | T_unit | T_bool | T_bytes | T_string -> + invalid_type ()) + | _ -> invalid_type ()); + (match (tlhs, trhs) with + | Tpat_constant { c = c1; _ }, Tpat_constant { c = c2; _ } -> ( + match Constant.eval_compare c1 c2 with + | Some compare_result -> + if compare_result > 0 || (compare_result = 0 && not inclusive) + then + add_error diagnostics + (Errors.range_pattern_invalid_range ~inclusive ~loc:loc_) + | None -> ()) + | _ -> ()); + ([], Tpat_range { lhs = tlhs; rhs = trhs; inclusive; ty; loc_ }) + : Typedtree.pat_binders * Typedtree.pat) diff --git a/src/pkg.ml b/src/pkg.ml index 3b40461..2ed1002 100644 --- a/src/pkg.ml +++ b/src/pkg.ml @@ -17,9 +17,10 @@ module Import_path = Parsing_import_path module Longident = Basic_longident module H = Basic_hash_string module Lst = Basic_lst +module Vec = Basic_vec module Type_path = Basic_type_path -module Arr = Basic_arr module Hash_string = Basic_hash_string +module Hashset_string = Basic_hashset_string type pkg_tbl_entry = Pkg_info.mi_view option lazy_t @@ -77,7 +78,8 @@ include struct alias_to = alias_to__013_; direct_uses = direct_uses__015_; loc = loc__017_; - } -> + } + -> let bnds__008_ = ([] : _ Stdlib.List.t) in let bnds__008_ = let arg__018_ = Loc.sexp_of_t loc__017_ in @@ -265,42 +267,34 @@ let load_std pkgs ~std_path ~diagnostics = in load_dir ~pkg_path:"" std_path -type find_value_result = - | Not_exist - | Found_value of Value_info.toplevel - | Found_method of (Type_path.t * Method_env.method_info) list - -let find_value_in_mi_view ~allow_method (mi_view : Pkg_info.mi_view) id : - find_value_result = - let p = mi_view in - match - Arr.find_map p.values (fun ((x : string), vd) -> - if x = id then Some vd else None) - with - | Some vd -> Found_value vd - | None -> - if allow_method then - Found_method - (Method_env.find_methods_by_name p.method_env ~method_name:id) - else Not_exist +let find_value_in_mi_view (mi_view : Pkg_info.mi_view) id = + (let p = mi_view in + Hash_string.find_opt p.values id + : Value_info.toplevel option) -let find_value ~allow_method (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) - ~loc : Value_info.t Local_diagnostics.info = - match find_pkg_opt tbl ~pkg with - | Some p -> ( - match find_value_in_mi_view ~allow_method p id with - | Found_value vd -> Ok (Toplevel_value vd) - | Found_method ms -> ( - match ms with - | [] -> Error (Errors.unbound_value ~name:(Ldot { pkg; id }) ~loc) - | (_, m) :: [] -> Ok (Method_env.to_value_info m) - | ms -> - let type_locs = - Lst.map ms (fun (type_name, m) -> (type_name, m.loc)) - in - Error (Errors.ambiguous_method ~name:id ~type_locs ~loc)) - | Not_exist -> Error (Errors.unbound_value ~name:(Ldot { pkg; id }) ~loc)) - | None -> Error (Errors.pkg_not_loaded ~pkg ~loc) +let find_value (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) ~loc + ~diagnostics = + (let error err = + Local_diagnostics.add_error diagnostics err; + None + [@@local] + in + match find_pkg_opt tbl ~pkg with + | Some p -> ( + match find_value_in_mi_view p id with + | Some vd -> Some (Toplevel_value vd) + | None -> error (Errors.unbound_value ~name:(Ldot { pkg; id }) ~loc)) + | None -> error (Errors.pkg_not_loaded ~pkg ~loc) + : Value_info.t option) + +let find_value_in_builtin_package (tbl : pkg_tbl) name = + (match find_pkg_opt tbl ~pkg:Basic_config.builtin_package with + | Some p -> ( + match find_value_in_mi_view p name with + | Some vd -> Some (Toplevel_value vd) + | None -> None) + | None -> None + : Value_info.t option) let find_constructor_or_constant (tbl : pkg_tbl) ~pkg constr_name ~loc = match find_pkg_opt tbl ~pkg with @@ -309,53 +303,60 @@ let find_constructor_or_constant (tbl : pkg_tbl) ~pkg constr_name ~loc = | Some (constr :: []) -> Ok (`Constr constr) | Some (c1 :: c2 :: _) -> let first_ty = - c1.cs_res |> Stype.extract_tpath_exn |> Type_path_util.name + Type_path_util.name (Stype.extract_tpath_exn c1.cs_res) in let second_ty = - c2.cs_res |> Stype.extract_tpath_exn |> Type_path_util.name + Type_path_util.name (Stype.extract_tpath_exn c2.cs_res) in Error (Errors.ambiguous_constructor ~name:constr_name ~first_ty ~second_ty ~loc) | None | Some [] -> ( - match find_value_in_mi_view ~allow_method:false p constr_name with - | Found_value c -> Ok (`Constant c) - | Found_method _ -> assert false - | Not_exist -> + match find_value_in_mi_view p constr_name with + | Some c -> Ok (`Constant c) + | None -> Error (Errors.constr_not_found ~ty:None ~constr:constr_name ~loc)) ) | None -> Error (Errors.pkg_not_loaded ~pkg ~loc) -let find_method_opt (tbl : pkg_tbl) ~pkg ~type_name ~method_name : - Method_env.method_table_entry option = - match find_pkg_opt tbl ~pkg with - | Some p -> Method_env.find_method_opt p.method_env ~type_name ~method_name - | None -> None - -let find_regular_method (tbl : pkg_tbl) ~pkg ~type_name ~method_name : - Method_env.method_info option = - match find_pkg_opt tbl ~pkg with - | Some p -> - Method_env.find_regular_method p.method_env ~type_name ~method_name - | None -> None - -let find_methods_by_name (tbl : pkg_tbl) ~pkg ~method_name : - (Type_path.t * Method_env.method_info) list = +let find_constant (tbl : pkg_tbl) ~pkg ~constant_name ~loc ~diagnostics = match find_pkg_opt tbl ~pkg with - | Some p -> Method_env.find_methods_by_name p.method_env ~method_name - | None -> [] + | Some p -> ( + match find_value_in_mi_view p constant_name with + | Some c -> Some c + | None -> + Local_diagnostics.add_error diagnostics + (Errors.constant_not_found ~name:constant_name ~loc); + None) + | None -> + Local_diagnostics.add_error diagnostics (Errors.pkg_not_loaded ~pkg ~loc); + None + +let find_method_opt (tbl : pkg_tbl) ~pkg ~type_name ~method_name = + (match find_pkg_opt tbl ~pkg with + | Some p -> Method_env.find_method_opt p.method_env ~type_name ~method_name + | None -> None + : Method_env.method_table_entry option) + +let find_regular_method (tbl : pkg_tbl) ~pkg ~type_name ~method_name = + (match find_pkg_opt tbl ~pkg with + | Some p -> + Method_env.find_regular_method p.method_env ~type_name ~method_name + | None -> None + : Method_env.method_info option) let iter_methods_by_type (tbl : pkg_tbl) ~pkg ~type_name f = match find_pkg_opt tbl ~pkg with | Some p -> Method_env.iter_methods_by_type p.method_env ~type_name f | None -> () -let find_ext_method_opt (tbl : pkg_tbl) ~pkg ~trait ~self_type ~method_name : - Ext_method_env.method_info option = - match find_pkg_opt tbl ~pkg with - | None -> None - | Some p -> - Ext_method_env.find_method p.ext_method_env ~trait ~self_type ~method_name +let find_ext_method_opt (tbl : pkg_tbl) ~pkg ~trait ~self_type ~method_name = + (match find_pkg_opt tbl ~pkg with + | None -> None + | Some p -> + Ext_method_env.find_method p.ext_method_env ~trait ~self_type + ~method_name + : Ext_method_env.method_info option) let find_trait_impl (tbl : pkg_tbl) ~pkg ~trait ~type_name = match find_pkg_opt tbl ~pkg with @@ -367,62 +368,42 @@ let find_type_alias (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) = | None -> None | Some p -> Hash_string.find_opt p.external_type_alias id -let find_type (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) ~loc : - Typedecl_info.t Local_diagnostics.info = - match find_pkg_opt tbl ~pkg with - | Some p -> ( - match - Array.find_map - (fun (name, td) -> if id = name then Some td else None) - p.external_types - with - | Some td -> Ok td - | None -> Error (Errors.unbound_type ~name:(Ldot { pkg; id }) ~loc)) - | None -> Error (Errors.pkg_not_loaded ~pkg ~loc) - -let find_trait (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) ~loc : - Trait_decl.t Local_diagnostics.info = - match find_pkg_opt tbl ~pkg with - | Some p -> ( - match - Array.find_map - (fun (name, trait) -> if id = name then Some trait else None) - p.external_traits - with - | Some trait -> Ok trait - | None -> Error (Errors.unbound_trait ~name:(Ldot { pkg; id }) ~loc)) - | None -> Error (Errors.pkg_not_loaded ~pkg ~loc) +let find_trait (tbl : pkg_tbl) ({ pkg; id } : Longident.qual_name) ~loc = + (match find_pkg_opt tbl ~pkg with + | Some p -> ( + match Hash_string.find_opt p.external_traits id with + | Some trait -> Ok trait + | None -> Error (Errors.unbound_trait ~name:(Ldot { pkg; id }) ~loc)) + | None -> Error (Errors.pkg_not_loaded ~pkg ~loc) + : Trait_decl.t Local_diagnostics.info) let find_type_or_trait (tbl : pkg_tbl) ~pkg id ~loc = match find_pkg_opt tbl ~pkg with | Some p -> ( - match - Array.find_map - (fun (name, td) -> if id = name then Some td else None) - p.external_types - with + match Hash_string.find_opt p.external_types id with | Some td -> `Type td | None -> ( - match - Array.find_map - (fun (name, trait) -> if id = name then Some trait else None) - p.external_traits - with + match Hash_string.find_opt p.external_traits id with | Some trait -> `Trait trait | None -> `Error (Errors.unbound_type_or_trait ~name:(Ldot { pkg; id }) ~loc))) | None -> `Error (Errors.pkg_not_loaded ~pkg ~loc) +let find_type_or_trait_in_builtin (tbl : pkg_tbl) id = + match find_pkg_opt tbl ~pkg:Basic_config.builtin_package with + | Some p -> ( + match Hash_string.find_opt p.external_types id with + | Some td -> `Type td + | None -> ( + match Hash_string.find_opt p.external_traits id with + | Some trait -> `Trait trait + | None -> `Not_found)) + | None -> `Not_found + let find_type_opt (tbl : pkg_tbl) ~pkg id = match find_pkg_opt tbl ~pkg with - | Some p -> - let type_ = - Array.find_map - (fun (name, td) -> if id = name then Some td else None) - p.external_types - in - type_ + | Some p -> Hash_string.find_opt p.external_types id | None -> None let iter (tbl : pkg_tbl) f = @@ -430,21 +411,21 @@ let iter (tbl : pkg_tbl) f = match pkg_info with Some pkg_info -> f (name, pkg_info) | None -> ()) let load_direct_uses (tbl : pkg_tbl) (values : Typing_info.values) - (type_alias : Typedecl_info.alias Hash_string.t) - ~(diagnostics : Diagnostics.t) = - let use_all_mi = Basic_vec.empty () in + (type_alias : Type_alias.t Hash_string.t) + ~(impls : Parsing_syntax.impl list) ~(diagnostics : Diagnostics.t) = + let use_all_mi = Vec.empty () in H.iter tbl (fun (pkg, { mi_info; direct_uses; _ }) -> match direct_uses with | Direct_use_all -> ( match mi_info with | (lazy None) -> () - | (lazy (Some mi_view)) -> Basic_vec.push use_all_mi mi_view) + | (lazy (Some mi_view)) -> Vec.push use_all_mi mi_view) | Values [] -> () | Values direct_uses -> ( match mi_info with | (lazy None) -> () | (lazy (Some mi_view)) -> - Lst.iter direct_uses (fun (id, loc) -> + Lst.iter direct_uses ~f:(fun (id, loc) -> match Typing_info.find_value values id with | Some vd -> ( match[@warning "-fragile-match"] vd.direct_use_loc_ with @@ -458,113 +439,108 @@ let load_direct_uses (tbl : pkg_tbl) (values : Typing_info.values) Diagnostics.add_error diagnostics (Errors.direct_use_not_found ~pkg ~id ~loc) in - match - find_value_in_mi_view ~allow_method:true mi_view id - with - | Found_value vd -> + match find_value_in_mi_view mi_view id with + | Some vd -> Typing_info.add_value values { vd with direct_use_loc_ = Explicit_import loc } - | Found_method ms -> ( - match ms with - | [] -> not_found () - | (_, m) :: [] -> ( - match[@warning "-fragile-match"] - Method_env.to_value_info m - with - | Toplevel_value v -> - Typing_info.add_value values - { - v with - direct_use_loc_ = Explicit_import loc; - } - | _ -> assert false) - | ms -> - let type_locs = - Lst.map ms (fun (type_name, m) -> - (type_name, m.loc)) - in - Diagnostics.add_error diagnostics - (Errors.direct_use_ambiguous_method ~name:id - ~type_locs ~pkg ~loc)) - | Not_exist -> not_found ())))); - Basic_vec.iter (fun (mi_view: Pkg_info.mi_view) -> - Array.iter - (fun (id, (vd : Value_info.toplevel)) -> - match Typing_info.find_value values id with - | Some _ -> () - | None -> - Typing_info.add_value values - { vd with direct_use_loc_ = Implicit_import_all vd.loc_ }) - mi_view.values; - Array.iter - (fun (id, (td : Typedecl_info.t)) -> - let alias : Typedecl_info.alias = - { - name = id; - arity = td.ty_arity; - ty_params = td.ty_params_; - alias = - T_constr - { - type_constructor = td.ty_constr; - tys = Tvar_env.to_list_map td.ty_params_ (fun p -> p.typ); - generic_ = not (Tvar_env.is_empty td.ty_params_); - only_tag_enum_ = td.ty_is_only_tag_enum_; - is_suberror_ = td.ty_is_suberror_; - }; - is_pub = false; - doc_ = Docstring.empty; - loc_ = td.ty_loc_; - } - in - Hash_string.add type_alias id alias) - mi_view.external_types; - Array.iter - (fun (id, (trait : Trait_decl.t)) -> - let alias : Typedecl_info.alias = - { - name = id; - arity = 0; - ty_params = Tvar_env.empty; - alias = T_trait trait.name; - is_pub = false; - doc_ = Docstring.empty; - loc_ = trait.loc_; - } + | None -> not_found ())))); + if not (Vec.is_empty use_all_mi) then ( + let local_values = Hashset_string.create 17 in + let local_types = Hashset_string.create 17 in + Lst.iter impls ~f:(fun impl -> + match impl with + | Ptop_expr _ | Ptop_test _ | Ptop_impl _ | Ptop_impl_relation _ -> () + | Ptop_typedef { tycon = name; _ } + | Ptop_trait { trait_name = { binder_name = name }; _ } + | Ptop_trait_alias { binder = { binder_name = name }; _ } -> + Hashset_string.add local_types name + | Ptop_letdef { binder = name; _ } + | Ptop_funcdef { fun_decl = { name; type_name = None; _ }; _ } -> + Hashset_string.add local_values name.binder_name + | Ptop_funcdef { fun_decl = { type_name = Some _; _ }; _ } -> ()); + Vec.iter (fun (mi_view : Pkg_info.mi_view) -> + Hash_string.iter2 mi_view.values (fun id -> + fun vd -> + match Typing_info.find_value values id with + | Some _ -> () + | None when Hashset_string.mem local_values id -> () + | None -> + Typing_info.add_value values + { vd with direct_use_loc_ = Implicit_import_all vd.loc_ }); + Hash_string.iter2 mi_view.external_types (fun id -> + fun td -> + if not (Hashset_string.mem local_types id) then + let alias : Type_alias.t = + { + name = id; + arity = td.ty_arity; + ty_params = td.ty_params_; + target = + Type_alias + (T_constr + { + type_constructor = td.ty_constr; + tys = + Tvar_env.to_list_map td.ty_params_ (fun p -> + p.typ); + generic_ = not (Tvar_env.is_empty td.ty_params_); + is_suberror_ = td.ty_is_suberror_; + }); + is_pub = false; + doc_ = Docstring.empty; + loc_ = td.ty_loc_; + } + in + Hash_string.add type_alias id alias); + Hash_string.iter2 mi_view.external_traits (fun id -> + fun trait -> + if not (Hashset_string.mem local_types id) then + let alias : Type_alias.t = + { + name = id; + arity = 0; + ty_params = Tvar_env.empty; + target = Trait_alias { trait = trait.name }; + is_pub = false; + doc_ = Docstring.empty; + loc_ = trait.loc_; + } + in + Hash_string.add type_alias id alias); + Hash_string.iter mi_view.external_type_alias (fun (id, alias) -> + if not (Hashset_string.mem local_types id) then + Hash_string.add type_alias id alias)) + use_all_mi) + +let report_unused ~diagnostics (tbl : pkg_tbl) = + (let is_core pkg = + String.starts_with ~prefix:"moonbitlang/core/" pkg + [@@inline] + in + H.iter2 tbl (fun name -> + fun info -> + if + Lazy.is_val info.mi_info && (not !(info.usage)) + && (is_core !Basic_config.current_package || not (is_core name)) + && not (String.starts_with ~prefix:"_" name) + then + let report w loc = + Diagnostics.add_warning diagnostics { loc; kind = w } in - Hash_string.add type_alias id alias) - mi_view.external_traits; - Hash_string.iter mi_view.external_type_alias (fun (id, alias) -> - Hash_string.add type_alias id alias)) use_all_mi - -let report_unused ~diagnostics (tbl : pkg_tbl) : unit = - let is_core pkg = - String.starts_with ~prefix:"moonbitlang/core/" pkg - [@@inline] - in - H.iter2 tbl (fun name info -> - if - Lazy.is_val info.mi_info && (not !(info.usage)) - && (is_core !Basic_config.current_package || not (is_core name)) - && not (String.starts_with ~prefix:"_" name) - then - let report w loc = - Diagnostics.add_warning diagnostics { loc; kind = w } - in - match info.alias_to with - | None -> - if - not - (name = "moonbitlang/core/coverage" - || name = "moonbitlang/core/builtin") - then report (Unused_package { name; is_alias = false }) info.loc - | Some _ -> report (Unused_package { name; is_alias = true }) info.loc) + match info.alias_to with + | None -> + if + not + (name = "moonbitlang/core/coverage" + || name = "moonbitlang/core/builtin") + then report (Unused_package { name; is_alias = false }) info.loc + | Some _ -> report (Unused_package { name; is_alias = true }) info.loc) + : unit) let find_regular_value (tbl : pkg_tbl) ~(pkg : string) (id : string) = match find_pkg_opt tbl ~pkg with | None -> None - | Some p -> - Array.find_map - (fun ((x : string), vd) : Value_info.t option -> - if x = id then Some (Toplevel_value vd) else None) - p.values + | Some p -> ( + match Hash_string.find_opt p.values id with + | Some top_value -> Some (Value_info.Toplevel_value top_value) + | None -> None) diff --git a/src/pkg_config_util.ml b/src/pkg_config_util.ml index ad5cc82..d761a0f 100644 --- a/src/pkg_config_util.ml +++ b/src/pkg_config_util.ml @@ -25,107 +25,153 @@ type pkg_info = { type import_kind = Wbtest | Bbtest | Normal type import_items = pkg_info Map_string.t -let parse_import_item ~import_kind (pkg_config : Json_types.t option) : - import_items = - let map = ref Map_string.empty in - let add_item name info = map := Map_string.add !map name info in - let parse_json_array arr ~need_analyze_usage = - Array.iter - (fun (item : Json_types.t) -> - match item with - | Str { str; loc = pkg_loc } -> - add_item str - { - pkg_loc; - alias_info = None; - need_analyze_usage; - direct_uses = []; - } - | Obj { map; loc = _ } -> ( - match Map_string.find_opt map "path" with - | Some (Str { str; loc = pkg_loc }) -> - let alias_info = - match Map_string.find_opt map "alias" with - | Some (Str { str = alias_str; loc = alias_loc }) -> - Some (alias_str, alias_loc) - | _ -> None - in - let direct_uses = - match Map_string.find_opt map "value" with - | Some (Arr { content; _ }) -> - Array.fold_left - (fun acc (use : Json_types.t) -> - match use with - | Str { str; loc } -> (str, loc) :: acc - | _ -> acc) - [] content - | _ -> [] - in - add_item str - { pkg_loc; alias_info; need_analyze_usage; direct_uses } - | _ -> ()) - | _ -> ()) - arr - in - let parse_import (obj : Json_types.t Basic_map_string.t) field_name - ~need_analyze_usage = - match Basic_map_string.find_opt obj field_name with - | Some (Arr { content = arr; _ }) -> - parse_json_array arr ~need_analyze_usage - | _ -> () - in - (match pkg_config with - | Some (Obj { map; loc = _ }) -> ( - parse_import map "import" ~need_analyze_usage:(import_kind = Normal); - match import_kind with - | Normal -> () - | Wbtest -> parse_import map "wbtest-import" ~need_analyze_usage:true - | Bbtest -> - (match Basic_map_string.find_opt map "test-import-all" with - | Some (True _) -> Basic_config.blackbox_test_import_all := true - | _ -> ()); - parse_import map "test-import" ~need_analyze_usage:true) - | _ -> ()); - !map +let parse_import_item ~import_kind (pkg_config : Json_types.t option) = + (let map = ref Map_string.empty in + let add_item name info = map := Map_string.add !map name info in + let parse_json_array arr ~need_analyze_usage = + Array.iter + (fun (item : Json_types.t) -> + match item with + | Str { str; loc = pkg_loc } -> + add_item str + { + pkg_loc; + alias_info = None; + need_analyze_usage; + direct_uses = []; + } + | Obj { map; loc = _ } -> ( + match Map_string.find_opt map "path" with + | Some (Str { str; loc = pkg_loc }) -> + let alias_info = + match Map_string.find_opt map "alias" with + | Some (Str { str = alias_str; loc = alias_loc }) -> + Some (alias_str, alias_loc) + | _ -> None + in + let direct_uses = + match Map_string.find_opt map "value" with + | Some (Arr { content; _ }) -> + Array.fold_left + (fun acc -> + fun (use : Json_types.t) -> + match use with + | Str { str; loc } -> (str, loc) :: acc + | _ -> acc) + [] content + | _ -> [] + in + add_item str + { pkg_loc; alias_info; need_analyze_usage; direct_uses } + | _ -> ()) + | _ -> ()) + arr + in + let parse_import (obj : Json_types.t Basic_map_string.t) field_name + ~need_analyze_usage = + match Basic_map_string.find_opt obj field_name with + | Some (Arr { content = arr; _ }) -> + parse_json_array arr ~need_analyze_usage + | _ -> () + in + (match pkg_config with + | Some (Obj { map; loc = _ }) -> ( + parse_import map "import" ~need_analyze_usage:(import_kind = Normal); + match import_kind with + | Normal -> () + | Wbtest -> parse_import map "wbtest-import" ~need_analyze_usage:true + | Bbtest -> + (match Basic_map_string.find_opt map "test-import-all" with + | Some (True _) -> Basic_config.blackbox_test_import_all := true + | Some (False _) -> Basic_config.blackbox_test_import_all := false + | _ -> ()); + parse_import map "test-import" ~need_analyze_usage:true) + | _ -> ()); + !map + : import_items) type is_main_info = Is_main of Loc.t | Not_main -let parse_is_main (pkg_config : Json_types.t option) : is_main_info = - match pkg_config with - | Some (Obj { map; loc = _ }) -> ( - match Map_string.find_opt map "is-main" with - | Some (True loc) -> Is_main loc - | _ -> ( - match Map_string.find_opt map "is_main" with - | Some (True loc) -> Is_main loc - | _ -> Not_main)) - | _ -> Not_main +let parse_is_main (pkg_config : Json_types.t option) = + (match pkg_config with + | Some (Obj { map; loc = _ }) -> ( + match Map_string.find_opt map "is-main" with + | Some (True loc) -> Is_main loc + | _ -> ( + match Map_string.find_opt map "is_main" with + | Some (True loc) -> Is_main loc + | _ -> Not_main)) + | _ -> Not_main + : is_main_info) + +let parse_memory_limits (memory_limits_config : Json_types.t option) = + (match memory_limits_config with + | Some (Obj { map; loc = _ }) -> ( + (match Map_string.find_opt map "min" with + | Some (Float { float = min; _ }) -> + Basic_config.memory_limits_min := int_of_string_opt min + | _ -> ()); + match Map_string.find_opt map "max" with + | Some (Float { float = max; _ }) -> + Basic_config.memory_limits_max := int_of_string_opt max + | _ -> ()) + | _ -> () + : unit) + +let parse_import_memory (import_memory_config : Json_types.t option) = + (match import_memory_config with + | Some (Obj { map; loc = _ }) -> ( + (match Map_string.find_opt map "name" with + | Some (Str { str; _ }) -> Basic_config.import_memory_name := Some str + | _ -> ()); + match Map_string.find_opt map "module" with + | Some (Str { str; _ }) -> Basic_config.import_memory_module := Some str + | _ -> ()) + | _ -> () + : unit) -let link_core_load_pkg_config (pkg_config : Json_types.t) : unit = - match pkg_config with - | Obj { map; loc = _ } -> ( - match Map_string.find_opt map "link" with - | Some (Obj { map; loc = _ }) -> ( - match Map_string.find_opt map "wasm-gc" with - | Some (Obj { map; loc = _ }) -> ( - (match Map_string.find_opt map "use-js-builtin-string" with - | Some (True _) -> Basic_config.use_js_builtin_string := true - | _ -> ()); - match Map_string.find_opt map "imported-string-constants" with - | Some (Str { str; _ }) -> - Basic_config.const_string_module_name := str - | _ -> ()) - | _ -> ()) - | _ -> ()) - | _ -> () +let parse_shared_memory (shared_memory : Json_types.t option) = + (match shared_memory with + | Some (True _) -> Basic_config.shared_memory := true + | _ -> () + : unit) -let parse_warn_alert (pkg_config : Json_types.t option) : unit = - match pkg_config with - | Some (Obj { map; loc = _ }) -> ( - (match Map_string.find_opt map "warn-list" with - | Some (Str { str; _ }) -> Warnings.parse_options false str - | _ -> ()); - match Map_string.find_opt map "alert-list" with - | Some (Str { str; _ }) -> Alerts.parse_options str - | _ -> ()) - | _ -> () +let link_core_load_pkg_config (pkg_config : Json_types.t) = + (match pkg_config with + | Obj { map; loc = _ } -> ( + match Map_string.find_opt map "link" with + | Some (Obj { map; loc = _ }) -> ( + (match Map_string.find_opt map "wasm-gc" with + | Some (Obj { map; loc = _ }) -> + (match Map_string.find_opt map "use-js-builtin-string" with + | Some (True _) -> Basic_config.use_js_builtin_string := true + | _ -> ()); + (match Map_string.find_opt map "imported-string-constants" with + | Some (Str { str; _ }) -> + Basic_config.const_string_module_name := str + | _ -> ()); + parse_import_memory (Map_string.find_opt map "import-memory"); + parse_memory_limits (Map_string.find_opt map "memory-limits"); + parse_shared_memory (Map_string.find_opt map "shared-memory") + | _ -> ()); + match Map_string.find_opt map "wasm" with + | Some (Obj { map; loc = _ }) -> + parse_import_memory (Map_string.find_opt map "import-memory"); + parse_memory_limits (Map_string.find_opt map "memory-limits"); + parse_shared_memory (Map_string.find_opt map "shared-memory") + | _ -> ()) + | _ -> ()) + | _ -> () + : unit) + +let parse_warn_alert (pkg_config : Json_types.t option) = + (match pkg_config with + | Some (Obj { map; loc = _ }) -> ( + (match Map_string.find_opt map "warn-list" with + | Some (Str { str; _ }) -> Warnings.parse_options false str + | _ -> ()); + match Map_string.find_opt map "alert-list" with + | Some (Str { str; _ }) -> Alerts.parse_options str + | _ -> ()) + | _ -> () + : unit) diff --git a/src/pkg_info.ml b/src/pkg_info.ml index 43c97fa..be15631 100644 --- a/src/pkg_info.ml +++ b/src/pkg_info.ml @@ -13,12 +13,17 @@ *) +module Vec = Basic_vec +module Arr = Basic_arr +module Type_path = Basic_type_path +module Hash_string = Basic_hash_string + type mi_view = { - values : (string * Value_info.toplevel) array; - external_types : (string * Typedecl_info.t) array; - external_traits : (string * Trait_decl.t) array; - external_constrs : Typedecl_info.constructor list Basic_hash_string.t; - external_type_alias : Typedecl_info.alias Basic_hash_string.t; + values : Value_info.toplevel Hash_string.t; + external_types : Typedecl_info.t Hash_string.t; + external_traits : Trait_decl.t Hash_string.t; + external_constrs : Typedecl_info.constructor list Hash_string.t; + external_type_alias : Type_alias.t Hash_string.t; method_env : Method_env.t; ext_method_env : Ext_method_env.t; trait_impls : Trait_impl.t; @@ -31,84 +36,69 @@ include struct let sexp_of_mi_view = (fun { values = values__002_; - external_types = external_types__008_; - external_traits = external_traits__014_; - external_constrs = external_constrs__020_; - external_type_alias = external_type_alias__022_; - method_env = method_env__024_; - ext_method_env = ext_method_env__026_; - trait_impls = trait_impls__028_; - name = name__030_; - } -> + external_types = external_types__004_; + external_traits = external_traits__006_; + external_constrs = external_constrs__008_; + external_type_alias = external_type_alias__010_; + method_env = method_env__012_; + ext_method_env = ext_method_env__014_; + trait_impls = trait_impls__016_; + name = name__018_; + } + -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = - let arg__031_ = Moon_sexp_conv.sexp_of_string name__030_ in - (S.List [ S.Atom "name"; arg__031_ ] :: bnds__001_ : _ Stdlib.List.t) + let arg__019_ = Moon_sexp_conv.sexp_of_string name__018_ in + (S.List [ S.Atom "name"; arg__019_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__029_ = Trait_impl.sexp_of_t trait_impls__028_ in - (S.List [ S.Atom "trait_impls"; arg__029_ ] :: bnds__001_ + let arg__017_ = Trait_impl.sexp_of_t trait_impls__016_ in + (S.List [ S.Atom "trait_impls"; arg__017_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__027_ = Ext_method_env.sexp_of_t ext_method_env__026_ in - (S.List [ S.Atom "ext_method_env"; arg__027_ ] :: bnds__001_ + let arg__015_ = Ext_method_env.sexp_of_t ext_method_env__014_ in + (S.List [ S.Atom "ext_method_env"; arg__015_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__025_ = Method_env.sexp_of_t method_env__024_ in - (S.List [ S.Atom "method_env"; arg__025_ ] :: bnds__001_ + let arg__013_ = Method_env.sexp_of_t method_env__012_ in + (S.List [ S.Atom "method_env"; arg__013_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__023_ = - Basic_hash_string.sexp_of_t Typedecl_info.sexp_of_alias - external_type_alias__022_ + let arg__011_ = + Hash_string.sexp_of_t Type_alias.sexp_of_t external_type_alias__010_ in - (S.List [ S.Atom "external_type_alias"; arg__023_ ] :: bnds__001_ + (S.List [ S.Atom "external_type_alias"; arg__011_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__021_ = - Basic_hash_string.sexp_of_t + let arg__009_ = + Hash_string.sexp_of_t (Moon_sexp_conv.sexp_of_list Typedecl_info.sexp_of_constructor) - external_constrs__020_ + external_constrs__008_ in - (S.List [ S.Atom "external_constrs"; arg__021_ ] :: bnds__001_ + (S.List [ S.Atom "external_constrs"; arg__009_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__015_ = - Moon_sexp_conv.sexp_of_array - (fun (arg0__016_, arg1__017_) -> - let res0__018_ = Moon_sexp_conv.sexp_of_string arg0__016_ - and res1__019_ = Trait_decl.sexp_of_t arg1__017_ in - S.List [ res0__018_; res1__019_ ]) - external_traits__014_ + let arg__007_ = + Hash_string.sexp_of_t Trait_decl.sexp_of_t external_traits__006_ in - (S.List [ S.Atom "external_traits"; arg__015_ ] :: bnds__001_ + (S.List [ S.Atom "external_traits"; arg__007_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - let arg__009_ = - Moon_sexp_conv.sexp_of_array - (fun (arg0__010_, arg1__011_) -> - let res0__012_ = Moon_sexp_conv.sexp_of_string arg0__010_ - and res1__013_ = Typedecl_info.sexp_of_t arg1__011_ in - S.List [ res0__012_; res1__013_ ]) - external_types__008_ + let arg__005_ = + Hash_string.sexp_of_t Typedecl_info.sexp_of_t external_types__004_ in - (S.List [ S.Atom "external_types"; arg__009_ ] :: bnds__001_ + (S.List [ S.Atom "external_types"; arg__005_ ] :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = let arg__003_ = - Moon_sexp_conv.sexp_of_array - (fun (arg0__004_, arg1__005_) -> - let res0__006_ = Moon_sexp_conv.sexp_of_string arg0__004_ - and res1__007_ = Value_info.sexp_of_toplevel arg1__005_ in - S.List [ res0__006_; res1__007_ ]) - values__002_ + Hash_string.sexp_of_t Value_info.sexp_of_toplevel values__002_ in (S.List [ S.Atom "values"; arg__003_ ] :: bnds__001_ : _ Stdlib.List.t) in @@ -117,3 +107,192 @@ include struct let _ = sexp_of_mi_view end + +type trait_impl_info = { + impl : Trait_impl.impl; + methods : (string * Method_env.method_info) Vec.t; +} + +type type_info = { + path : Type_path.t; + decl : Typedecl_info.t option; + methods : (string * Method_env.method_info) Vec.t; + impls : trait_impl_info Vec.t; +} + +type trait_info = { + path : Type_path.t; + decl : Trait_decl.t; + default_impls : (string * Method_env.method_info) Vec.t; + impls : trait_impl_info Vec.t; +} + +type mi_readable_view = { + name : string; + values : (string * Value_info.toplevel) Vec.t; + types : type_info array; + traits : trait_info array; + type_alias : Type_alias.t array; +} + +module Trait_impl_hash = Basic_hashf.Make (struct + type t = Type_path.t * Type_path.t + + include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (fun (arg0__020_, arg1__021_) -> + let res0__022_ = Type_path.sexp_of_t arg0__020_ + and res1__023_ = Type_path.sexp_of_t arg1__021_ in + S.List [ res0__022_; res1__023_ ] + : t -> S.t) + + let _ = sexp_of_t + + let equal = + (fun a__024_ -> + fun b__025_ -> + let t__026_, t__027_ = a__024_ in + let t__028_, t__029_ = b__025_ in + Stdlib.( && ) + (Type_path.equal t__026_ t__028_) + (Type_path.equal t__027_ t__029_) + : t -> t -> bool) + + let _ = equal + + let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = + fun hsv -> + fun arg -> + let e0, e1 = arg in + let hsv = Type_path.hash_fold_t hsv e0 in + let hsv = Type_path.hash_fold_t hsv e1 in + hsv + + let _ = hash_fold_t + + let (hash : t -> Ppx_base.hash_value) = + let func arg = + Ppx_base.get_hash_value + (let hsv = Ppx_base.create () in + hash_fold_t hsv arg) + in + fun x -> func x + + let _ = hash + end +end) + +let to_readable_view (mi : mi_view) = + let types = Type_path.Hash.create 17 in + Hash_string.iter2 mi.external_types (fun _ -> + fun decl -> + Type_path.Hash.add types decl.ty_constr + { + path = decl.ty_constr; + decl = Some decl; + methods = Vec.empty (); + impls = Vec.empty (); + }); + let get_type_info_or_add_as_foreign path = + match Type_path.Hash.find_opt types path with + | Some info -> info + | None -> + let info = + { path; decl = None; methods = Vec.empty (); impls = Vec.empty () } + in + Type_path.Hash.add types path info; + info + in + let traits = Type_path.Hash.create 17 in + Hash_string.iter2 mi.external_traits (fun _ -> + fun trait_decl -> + Type_path.Hash.add traits trait_decl.name + { + path = trait_decl.name; + decl = trait_decl; + default_impls = Vec.empty (); + impls = Vec.empty (); + }); + let values = Vec.empty () in + Hash_string.iter2 mi.values (fun name -> + fun value_info -> + match value_info.direct_use_loc_ with + | Explicit_import _ | Implicit_import_all _ -> () + | Not_direct_use -> Vec.push values (name, value_info)); + Method_env.iter mi.method_env (fun type_name -> + fun method_name -> + fun method_info -> + match method_info.id with + | Qmethod _ -> + let type_info = get_type_info_or_add_as_foreign type_name in + Vec.push type_info.methods (method_name, method_info) + | _ -> ()); + let trait_impls = Trait_impl_hash.create 17 in + Trait_impl.iter mi.trait_impls (fun ~trait -> + fun ~type_name -> + fun impl -> + if not impl.is_implicit_ then + Trait_impl_hash.add trait_impls (trait, type_name) + { impl; methods = Vec.empty () }); + Ext_method_env.iter mi.ext_method_env + (fun ({ trait; self_type; method_name }, method_info) -> + if Type_path.equal self_type Type_path.Builtin.default_impl_placeholder + then + let trait_info = Type_path.Hash.find_exn traits trait in + Vec.push trait_info.default_impls (method_name, method_info) + else + match Trait_impl_hash.find_opt trait_impls (trait, self_type) with + | None -> () + | Some impl_info -> Vec.push impl_info.methods (method_name, method_info)); + Trait_impl_hash.iter2 trait_impls (fun (trait, type_name) -> + fun impl -> + Vec.sort impl.methods (fun (name1, _) -> + fun (name2, _) -> String.compare name1 name2); + match Type_path.Hash.find_opt types type_name with + | Some { decl = Some _; impls; _ } -> Vec.push impls impl + | _ -> ( + match Type_path.Hash.find_opt traits trait with + | Some trait_info -> Vec.push trait_info.impls impl + | None -> + let type_info = get_type_info_or_add_as_foreign type_name in + Vec.push type_info.impls impl)); + let type_alias = Hash_string.to_array_map mi.external_type_alias snd in + let types = Type_path.Hash.to_array_map types snd in + Array.sort + (fun (t1 : type_info) -> + fun (t2 : type_info) -> + match (t1.decl, t2.decl) with + | Some _, None -> -1 + | None, Some _ -> 1 + | Some _, Some _ | None, None -> Type_path.compare t1.path t2.path) + types; + Arr.iter types (fun type_info -> + let { path = _; decl = _; methods; impls } = type_info in + Vec.sort methods (fun (name1, _) -> + fun (name2, _) -> String.compare name1 name2); + Vec.sort impls (fun impl1 -> + fun impl2 -> Type_path.compare impl1.impl.trait impl2.impl.trait)); + let traits = Type_path.Hash.to_array_map traits snd in + Array.sort (fun tr1 -> fun tr2 -> Type_path.compare tr1.path tr2.path) traits; + Arr.iter traits (fun trait_info -> + let { path = _; decl = _; default_impls; impls } = trait_info in + Vec.sort default_impls (fun (name1, _) -> + fun (name2, _) -> String.compare name1 name2); + Vec.sort impls (fun impl1 -> + fun impl2 -> + let ty1 = + Stype.extract_tpath_exn (Stype.type_repr impl1.impl.self_ty) + in + let ty2 = + Stype.extract_tpath_exn (Stype.type_repr impl2.impl.self_ty) + in + Type_path.compare ty1 ty2)); + Vec.sort values (fun (name1, _) -> + fun (name2, _) -> String.compare name1 name2); + Array.sort + (fun (alias1 : Type_alias.t) -> + fun (alias2 : Type_alias.t) -> String.compare alias1.name alias2.name) + type_alias; + { name = mi.name; values; types; traits; type_alias } diff --git a/src/pkg_path_tbl.ml b/src/pkg_path_tbl.ml index b3a1d19..9ed4c2a 100644 --- a/src/pkg_path_tbl.ml +++ b/src/pkg_path_tbl.ml @@ -26,10 +26,10 @@ let resolve_source self ~pkg ~file:path = match rev_parts with | [] -> path | last :: rest -> ( - let pkg = String.concat "/" (rev_parts |> List.rev) in + let pkg = String.concat "/" (List.rev rev_parts) in match H.find_opt self pkg with | Some src_dir -> Filename.concat src_dir path | None -> find rest (Filename.concat last path)) in - let rev_parts = String.split_on_char '/' pkg |> List.rev in + let rev_parts = List.rev (String.split_on_char '/' pkg) in find rev_parts path diff --git a/src/placeholder_env.ml b/src/placeholder_env.ml index fb9beba..00d9ef6 100644 --- a/src/placeholder_env.ml +++ b/src/placeholder_env.ml @@ -19,6 +19,7 @@ module Type_path = Basic_type_path module Lst = Basic_lst module Vec = Basic_vec module Syntax = Parsing_syntax +module Longident = Basic_longident type trait_info = { decl : Syntax.trait_decl; @@ -29,6 +30,7 @@ type trait_info = { type t = { types : Syntax.type_decl Hash_string.t; traits : trait_info Hash_string.t; + trait_alias : Syntax.impl Hash_string.t; newtype_deps : string list Hash_string.t; type_alias_deps : string list Hash_string.t; } @@ -37,12 +39,17 @@ let find_type_opt (env : t) (name : string) = Hash_string.find_opt env.types name let find_trait_opt (env : t) (name : string) = - Hash_string.find_opt env.traits name + match Hash_string.find_opt env.traits name with + | None -> None + | Some trait_info -> Some trait_info.decl + +let find_trait_alias (env : t) (name : string) = + Hash_string.find_opt env.trait_alias name let find_type_alias_deps (env : t) (name : string) = Hash_string.find_opt env.type_alias_deps name -let make ~foreign_types ~type_defs ~trait_defs = +let make ~foreign_types ~type_defs ~trait_defs ~trait_alias = let newtype_deps = Hash_string.create 17 in let type_alias_deps = Hash_string.create 17 in Hash_string.iter type_defs (fun (name, (decl : Syntax.type_decl)) -> @@ -51,21 +58,25 @@ let make ~foreign_types ~type_defs ~trait_defs = let rec go (typ : Syntax.typ) = match typ with | Ptype_any _ -> () - | Ptype_arrow { ty_arg; ty_res; ty_err } -> ( - Lst.iter ty_arg go; + | Ptype_arrow { ty_arg; ty_res; ty_err; is_async = _ } -> ( + Lst.iter ty_arg ~f:go; go ty_res; match ty_err with | Error_typ { ty = ty_err } -> go ty_err | No_error_typ | Default_error_typ _ -> ()) - | Ptype_tuple { tys } -> Lst.iter tys go + | Ptype_tuple { tys } -> Lst.iter tys ~f:go | Ptype_name { constr_id; tys } -> ( - Lst.iter tys go; + Lst.iter tys ~f:go; match constr_id.lid with | Lident name -> if not (Hashset_string.mem exclude name) then result := name :: !result | Ldot _ -> ()) | Ptype_option { ty; _ } -> go ty + | Ptype_object { lid = Lident name } -> + if not (Hashset_string.mem exclude name) then + result := name :: !result + | Ptype_object { lid = Ldot _ } -> () in go typ; !result @@ -73,19 +84,19 @@ let make ~foreign_types ~type_defs ~trait_defs = match decl.components with | Ptd_newtype typ -> let exclude = Hashset_string.create 17 in - Lst.iter decl.params (fun tvar -> + Lst.iter decl.params ~f:(fun tvar -> match tvar.tvar_name with | Some tvar_name -> Hashset_string.add exclude tvar_name | None -> ()); Hash_string.add newtype_deps name (collect_use exclude typ) | Ptd_alias typ -> let exclude = Hashset_string.create 17 in - Lst.iter decl.params (fun tvar -> + Lst.iter decl.params ~f:(fun tvar -> match tvar.tvar_name with | Some tvar_name -> Hashset_string.add exclude tvar_name | None -> ()); Hash_string.add type_alias_deps name (collect_use exclude typ) - | Ptd_abstract | Ptd_variant _ | Ptd_record _ | Ptd_error _ -> ()); + | Ptd_abstract | Ptd_extern | Ptd_variant _ | Ptd_record _ | Ptd_error _ -> ()); let object_safety_of_traits = Hash_string.create (Hash_string.length trait_defs) in @@ -111,7 +122,7 @@ let make ~foreign_types ~type_defs ~trait_defs = Hash_string.find_exn object_safety_of_traits name <> [] && name <> name0 then Vec.push not_object_safe_supers path; - Lst.iter decl.trait_supers (fun super -> + Lst.iter decl.trait_supers ~f:(fun super -> match super.tvc_trait with | Lident name -> add_trait name | Ldot _ as id -> add_foreign_trait id)) @@ -123,7 +134,7 @@ let make ~foreign_types ~type_defs ~trait_defs = with | Error _ -> () | Ok decl -> - Lst.iter decl.closure (fun path -> + Lst.iter decl.closure ~f:(fun path -> if not (Type_path.Hashset.mem visited path) then ( Type_path.Hashset.add visited path; Vec.push closure path; @@ -134,40 +145,104 @@ let make ~foreign_types ~type_defs ~trait_defs = let object_safety_status = List.append (Hash_string.find_exn object_safety_of_traits name) - (Vec.map_into_list not_object_safe_supers (fun super -> + (Vec.map_into_list not_object_safe_supers ~unorder:(fun super -> Trait_decl.Bad_super_trait super)) in let info = { decl; object_safety_status; closure = Vec.to_list closure } in Hash_string.add traits name info); - { types = type_defs; traits; newtype_deps; type_alias_deps } + { types = type_defs; traits; newtype_deps; type_alias_deps; trait_alias } -let types_to_list_map (type a) (env : t) (f : string -> Syntax.type_decl -> a) : - a list = - Hash_string.to_list_with env.types f +let types_to_list_map (type a) (env : t) (f : string -> Syntax.type_decl -> a) = + (Hash_string.to_list_with env.types f : a list) let iter_types (env : t) (f : string -> Syntax.type_decl -> unit) = Hash_string.iter2 env.types f -let iter_traits (env : t) (f : string -> trait_info -> unit) : unit = - Hash_string.iter2 env.traits f - -let traits_to_list_map (type a) (env : t) (f : string -> trait_info -> a) : - a list = - Hash_string.to_list_with env.traits f - -let newtype_in_cycle (env : t) (name : string) : bool = - let visiting = Hashset_string.create 17 in - let rec go (name : string) = - if Hashset_string.mem visiting name then true - else - match Hash_string.find_opt env.newtype_deps name with - | None -> false - | Some deps -> - Hashset_string.add visiting name; - let result = Lst.exists deps (fun dep -> go dep) in - Hashset_string.remove visiting name; - result +let iter_traits (env : t) (f : string -> Syntax.trait_decl -> unit) = + (Hash_string.iter2 env.traits (fun name trait_info -> f name trait_info.decl) : unit) + +let iter_trait_alias (env : t) (f : string -> Syntax.impl -> unit) = + (Hash_string.iter2 env.trait_alias f : unit) + +let traits_to_list_map (type a) (env : t) (f : string -> Syntax.trait_decl -> a) + = + (Hash_string.to_list_with env.traits (fun name trait_info -> f name trait_info.decl) : a list) + +let newtype_in_cycle (env : t) (name : string) = + (let visiting = Hashset_string.create 17 in + let rec go (name : string) = + if Hashset_string.mem visiting name then true + else + match Hash_string.find_opt env.newtype_deps name with + | None -> false + | Some deps -> + Hashset_string.add visiting name; + let result = Lst.exists deps (fun dep -> go dep) in + Hashset_string.remove visiting name; + result + in + go name + : bool) + +type trait_location_info = + | Local_trait of Type_path.t * Syntax.trait_decl + | Foreign_trait of Trait_decl.t + +let typing_trait_name ~types (env : t) (trait : Syntax.type_name) = + let find_foreign ~is_alias = + match Global_env.All_types.find_trait types trait.name ~loc:trait.loc_ with + | Ok decl -> + let type_name : Typedtree.type_name = + if is_alias then + Tname_alias + { + name = decl.name; + kind = Trait; + alias_ = trait.name; + loc_ = trait.loc_; + } + else Tname_path { name = decl.name; kind = Trait; loc_ = trait.loc_ } + in + Ok (Foreign_trait decl, type_name) + | Error err -> Error err + [@@local] in - go name + match Global_env.All_types.find_type_alias types trait.name with + | Some { target = Trait_alias { trait = path }; _ } -> ( + match path with + | Toplevel { pkg; id } when pkg = !Basic_config.current_package -> ( + match find_trait_opt env id with + | Some decl -> + let type_name : Typedtree.type_name = + Tname_alias + { + name = path; + kind = Trait; + alias_ = trait.name; + loc_ = trait.loc_; + } + in + Ok (Local_trait (path, decl), type_name) + | None -> Error Errors.swallow_error) + | _ -> find_foreign ~is_alias:true) + | Some { target = Type_alias _; _ } -> + Error + (Errors.not_a_trait + ~name:(Longident.to_string trait.name) + ~loc:trait.loc_) + | None -> ( + match trait.name with + | Lident name -> ( + match find_trait_opt env name with + | Some decl -> + let path = + Type_path.toplevel_type ~pkg:!Basic_config.current_package name + in + let type_name : Typedtree.type_name = + Tname_path { name = path; kind = Trait; loc_ = trait.loc_ } + in + Ok (Local_trait (path, decl), type_name) + | None -> find_foreign ~is_alias:false) + | Ldot _ -> find_foreign ~is_alias:false) diff --git a/src/poly_type.ml b/src/poly_type.ml index 3493c97..1c9bedd 100644 --- a/src/poly_type.ml +++ b/src/poly_type.ml @@ -30,37 +30,38 @@ let add_constraint (cenv : t) (typ : typ) (c : Tvar_env.type_constraint) = let iter (c : t) ~f = Alist.iter c.constraints f let rec instantiate_type_aux ~(generic : bool) (type_subst : Stype.t array) - (ty : typ) : Stype.t = - let go ty = instantiate_type_aux ~generic type_subst ty [@@inline] in - match Stype.type_repr ty with - | Tarrow { params_ty = ty1; ret_ty = ty2; err_ty = ty3; generic_ } -> - if generic_ then - let err_ty = - match ty3 with None -> None | Some ty3 -> Some (go ty3) - in - Tarrow - { - params_ty = Lst.map ty1 go; - ret_ty = go ty2; - err_ty; - generic_ = generic; - } - else ty - | T_constr - { type_constructor = c; tys; generic_; only_tag_enum_; is_suberror_ } -> - if generic_ then - T_constr - { - type_constructor = c; - tys = Lst.map tys go; - generic_ = generic; - only_tag_enum_; - is_suberror_; - } - else ty - | Tvar _ as ty -> ty - | Tparam { index } -> type_subst.!(index) - | (T_trait _ | T_builtin _ | T_blackhole) as ty -> ty + (ty : typ) = + (let go ty = instantiate_type_aux ~generic type_subst ty [@@inline] in + match Stype.type_repr ty with + | Tarrow { params_ty = ty1; ret_ty = ty2; err_ty = ty3; is_async; generic_ } + -> + if generic_ then + let err_ty = + match ty3 with None -> None | Some ty3 -> Some (go ty3) + in + Tarrow + { + params_ty = Lst.map ty1 go; + ret_ty = go ty2; + err_ty; + is_async; + generic_ = generic; + } + else ty + | T_constr { type_constructor = c; tys; generic_; is_suberror_ } -> + if generic_ then + T_constr + { + type_constructor = c; + tys = Lst.map tys go; + generic_ = generic; + is_suberror_; + } + else ty + | Tvar _ as ty -> ty + | Tparam { index } -> type_subst.!(index) + | (T_trait _ | T_builtin _ | T_blackhole) as ty -> ty + : Stype.t) let instantiate_type type_subst ty = instantiate_type_aux ~generic:false type_subst ty @@ -71,11 +72,12 @@ let gen_instantiate_type type_subst ty = [@@inline] let add_constraints ~loc ~cenv (type_subst : Stype.t array) (env : Tvar_env.t) = - Tvar_env.iteri env (fun index tvar_info -> - let ty = type_subst.!(index) in - Lst.iter tvar_info.constraints (fun c -> - let c' = match loc with None -> c | Some loc_ -> { c with loc_ } in - add_constraint cenv ty c')) + Tvar_env.iteri env (fun index -> + fun tvar_info -> + let ty = type_subst.!(index) in + Lst.iter tvar_info.constraints ~f:(fun c -> + let c' = match loc with None -> c | Some loc_ -> { c with loc_ } in + add_constraint cenv ty c')) [@@inline] let instantiate_value ~(cenv : t) ?(loc : Rloc.t option) @@ -101,30 +103,37 @@ let instantiate_impl_self_type ~(cenv : t) ~(ty_params : Tvar_env.t) add_constraints ~loc:None ~cenv type_subst ty_params; instantiate_type type_subst self_ty -let instantiate_method_no_constraint (method_info : Method_env.method_info) : - Stype.t * Stype.t array = - let ty_params = method_info.ty_params_ in - if Tvar_env.is_empty ty_params then (method_info.typ, [||]) - else - let type_subst = Tvar_env.make_type_subst ty_params in - let typ' = instantiate_type type_subst method_info.typ in - (typ', type_subst) - -let instantiate_method_decl (md : Trait_decl.method_decl) ~(self : Stype.t) : - Stype.t = - let type_subst = [| self |] in - gen_instantiate_type type_subst md.method_typ +let instantiate_method_no_constraint (method_info : Method_env.method_info) = + (let ty_params = method_info.ty_params_ in + if Tvar_env.is_empty ty_params then (method_info.typ, method_info.kind_, [||]) + else + let type_subst = Tvar_env.make_type_subst ty_params in + let typ' = instantiate_type type_subst method_info.typ in + let kind : Method_env.method_kind = + match method_info.kind_ with + | Regular_method | Regular_method_qualified -> method_info.kind_ + | Method_explicit_self { self_ty } -> + Method_explicit_self + { self_ty = instantiate_type type_subst self_ty } + in + (typ', kind, type_subst) + : Stype.t * Method_env.method_kind * Stype.t array) + +let instantiate_method_decl (md : Trait_decl.method_decl) ~(self : Stype.t) = + (let type_subst = [| self |] in + gen_instantiate_type type_subst md.method_typ + : Stype.t) let instantiate_record ~(ty_record : [ `Known of Stype.t | `Generic of Tvar_env.t * Stype.t ]) (fields : Typedecl_info.fields) = - let instantiate_field type_subst (field_info : Typedecl_info.field) : - Typedecl_info.field = - { - field_info with - ty_record = instantiate_type type_subst field_info.ty_record; - ty_field = instantiate_type type_subst field_info.ty_field; - } + let instantiate_field type_subst (field_info : Typedecl_info.field) = + ({ + field_info with + ty_record = instantiate_type type_subst field_info.ty_record; + ty_field = instantiate_type type_subst field_info.ty_field; + } + : Typedecl_info.field) in match ty_record with | `Known ty_expect -> ( @@ -164,6 +173,11 @@ let instantiate_constr (constr : Typedecl_info.constructor) = in (ty_res, ty_args) -let instantiate_alias (alias : Typedecl_info.alias) (ty_args : Stype.t list) = - if Tvar_env.is_empty alias.ty_params then alias.alias - else gen_instantiate_type (Array.of_list ty_args) alias.alias +let instantiate_alias (alias : Type_alias.t) (ty_args : Stype.t list) = + let ty = + match alias.target with + | Type_alias ty -> ty + | Trait_alias { trait } -> T_trait trait + in + if Tvar_env.is_empty alias.ty_params then ty + else gen_instantiate_type (Array.of_list ty_args) ty diff --git a/src/ppx_base.ml b/src/ppx_base.ml index a561a4e..0c63f27 100644 --- a/src/ppx_base.ml +++ b/src/ppx_base.ml @@ -65,4 +65,4 @@ let hash_fold_list hash_fold_elem s list = let hash_fold_char s c = hash_fold_int s (Char.code c) let hash_fold_bool s b = hash_fold_int s (if b then 1 else 0) -let create () : state = 0 +let create () = (0 : state) diff --git a/src/primitive.ml b/src/primitive.ml index 634af78..4031f6c 100644 --- a/src/primitive.ml +++ b/src/primitive.ml @@ -16,33 +16,36 @@ module Constr_info = Basic_constr_info module Hash_string = Basic_hash_string -type operand_type = I32 | I64 | U32 | U64 | F64 | F32 | U8 -and convert_kind = Convert | Reinterpret -and arith_operator = Add | Sub | Mul | Div | Mod | Neg | Sqrt +type operand_type = I32 | I64 | U32 | U64 | F64 | F32 | U8 | U16 | I16 +and convert_kind = Convert | Saturate | Reinterpret +and arith_operator = Add | Sub | Mul | Div | Mod | Neg | Sqrt | Abs and bitwise_operator = Not | And | Or | Xor | Shl | Shr | Ctz | Clz | Popcnt and comparison = Lt | Le | Gt | Ge | Eq | Ne -and cast_kind = Constr_to_enum | Unfold_rec_newtype | Make_newtype + +and cast_kind = + | Constr_to_enum + | Enum_to_constr + | Unfold_rec_newtype + | Make_newtype and prim = | Pfixedarray_length | Pccall of { arity : int; func_name : string } | Pintrinsic of Moon_intrinsic.t - | Pgetstringitem + | Pgetstringitem of { safe : bool } | Pignore | Pidentity | Pmakebytes | Pbyteslength - | Pgetbytesitem - | Psetbytesitem + | Pgetbytesitem of { safe : bool } + | Psetbytesitem of { safe : bool } | Pnot - | Praise | Ppanic | Punreachable | Pcatch - | Psequand - | Psequor | Pstringlength | Pstringequal + | Pbytesequal | Pcast of { kind : cast_kind } | Pconvert of { kind : convert_kind; from : operand_type; to_ : operand_type } | Parith of { operand_type : operand_type; operator : arith_operator } @@ -66,6 +69,9 @@ and prim = | Perror_to_string | Pcall_object_method of { method_index : int; method_name : string } | Pany_to_string + | Pget_current_continuation + | Prun_async + | Praw_func_to_func_ref and make_array_kind = LenAndInit | EverySingleElem | Uninit and array_get_kind = Safe | Unsafe | Rev_unsafe @@ -81,11 +87,15 @@ include struct | F64 -> S.Atom "F64" | F32 -> S.Atom "F32" | U8 -> S.Atom "U8" + | U16 -> S.Atom "U16" + | I16 -> S.Atom "I16" : operand_type -> S.t) and sexp_of_convert_kind = (function - | Convert -> S.Atom "Convert" | Reinterpret -> S.Atom "Reinterpret" + | Convert -> S.Atom "Convert" + | Saturate -> S.Atom "Saturate" + | Reinterpret -> S.Atom "Reinterpret" : convert_kind -> S.t) and sexp_of_arith_operator = @@ -97,6 +107,7 @@ include struct | Mod -> S.Atom "Mod" | Neg -> S.Atom "Neg" | Sqrt -> S.Atom "Sqrt" + | Abs -> S.Atom "Abs" : arith_operator -> S.t) and sexp_of_bitwise_operator = @@ -125,6 +136,7 @@ include struct and sexp_of_cast_kind = (function | Constr_to_enum -> S.Atom "Constr_to_enum" + | Enum_to_constr -> S.Atom "Enum_to_constr" | Unfold_rec_newtype -> S.Atom "Unfold_rec_newtype" | Make_newtype -> S.Atom "Make_newtype" : cast_kind -> S.t) @@ -148,135 +160,151 @@ include struct | Pintrinsic arg0__006_ -> let res0__007_ = Moon_intrinsic.sexp_of_t arg0__006_ in S.List [ S.Atom "Pintrinsic"; res0__007_ ] - | Pgetstringitem -> S.Atom "Pgetstringitem" + | Pgetstringitem { safe = safe__009_ } -> + let bnds__008_ = ([] : _ Stdlib.List.t) in + let bnds__008_ = + let arg__010_ = Moon_sexp_conv.sexp_of_bool safe__009_ in + (S.List [ S.Atom "safe"; arg__010_ ] :: bnds__008_ : _ Stdlib.List.t) + in + S.List (S.Atom "Pgetstringitem" :: bnds__008_) | Pignore -> S.Atom "Pignore" | Pidentity -> S.Atom "Pidentity" | Pmakebytes -> S.Atom "Pmakebytes" | Pbyteslength -> S.Atom "Pbyteslength" - | Pgetbytesitem -> S.Atom "Pgetbytesitem" - | Psetbytesitem -> S.Atom "Psetbytesitem" + | Pgetbytesitem { safe = safe__012_ } -> + let bnds__011_ = ([] : _ Stdlib.List.t) in + let bnds__011_ = + let arg__013_ = Moon_sexp_conv.sexp_of_bool safe__012_ in + (S.List [ S.Atom "safe"; arg__013_ ] :: bnds__011_ : _ Stdlib.List.t) + in + S.List (S.Atom "Pgetbytesitem" :: bnds__011_) + | Psetbytesitem { safe = safe__015_ } -> + let bnds__014_ = ([] : _ Stdlib.List.t) in + let bnds__014_ = + let arg__016_ = Moon_sexp_conv.sexp_of_bool safe__015_ in + (S.List [ S.Atom "safe"; arg__016_ ] :: bnds__014_ : _ Stdlib.List.t) + in + S.List (S.Atom "Psetbytesitem" :: bnds__014_) | Pnot -> S.Atom "Pnot" - | Praise -> S.Atom "Praise" | Ppanic -> S.Atom "Ppanic" | Punreachable -> S.Atom "Punreachable" | Pcatch -> S.Atom "Pcatch" - | Psequand -> S.Atom "Psequand" - | Psequor -> S.Atom "Psequor" | Pstringlength -> S.Atom "Pstringlength" | Pstringequal -> S.Atom "Pstringequal" - | Pcast { kind = kind__009_ } -> - let bnds__008_ = ([] : _ Stdlib.List.t) in - let bnds__008_ = - let arg__010_ = sexp_of_cast_kind kind__009_ in - (S.List [ S.Atom "kind"; arg__010_ ] :: bnds__008_ : _ Stdlib.List.t) + | Pbytesequal -> S.Atom "Pbytesequal" + | Pcast { kind = kind__018_ } -> + let bnds__017_ = ([] : _ Stdlib.List.t) in + let bnds__017_ = + let arg__019_ = sexp_of_cast_kind kind__018_ in + (S.List [ S.Atom "kind"; arg__019_ ] :: bnds__017_ : _ Stdlib.List.t) in - S.List (S.Atom "Pcast" :: bnds__008_) - | Pconvert { kind = kind__012_; from = from__014_; to_ = to___016_ } -> - let bnds__011_ = ([] : _ Stdlib.List.t) in - let bnds__011_ = - let arg__017_ = sexp_of_operand_type to___016_ in - (S.List [ S.Atom "to_"; arg__017_ ] :: bnds__011_ : _ Stdlib.List.t) + S.List (S.Atom "Pcast" :: bnds__017_) + | Pconvert { kind = kind__021_; from = from__023_; to_ = to___025_ } -> + let bnds__020_ = ([] : _ Stdlib.List.t) in + let bnds__020_ = + let arg__026_ = sexp_of_operand_type to___025_ in + (S.List [ S.Atom "to_"; arg__026_ ] :: bnds__020_ : _ Stdlib.List.t) in - let bnds__011_ = - let arg__015_ = sexp_of_operand_type from__014_ in - (S.List [ S.Atom "from"; arg__015_ ] :: bnds__011_ : _ Stdlib.List.t) + let bnds__020_ = + let arg__024_ = sexp_of_operand_type from__023_ in + (S.List [ S.Atom "from"; arg__024_ ] :: bnds__020_ : _ Stdlib.List.t) in - let bnds__011_ = - let arg__013_ = sexp_of_convert_kind kind__012_ in - (S.List [ S.Atom "kind"; arg__013_ ] :: bnds__011_ : _ Stdlib.List.t) + let bnds__020_ = + let arg__022_ = sexp_of_convert_kind kind__021_ in + (S.List [ S.Atom "kind"; arg__022_ ] :: bnds__020_ : _ Stdlib.List.t) in - S.List (S.Atom "Pconvert" :: bnds__011_) - | Parith { operand_type = operand_type__019_; operator = operator__021_ } + S.List (S.Atom "Pconvert" :: bnds__020_) + | Parith { operand_type = operand_type__028_; operator = operator__030_ } -> - let bnds__018_ = ([] : _ Stdlib.List.t) in - let bnds__018_ = - let arg__022_ = sexp_of_arith_operator operator__021_ in - (S.List [ S.Atom "operator"; arg__022_ ] :: bnds__018_ + let bnds__027_ = ([] : _ Stdlib.List.t) in + let bnds__027_ = + let arg__031_ = sexp_of_arith_operator operator__030_ in + (S.List [ S.Atom "operator"; arg__031_ ] :: bnds__027_ : _ Stdlib.List.t) in - let bnds__018_ = - let arg__020_ = sexp_of_operand_type operand_type__019_ in - (S.List [ S.Atom "operand_type"; arg__020_ ] :: bnds__018_ + let bnds__027_ = + let arg__029_ = sexp_of_operand_type operand_type__028_ in + (S.List [ S.Atom "operand_type"; arg__029_ ] :: bnds__027_ : _ Stdlib.List.t) in - S.List (S.Atom "Parith" :: bnds__018_) - | Pbitwise { operand_type = operand_type__024_; operator = operator__026_ } + S.List (S.Atom "Parith" :: bnds__027_) + | Pbitwise { operand_type = operand_type__033_; operator = operator__035_ } -> - let bnds__023_ = ([] : _ Stdlib.List.t) in - let bnds__023_ = - let arg__027_ = sexp_of_bitwise_operator operator__026_ in - (S.List [ S.Atom "operator"; arg__027_ ] :: bnds__023_ + let bnds__032_ = ([] : _ Stdlib.List.t) in + let bnds__032_ = + let arg__036_ = sexp_of_bitwise_operator operator__035_ in + (S.List [ S.Atom "operator"; arg__036_ ] :: bnds__032_ : _ Stdlib.List.t) in - let bnds__023_ = - let arg__025_ = sexp_of_operand_type operand_type__024_ in - (S.List [ S.Atom "operand_type"; arg__025_ ] :: bnds__023_ + let bnds__032_ = + let arg__034_ = sexp_of_operand_type operand_type__033_ in + (S.List [ S.Atom "operand_type"; arg__034_ ] :: bnds__032_ : _ Stdlib.List.t) in - S.List (S.Atom "Pbitwise" :: bnds__023_) + S.List (S.Atom "Pbitwise" :: bnds__032_) | Pcomparison - { operand_type = operand_type__029_; operator = operator__031_ } -> - let bnds__028_ = ([] : _ Stdlib.List.t) in - let bnds__028_ = - let arg__032_ = sexp_of_comparison operator__031_ in - (S.List [ S.Atom "operator"; arg__032_ ] :: bnds__028_ + { operand_type = operand_type__038_; operator = operator__040_ } -> + let bnds__037_ = ([] : _ Stdlib.List.t) in + let bnds__037_ = + let arg__041_ = sexp_of_comparison operator__040_ in + (S.List [ S.Atom "operator"; arg__041_ ] :: bnds__037_ : _ Stdlib.List.t) in - let bnds__028_ = - let arg__030_ = sexp_of_operand_type operand_type__029_ in - (S.List [ S.Atom "operand_type"; arg__030_ ] :: bnds__028_ + let bnds__037_ = + let arg__039_ = sexp_of_operand_type operand_type__038_ in + (S.List [ S.Atom "operand_type"; arg__039_ ] :: bnds__037_ : _ Stdlib.List.t) in - S.List (S.Atom "Pcomparison" :: bnds__028_) - | Pcompare arg0__033_ -> - let res0__034_ = sexp_of_operand_type arg0__033_ in - S.List [ S.Atom "Pcompare"; res0__034_ ] - | Pfixedarray_make { kind = kind__036_ } -> - let bnds__035_ = ([] : _ Stdlib.List.t) in - let bnds__035_ = - let arg__037_ = sexp_of_make_array_kind kind__036_ in - (S.List [ S.Atom "kind"; arg__037_ ] :: bnds__035_ : _ Stdlib.List.t) + S.List (S.Atom "Pcomparison" :: bnds__037_) + | Pcompare arg0__042_ -> + let res0__043_ = sexp_of_operand_type arg0__042_ in + S.List [ S.Atom "Pcompare"; res0__043_ ] + | Pfixedarray_make { kind = kind__045_ } -> + let bnds__044_ = ([] : _ Stdlib.List.t) in + let bnds__044_ = + let arg__046_ = sexp_of_make_array_kind kind__045_ in + (S.List [ S.Atom "kind"; arg__046_ ] :: bnds__044_ : _ Stdlib.List.t) in - S.List (S.Atom "Pfixedarray_make" :: bnds__035_) - | Pfixedarray_get_item { kind = kind__039_ } -> - let bnds__038_ = ([] : _ Stdlib.List.t) in - let bnds__038_ = - let arg__040_ = sexp_of_array_get_kind kind__039_ in - (S.List [ S.Atom "kind"; arg__040_ ] :: bnds__038_ : _ Stdlib.List.t) + S.List (S.Atom "Pfixedarray_make" :: bnds__044_) + | Pfixedarray_get_item { kind = kind__048_ } -> + let bnds__047_ = ([] : _ Stdlib.List.t) in + let bnds__047_ = + let arg__049_ = sexp_of_array_get_kind kind__048_ in + (S.List [ S.Atom "kind"; arg__049_ ] :: bnds__047_ : _ Stdlib.List.t) in - S.List (S.Atom "Pfixedarray_get_item" :: bnds__038_) - | Pfixedarray_set_item { set_kind = set_kind__042_ } -> - let bnds__041_ = ([] : _ Stdlib.List.t) in - let bnds__041_ = - let arg__043_ = sexp_of_array_set_kind set_kind__042_ in - (S.List [ S.Atom "set_kind"; arg__043_ ] :: bnds__041_ + S.List (S.Atom "Pfixedarray_get_item" :: bnds__047_) + | Pfixedarray_set_item { set_kind = set_kind__051_ } -> + let bnds__050_ = ([] : _ Stdlib.List.t) in + let bnds__050_ = + let arg__052_ = sexp_of_array_set_kind set_kind__051_ in + (S.List [ S.Atom "set_kind"; arg__052_ ] :: bnds__050_ : _ Stdlib.List.t) in - S.List (S.Atom "Pfixedarray_set_item" :: bnds__041_) - | Penum_field { index = index__045_; tag = tag__047_ } -> - let bnds__044_ = ([] : _ Stdlib.List.t) in - let bnds__044_ = - let arg__048_ = Constr_info.sexp_of_constr_tag tag__047_ in - (S.List [ S.Atom "tag"; arg__048_ ] :: bnds__044_ : _ Stdlib.List.t) + S.List (S.Atom "Pfixedarray_set_item" :: bnds__050_) + | Penum_field { index = index__054_; tag = tag__056_ } -> + let bnds__053_ = ([] : _ Stdlib.List.t) in + let bnds__053_ = + let arg__057_ = Constr_info.sexp_of_constr_tag tag__056_ in + (S.List [ S.Atom "tag"; arg__057_ ] :: bnds__053_ : _ Stdlib.List.t) in - let bnds__044_ = - let arg__046_ = Moon_sexp_conv.sexp_of_int index__045_ in - (S.List [ S.Atom "index"; arg__046_ ] :: bnds__044_ + let bnds__053_ = + let arg__055_ = Moon_sexp_conv.sexp_of_int index__054_ in + (S.List [ S.Atom "index"; arg__055_ ] :: bnds__053_ : _ Stdlib.List.t) in - S.List (S.Atom "Penum_field" :: bnds__044_) - | Pset_enum_field { index = index__050_; tag = tag__052_ } -> - let bnds__049_ = ([] : _ Stdlib.List.t) in - let bnds__049_ = - let arg__053_ = Constr_info.sexp_of_constr_tag tag__052_ in - (S.List [ S.Atom "tag"; arg__053_ ] :: bnds__049_ : _ Stdlib.List.t) + S.List (S.Atom "Penum_field" :: bnds__053_) + | Pset_enum_field { index = index__059_; tag = tag__061_ } -> + let bnds__058_ = ([] : _ Stdlib.List.t) in + let bnds__058_ = + let arg__062_ = Constr_info.sexp_of_constr_tag tag__061_ in + (S.List [ S.Atom "tag"; arg__062_ ] :: bnds__058_ : _ Stdlib.List.t) in - let bnds__049_ = - let arg__051_ = Moon_sexp_conv.sexp_of_int index__050_ in - (S.List [ S.Atom "index"; arg__051_ ] :: bnds__049_ + let bnds__058_ = + let arg__060_ = Moon_sexp_conv.sexp_of_int index__059_ in + (S.List [ S.Atom "index"; arg__060_ ] :: bnds__058_ : _ Stdlib.List.t) in - S.List (S.Atom "Pset_enum_field" :: bnds__049_) + S.List (S.Atom "Pset_enum_field" :: bnds__058_) | Pclosure_to_extern_ref -> S.Atom "Pclosure_to_extern_ref" | Prefeq -> S.Atom "Prefeq" | Parray_make -> S.Atom "Parray_make" @@ -284,31 +312,34 @@ include struct | Pnull_string_extern -> S.Atom "Pnull_string_extern" | Pis_null -> S.Atom "Pis_null" | Pas_non_null -> S.Atom "Pas_non_null" - | Pmake_value_or_error { tag = tag__055_ } -> - let bnds__054_ = ([] : _ Stdlib.List.t) in - let bnds__054_ = - let arg__056_ = Basic_constr_info.sexp_of_constr_tag tag__055_ in - (S.List [ S.Atom "tag"; arg__056_ ] :: bnds__054_ : _ Stdlib.List.t) + | Pmake_value_or_error { tag = tag__064_ } -> + let bnds__063_ = ([] : _ Stdlib.List.t) in + let bnds__063_ = + let arg__065_ = Basic_constr_info.sexp_of_constr_tag tag__064_ in + (S.List [ S.Atom "tag"; arg__065_ ] :: bnds__063_ : _ Stdlib.List.t) in - S.List (S.Atom "Pmake_value_or_error" :: bnds__054_) + S.List (S.Atom "Pmake_value_or_error" :: bnds__063_) | Pprintln -> S.Atom "Pprintln" | Perror_to_string -> S.Atom "Perror_to_string" | Pcall_object_method - { method_index = method_index__058_; method_name = method_name__060_ } + { method_index = method_index__067_; method_name = method_name__069_ } -> - let bnds__057_ = ([] : _ Stdlib.List.t) in - let bnds__057_ = - let arg__061_ = Moon_sexp_conv.sexp_of_string method_name__060_ in - (S.List [ S.Atom "method_name"; arg__061_ ] :: bnds__057_ + let bnds__066_ = ([] : _ Stdlib.List.t) in + let bnds__066_ = + let arg__070_ = Moon_sexp_conv.sexp_of_string method_name__069_ in + (S.List [ S.Atom "method_name"; arg__070_ ] :: bnds__066_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__059_ = Moon_sexp_conv.sexp_of_int method_index__058_ in - (S.List [ S.Atom "method_index"; arg__059_ ] :: bnds__057_ + let bnds__066_ = + let arg__068_ = Moon_sexp_conv.sexp_of_int method_index__067_ in + (S.List [ S.Atom "method_index"; arg__068_ ] :: bnds__066_ : _ Stdlib.List.t) in - S.List (S.Atom "Pcall_object_method" :: bnds__057_) + S.List (S.Atom "Pcall_object_method" :: bnds__066_) | Pany_to_string -> S.Atom "Pany_to_string" + | Pget_current_continuation -> S.Atom "Pget_current_continuation" + | Prun_async -> S.Atom "Prun_async" + | Praw_func_to_func_ref -> S.Atom "Praw_func_to_func_ref" : prim -> S.t) and sexp_of_make_array_kind = @@ -343,28 +374,253 @@ include struct and _ = sexp_of_make_array_kind and _ = sexp_of_array_get_kind and _ = sexp_of_array_set_kind + + let rec equal_operand_type = + (fun a__071_ -> fun b__072_ -> Stdlib.( = ) a__071_ b__072_ + : operand_type -> operand_type -> bool) + + and equal_convert_kind = + (fun a__073_ -> fun b__074_ -> Stdlib.( = ) a__073_ b__074_ + : convert_kind -> convert_kind -> bool) + + and equal_arith_operator = + (fun a__075_ -> fun b__076_ -> Stdlib.( = ) a__075_ b__076_ + : arith_operator -> arith_operator -> bool) + + and equal_bitwise_operator = + (fun a__077_ -> fun b__078_ -> Stdlib.( = ) a__077_ b__078_ + : bitwise_operator -> bitwise_operator -> bool) + + and equal_comparison = + (fun a__079_ -> fun b__080_ -> Stdlib.( = ) a__079_ b__080_ + : comparison -> comparison -> bool) + + and equal_cast_kind = + (fun a__081_ -> fun b__082_ -> Stdlib.( = ) a__081_ b__082_ + : cast_kind -> cast_kind -> bool) + + and equal_prim = + (fun a__083_ -> + fun b__084_ -> + if Stdlib.( == ) a__083_ b__084_ then true + else + match (a__083_, b__084_) with + | Pfixedarray_length, Pfixedarray_length -> true + | Pfixedarray_length, _ -> false + | _, Pfixedarray_length -> false + | Pccall _a__085_, Pccall _b__086_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__085_.arity : int) _b__086_.arity) + (Stdlib.( = ) (_a__085_.func_name : string) _b__086_.func_name) + | Pccall _, _ -> false + | _, Pccall _ -> false + | Pintrinsic _a__087_, Pintrinsic _b__088_ -> + Moon_intrinsic.equal _a__087_ _b__088_ + | Pintrinsic _, _ -> false + | _, Pintrinsic _ -> false + | Pgetstringitem _a__089_, Pgetstringitem _b__090_ -> + Stdlib.( = ) (_a__089_.safe : bool) _b__090_.safe + | Pgetstringitem _, _ -> false + | _, Pgetstringitem _ -> false + | Pignore, Pignore -> true + | Pignore, _ -> false + | _, Pignore -> false + | Pidentity, Pidentity -> true + | Pidentity, _ -> false + | _, Pidentity -> false + | Pmakebytes, Pmakebytes -> true + | Pmakebytes, _ -> false + | _, Pmakebytes -> false + | Pbyteslength, Pbyteslength -> true + | Pbyteslength, _ -> false + | _, Pbyteslength -> false + | Pgetbytesitem _a__091_, Pgetbytesitem _b__092_ -> + Stdlib.( = ) (_a__091_.safe : bool) _b__092_.safe + | Pgetbytesitem _, _ -> false + | _, Pgetbytesitem _ -> false + | Psetbytesitem _a__093_, Psetbytesitem _b__094_ -> + Stdlib.( = ) (_a__093_.safe : bool) _b__094_.safe + | Psetbytesitem _, _ -> false + | _, Psetbytesitem _ -> false + | Pnot, Pnot -> true + | Pnot, _ -> false + | _, Pnot -> false + | Ppanic, Ppanic -> true + | Ppanic, _ -> false + | _, Ppanic -> false + | Punreachable, Punreachable -> true + | Punreachable, _ -> false + | _, Punreachable -> false + | Pcatch, Pcatch -> true + | Pcatch, _ -> false + | _, Pcatch -> false + | Pstringlength, Pstringlength -> true + | Pstringlength, _ -> false + | _, Pstringlength -> false + | Pstringequal, Pstringequal -> true + | Pstringequal, _ -> false + | _, Pstringequal -> false + | Pbytesequal, Pbytesequal -> true + | Pbytesequal, _ -> false + | _, Pbytesequal -> false + | Pcast _a__095_, Pcast _b__096_ -> + equal_cast_kind _a__095_.kind _b__096_.kind + | Pcast _, _ -> false + | _, Pcast _ -> false + | Pconvert _a__097_, Pconvert _b__098_ -> + Stdlib.( && ) + (equal_convert_kind _a__097_.kind _b__098_.kind) + (Stdlib.( && ) + (equal_operand_type _a__097_.from _b__098_.from) + (equal_operand_type _a__097_.to_ _b__098_.to_)) + | Pconvert _, _ -> false + | _, Pconvert _ -> false + | Parith _a__099_, Parith _b__100_ -> + Stdlib.( && ) + (equal_operand_type _a__099_.operand_type _b__100_.operand_type) + (equal_arith_operator _a__099_.operator _b__100_.operator) + | Parith _, _ -> false + | _, Parith _ -> false + | Pbitwise _a__101_, Pbitwise _b__102_ -> + Stdlib.( && ) + (equal_operand_type _a__101_.operand_type _b__102_.operand_type) + (equal_bitwise_operator _a__101_.operator _b__102_.operator) + | Pbitwise _, _ -> false + | _, Pbitwise _ -> false + | Pcomparison _a__103_, Pcomparison _b__104_ -> + Stdlib.( && ) + (equal_operand_type _a__103_.operand_type _b__104_.operand_type) + (equal_comparison _a__103_.operator _b__104_.operator) + | Pcomparison _, _ -> false + | _, Pcomparison _ -> false + | Pcompare _a__105_, Pcompare _b__106_ -> + equal_operand_type _a__105_ _b__106_ + | Pcompare _, _ -> false + | _, Pcompare _ -> false + | Pfixedarray_make _a__107_, Pfixedarray_make _b__108_ -> + equal_make_array_kind _a__107_.kind _b__108_.kind + | Pfixedarray_make _, _ -> false + | _, Pfixedarray_make _ -> false + | Pfixedarray_get_item _a__109_, Pfixedarray_get_item _b__110_ -> + equal_array_get_kind _a__109_.kind _b__110_.kind + | Pfixedarray_get_item _, _ -> false + | _, Pfixedarray_get_item _ -> false + | Pfixedarray_set_item _a__111_, Pfixedarray_set_item _b__112_ -> + equal_array_set_kind _a__111_.set_kind _b__112_.set_kind + | Pfixedarray_set_item _, _ -> false + | _, Pfixedarray_set_item _ -> false + | Penum_field _a__113_, Penum_field _b__114_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__113_.index : int) _b__114_.index) + (Constr_info.equal_constr_tag _a__113_.tag _b__114_.tag) + | Penum_field _, _ -> false + | _, Penum_field _ -> false + | Pset_enum_field _a__115_, Pset_enum_field _b__116_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__115_.index : int) _b__116_.index) + (Constr_info.equal_constr_tag _a__115_.tag _b__116_.tag) + | Pset_enum_field _, _ -> false + | _, Pset_enum_field _ -> false + | Pclosure_to_extern_ref, Pclosure_to_extern_ref -> true + | Pclosure_to_extern_ref, _ -> false + | _, Pclosure_to_extern_ref -> false + | Prefeq, Prefeq -> true + | Prefeq, _ -> false + | _, Prefeq -> false + | Parray_make, Parray_make -> true + | Parray_make, _ -> false + | _, Parray_make -> false + | Pnull, Pnull -> true + | Pnull, _ -> false + | _, Pnull -> false + | Pnull_string_extern, Pnull_string_extern -> true + | Pnull_string_extern, _ -> false + | _, Pnull_string_extern -> false + | Pis_null, Pis_null -> true + | Pis_null, _ -> false + | _, Pis_null -> false + | Pas_non_null, Pas_non_null -> true + | Pas_non_null, _ -> false + | _, Pas_non_null -> false + | Pmake_value_or_error _a__117_, Pmake_value_or_error _b__118_ -> + Basic_constr_info.equal_constr_tag _a__117_.tag _b__118_.tag + | Pmake_value_or_error _, _ -> false + | _, Pmake_value_or_error _ -> false + | Pprintln, Pprintln -> true + | Pprintln, _ -> false + | _, Pprintln -> false + | Perror_to_string, Perror_to_string -> true + | Perror_to_string, _ -> false + | _, Perror_to_string -> false + | Pcall_object_method _a__119_, Pcall_object_method _b__120_ -> + Stdlib.( && ) + (Stdlib.( = ) + (_a__119_.method_index : int) + _b__120_.method_index) + (Stdlib.( = ) + (_a__119_.method_name : string) + _b__120_.method_name) + | Pcall_object_method _, _ -> false + | _, Pcall_object_method _ -> false + | Pany_to_string, Pany_to_string -> true + | Pany_to_string, _ -> false + | _, Pany_to_string -> false + | Pget_current_continuation, Pget_current_continuation -> true + | Pget_current_continuation, _ -> false + | _, Pget_current_continuation -> false + | Prun_async, Prun_async -> true + | Prun_async, _ -> false + | _, Prun_async -> false + | Praw_func_to_func_ref, Praw_func_to_func_ref -> true + : prim -> prim -> bool) + + and equal_make_array_kind = + (fun a__121_ -> fun b__122_ -> Stdlib.( = ) a__121_ b__122_ + : make_array_kind -> make_array_kind -> bool) + + and equal_array_get_kind = + (fun a__123_ -> fun b__124_ -> Stdlib.( = ) a__123_ b__124_ + : array_get_kind -> array_get_kind -> bool) + + and equal_array_set_kind = + (fun a__125_ -> fun b__126_ -> Stdlib.( = ) a__125_ b__126_ + : array_set_kind -> array_set_kind -> bool) + + let _ = equal_operand_type + and _ = equal_convert_kind + and _ = equal_arith_operator + and _ = equal_bitwise_operator + and _ = equal_comparison + and _ = equal_cast_kind + and _ = equal_prim + and _ = equal_make_array_kind + and _ = equal_array_get_kind + and _ = equal_array_set_kind end -let sexp_of_prim (x : prim) : S.t = - match x with - | Pccall { func_name; _ } -> Atom ("@" ^ func_name) - | Parith { operand_type; operator } -> - (List - (List.cons - (Atom "Parith" : S.t) - (List.cons - (sexp_of_operand_type operand_type : S.t) - ([ sexp_of_arith_operator operator ] : S.t list))) - : S.t) - | Pcomparison { operand_type; operator } -> - (List - (List.cons - (Atom "Pcomparison" : S.t) - (List.cons - (sexp_of_operand_type operand_type : S.t) - ([ sexp_of_comparison operator ] : S.t list))) - : S.t) - | _ -> sexp_of_prim x +let sexp_of_prim (x : prim) = + (match x with + | Pccall { func_name; _ } -> Atom ("@" ^ func_name) + | Parith { operand_type; operator } -> + (List + (List.cons + (Atom "Parith" : S.t) + (List.cons + (sexp_of_operand_type operand_type : S.t) + ([ sexp_of_arith_operator operator ] : S.t list))) + : S.t) + | Pcomparison { operand_type; operator } -> + (List + (List.cons + (Atom "Pcomparison" : S.t) + (List.cons + (sexp_of_operand_type operand_type : S.t) + ([ sexp_of_comparison operator ] : S.t list))) + : S.t) + | Pgetbytesitem { safe = true } -> (Atom "Pgetbytesitem" : S.t) + | Psetbytesitem { safe = true } -> (Atom "Psetbytesitem" : S.t) + | _ -> sexp_of_prim x + : S.t) let compare_int = Pcompare I32 let compare_int64 = Pcompare I64 @@ -417,7 +673,9 @@ let lt_double = Pcomparison { operand_type = F64; operator = Lt } let ne_double = Pcomparison { operand_type = F64; operator = Ne } let add_string = Pccall { func_name = "add_string"; arity = 2 } let incref = Pccall { func_name = "incref"; arity = 1 } -let drop = Pccall { func_name = "decref"; arity = 1 } +let incref_nullable = Pccall { func_name = "incref_nullable"; arity = 1 } +let decref = Pccall { func_name = "decref"; arity = 1 } +let decref_nullable = Pccall { func_name = "decref_nullable"; arity = 1 } let prim_table = Hash_string.of_list @@ -433,7 +691,6 @@ let prim_table = ( "%unsafe_obj_get_field", Pccall { func_name = "unsafe_obj_get_field"; arity = 2 } ); ("%println", Pprintln); - ("%abort", Praise); ("%panic", Ppanic); ("%unreachable", Punreachable); ("%control.catch", Pcatch); @@ -444,7 +701,8 @@ let prim_table = ("%loc_ghost", Pccall { arity = 0; func_name = "loc_ghost" }); ("%loc_to_string", Pidentity); ("%string_length", Pstringlength); - ("%string_get", Pgetstringitem); + ("%string_get", Pgetstringitem { safe = true }); + ("%string.unsafe_get", Pgetstringitem { safe = false }); ("%string_add", add_string); ("%string_eq", equal_string); ("%string_to_string", Pidentity); @@ -457,10 +715,12 @@ let prim_table = ("%fixedarray.length", Pfixedarray_length); ("%fixedarray.make", Pfixedarray_make { kind = LenAndInit }); ("%fixedarray.make_uninit", Pfixedarray_make { kind = Uninit }); - ("%bytes_get", Pgetbytesitem); - ("%bytes_set", Psetbytesitem); + ("%bytes_get", Pgetbytesitem { safe = true }); + ("%bytes_set", Psetbytesitem { safe = true }); ("%bytes_make", Pmakebytes); ("%bytes_length", Pbyteslength); + ("%bytes.unsafe_get", Pgetbytesitem { safe = false }); + ("%bytes.equal", Pbytesequal); ("%i32_neg", Parith { operand_type = I32; operator = Neg }); ("%i32_add", Parith { operand_type = I32; operator = Add }); ("%i32_sub", Parith { operand_type = I32; operator = Sub }); @@ -543,6 +803,7 @@ let prim_table = ("%f32.mul", Parith { operand_type = F32; operator = Mul }); ("%f32.div", Parith { operand_type = F32; operator = Div }); ("%f32.sqrt", Parith { operand_type = F32; operator = Sqrt }); + ("%f32.abs", Parith { operand_type = F32; operator = Abs }); ("%f32.eq", Pcomparison { operand_type = F32; operator = Eq }); ("%f32.ne", Pcomparison { operand_type = F32; operator = Ne }); ("%f32.compare", compare_float32); @@ -554,6 +815,17 @@ let prim_table = ("%u32.to_f32", Pconvert { from = U32; to_ = F32; kind = Convert }); ("%u64.to_f32", Pconvert { from = U64; to_ = F32; kind = Convert }); ("%f32.to_i32", Pconvert { from = F32; to_ = I32; kind = Convert }); + ("%f32.to_u32", Pconvert { from = F32; to_ = U32; kind = Convert }); + ("%f32.to_i64", Pconvert { from = F32; to_ = I64; kind = Convert }); + ("%f32.to_u64", Pconvert { from = F32; to_ = U64; kind = Convert }); + ( "%f32.to_i32_saturate", + Pconvert { from = F32; to_ = I32; kind = Saturate } ); + ( "%f32.to_u32_saturate", + Pconvert { from = F32; to_ = U32; kind = Saturate } ); + ( "%f32.to_i64_saturate", + Pconvert { from = F32; to_ = I64; kind = Saturate } ); + ( "%f32.to_u64_saturate", + Pconvert { from = F32; to_ = U64; kind = Saturate } ); ( "%f32.to_i32_reinterpret", Pconvert { from = F32; to_ = I32; kind = Reinterpret } ); ( "%i32.to_f32_reinterpret", @@ -564,6 +836,7 @@ let prim_table = ("%f64_mul", Parith { operand_type = F64; operator = Mul }); ("%f64_div", Parith { operand_type = F64; operator = Div }); ("%f64_sqrt", Parith { operand_type = F64; operator = Sqrt }); + ("%f64.abs", Parith { operand_type = F64; operator = Abs }); ("%f64_eq", Pcomparison { operand_type = F64; operator = Eq }); ("%f64_ne", Pcomparison { operand_type = F64; operator = Ne }); ("%f64_compare", compare_float); @@ -573,6 +846,18 @@ let prim_table = ("%char_eq", Pcomparison { operand_type = I32; operator = Eq }); ("%char_compare", compare_char); ("%char_default", Pccall { func_name = "default_char"; arity = 0 }); + ("%u16_to_i32", Pconvert { from = U16; to_ = I32; kind = Convert }); + ("%u16_to_i64", Pconvert { from = U16; to_ = I64; kind = Convert }); + ("%u16_to_byte", Pconvert { from = U16; to_ = U8; kind = Convert }); + ("%i32_to_u16", Pconvert { from = I32; to_ = U16; kind = Convert }); + ("%i64_to_u16", Pconvert { from = I64; to_ = U16; kind = Convert }); + ("%byte_to_u16", Pconvert { from = U8; to_ = U16; kind = Convert }); + ("%i16_to_i32", Pconvert { from = I16; to_ = I32; kind = Convert }); + ("%i16_to_i64", Pconvert { from = I16; to_ = I64; kind = Convert }); + ("%i16_to_byte", Pconvert { from = I16; to_ = U8; kind = Convert }); + ("%i32_to_i16", Pconvert { from = I32; to_ = I16; kind = Convert }); + ("%i64_to_i16", Pconvert { from = I64; to_ = I16; kind = Convert }); + ("%byte_to_i16", Pconvert { from = U8; to_ = I16; kind = Convert }); ("%i32_to_i64", Pconvert { from = I32; to_ = I64; kind = Convert }); ("%i32_to_f64", Pconvert { from = I32; to_ = F64; kind = Convert }); ("%i64_to_i32", Pconvert { from = I64; to_ = I32; kind = Convert }); @@ -581,7 +866,11 @@ let prim_table = Pconvert { from = I64; to_ = F64; kind = Reinterpret } ); ("%f64_default", Pccall { func_name = "default_float"; arity = 0 }); ("%f64_to_i32", Pconvert { from = F64; to_ = I32; kind = Convert }); + ( "%f64_to_i32_saturate", + Pconvert { from = F64; to_ = I32; kind = Saturate } ); ("%f64_to_i64", Pconvert { from = F64; to_ = I64; kind = Convert }); + ( "%f64_to_i64_saturate", + Pconvert { from = F64; to_ = I64; kind = Saturate } ); ( "%f64_to_i64_reinterpret", Pconvert { from = F64; to_ = I64; kind = Reinterpret } ); ("%byte_to_int", Pidentity); @@ -599,8 +888,12 @@ let prim_table = ( "%i64.to_u64_reinterpret", Pconvert { from = I64; to_ = U64; kind = Reinterpret } ); ("%f64.to_u32", Pconvert { from = F64; to_ = U32; kind = Convert }); + ( "%f64.to_u32_saturate", + Pconvert { from = F64; to_ = U32; kind = Saturate } ); ("%u32.to_u64", Pconvert { from = U32; to_ = U64; kind = Convert }); ("%f64.to_u64", Pconvert { from = F64; to_ = U64; kind = Convert }); + ( "%f64.to_u64_saturate", + Pconvert { from = F64; to_ = U64; kind = Saturate } ); ("%u32.to_f64", Pconvert { from = U32; to_ = F64; kind = Convert }); ("%u64.to_u32", Pconvert { from = U64; to_ = U32; kind = Convert }); ("%u64.to_i32", Pconvert { from = U64; to_ = I32; kind = Convert }); @@ -631,26 +924,32 @@ let prim_table = ("%array.unsafe_get", Pintrinsic Array_unsafe_get); ("%array.set", Pintrinsic Array_set); ("%array.unsafe_set", Pintrinsic Array_unsafe_set); + ("%arrayview.length", Pintrinsic ArrayView_length); + ("%arrayview.unsafe_get", Pintrinsic ArrayView_unsafe_get); + ("%arrayview.unsafe_set", Pintrinsic ArrayView_unsafe_set); + ("%arrayview.unsafe_as_view", Pintrinsic ArrayView_unsafe_as_view); + ("%async.suspend", Pget_current_continuation); + ("%async.run", Prun_async); ] -let find_prim (name : string) : prim option = - Hash_string.find_opt prim_table name +let find_prim (name : string) = + (Hash_string.find_opt prim_table name : prim option) let is_intrinsic (p : prim) = match p with Pintrinsic _ -> true | _ -> false let is_pure (prim : prim) = match prim with | Pfixedarray_length | Penum_field _ | Pnot | Pstringlength | Pstringequal - | Pignore | Pidentity | Psequor | Psequand | Pmakebytes | Pbyteslength + | Pbytesequal | Pignore | Pidentity | Pmakebytes | Pbyteslength | Pfixedarray_make _ | Pfixedarray_get_item { kind = Unsafe } | Parray_make | Parith _ | Pbitwise _ | Pconvert _ | Pcast _ | Pcomparison _ | Pcompare _ | Pclosure_to_extern_ref | Prefeq | Pnull | Pnull_string_extern | Pis_null | Pas_non_null | Pmake_value_or_error _ | Perror_to_string - | Pany_to_string -> + | Praw_func_to_func_ref | Pany_to_string -> true - | Pfixedarray_get_item _ | Pgetstringitem | Pgetbytesitem | Pccall _ - | Pintrinsic _ | Praise | Ppanic | Punreachable | Pcatch - | Pfixedarray_set_item _ | Psetbytesitem | Pset_enum_field _ | Pprintln - | Pcall_object_method _ -> - false \ No newline at end of file + | Pfixedarray_get_item _ | Pgetstringitem _ | Pgetbytesitem _ | Pccall _ + | Pintrinsic _ | Ppanic | Punreachable | Pcatch | Pfixedarray_set_item _ + | Psetbytesitem _ | Pset_enum_field _ | Pprintln | Pget_current_continuation + | Prun_async | Pcall_object_method _ -> + false diff --git a/src/printer.ml b/src/printer.ml index c16bf20..c58c4e2 100644 --- a/src/printer.ml +++ b/src/printer.ml @@ -38,7 +38,8 @@ let type_to_string_aux (ctx : printer_ctx) (ty : Stype.t) = let append s = Buffer.add_string buf s in let rec go (ty : Stype.t) = match ty with - | Tarrow { params_ty; ret_ty; err_ty } -> ( + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> ( + if is_async then append "async "; append "("; (match params_ty with | [] -> () @@ -56,6 +57,9 @@ let type_to_string_aux (ctx : printer_ctx) (ty : Stype.t) = append "("; gos ", " tys; append ")" + | T_constr { type_constructor = T_local { toplevel_id = _; name }; tys = _ } + -> + append name | T_constr { type_constructor = c; tys = args } -> ( append (Type_path_util.name c); match args with @@ -70,10 +74,14 @@ let type_to_string_aux (ctx : printer_ctx) (ty : Stype.t) = match ctx.type_param_names with | None -> append name_ | Some names -> append names.(index)) - | T_trait trait -> append (Type_path_util.name trait) + | T_trait trait -> + append "&"; + append (Type_path_util.name trait) | T_builtin T_unit -> append "Unit" | T_builtin T_bool -> append "Bool" | T_builtin T_byte -> append "Byte" + | T_builtin T_int16 -> append "Int16" + | T_builtin T_uint16 -> append "UInt16" | T_builtin T_char -> append "Char" | T_builtin T_int -> append "Int" | T_builtin T_int64 -> append "Int64" @@ -106,28 +114,34 @@ let type_pair_to_string typ1 typ2 = let toplevel_function_type_to_string ~arity typ = let ctx = make_ctx None in match (typ : Stype.t) with - | Tarrow { params_ty; ret_ty; err_ty } -> + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> let buf = Buffer.create 17 in let is_first = ref true in + if is_async then Buffer.add_string buf "async "; Buffer.add_char buf '('; - Fn_arity.iter2 arity params_ty (fun kind ty -> - if !is_first then is_first := false else Buffer.add_string buf ", "; - match kind with - | Positional _ -> Buffer.add_string buf (type_to_string_aux ctx ty) - | Labelled { label; _ } -> - Buffer.add_string buf (label ^ "~ : " : Stdlib.String.t); - Buffer.add_string buf (type_to_string_aux ctx ty) - | Optional { label; _ } -> - Buffer.add_string buf (label ^ "~ : " : Stdlib.String.t); - Buffer.add_string buf (type_to_string_aux ctx ty); - Buffer.add_string buf " = .." - | Autofill { label } -> - Buffer.add_string buf (label ^ "~ : " : Stdlib.String.t); - Buffer.add_string buf (type_to_string_aux ctx ty); - Buffer.add_string buf " = _" - | Question_optional { label } -> - Buffer.add_string buf (label ^ "? : " : Stdlib.String.t); - Buffer.add_string buf (type_to_string_aux ctx ty)); + Fn_arity.iter2 arity params_ty (fun kind -> + fun ty -> + if !is_first then is_first := false else Buffer.add_string buf ", "; + match kind with + | Positional _ -> Buffer.add_string buf (type_to_string_aux ctx ty) + | Labelled { label; _ } -> + Buffer.add_string buf + ((label ^ "~ : " : Stdlib.String.t) [@merlin.hide]); + Buffer.add_string buf (type_to_string_aux ctx ty) + | Optional { label; _ } -> + Buffer.add_string buf + ((label ^ "~ : " : Stdlib.String.t) [@merlin.hide]); + Buffer.add_string buf (type_to_string_aux ctx ty); + Buffer.add_string buf " = .." + | Autofill { label } -> + Buffer.add_string buf + ((label ^ "~ : " : Stdlib.String.t) [@merlin.hide]); + Buffer.add_string buf (type_to_string_aux ctx ty); + Buffer.add_string buf " = _" + | Question_optional { label } -> + Buffer.add_string buf + ((label ^ "? : " : Stdlib.String.t) [@merlin.hide]); + Buffer.add_string buf (type_to_string_aux ctx ty)); Buffer.add_string buf ") -> "; Buffer.add_string buf (type_to_string_aux ctx ret_ty); (match err_ty with @@ -143,12 +157,14 @@ let tvar_env_to_string (env : Tvar_env.t) = else let buf = Buffer.create 17 in Buffer.add_char buf '['; - Tvar_env.iteri env (fun i tvar_info -> - if i > 0 then Buffer.add_string buf ", "; - Buffer.add_string buf tvar_info.name; - Lst.iteri tvar_info.constraints (fun i c -> - if i = 0 then Buffer.add_string buf " : " - else Buffer.add_string buf " + "; - Buffer.add_string buf (Type_path_util.name c.trait))); + Tvar_env.iteri env (fun i -> + fun tvar_info -> + if i > 0 then Buffer.add_string buf ", "; + Buffer.add_string buf tvar_info.name; + Lst.iteri tvar_info.constraints ~f:(fun i -> + fun c -> + if i = 0 then Buffer.add_string buf " : " + else Buffer.add_string buf " + "; + Buffer.add_string buf (Type_path_util.name c.trait))); Buffer.add_char buf ']'; Buffer.contents buf diff --git a/src/riscv.ml b/src/riscv.ml index 76f5f0d..d9f6b89 100644 --- a/src/riscv.ml +++ b/src/riscv.ml @@ -54,4 +54,4 @@ let to_asm_string asm = | Label _ -> to_string asm | _ -> " " ^ to_string asm -let generate ssa = [] \ No newline at end of file +let generate _ssa = [] \ No newline at end of file diff --git a/src/riscv_generate.ml b/src/riscv_generate.ml index 09a5024..16de6f1 100644 --- a/src/riscv_generate.ml +++ b/src/riscv_generate.ml @@ -387,7 +387,7 @@ let deal_with_prim tac rd (prim: Primitive.prim) args = (* The whole set of args (including self) is needed. *) Vec.push tac (CallIndirect { rd; rs = fptr; args }) - | Pgetbytesitem -> + | Pgetbytesitem { safe = _ } -> let str = List.nth args 0 in let i = List.nth args 1 in @@ -395,7 +395,7 @@ let deal_with_prim tac rd (prim: Primitive.prim) args = Vec.push tac (Add { rd = altered; rs1 = str; rs2 = i }); Vec.push tac (Load { rd; rs = altered; offset = 0; byte = 1 }) - | Psetbytesitem -> + | Psetbytesitem { safe = _ } -> let str = List.nth args 0 in let i = List.nth args 1 in let item = List.nth args 2 in @@ -406,7 +406,7 @@ let deal_with_prim tac rd (prim: Primitive.prim) args = Vec.push tac (Assign { rd; rs = unit }) (* Be cautious that each `char` is 2 bytes long, which is extremely counter-intuitive. *) - | Pgetstringitem -> + | Pgetstringitem { safe = _ } -> let str = List.nth args 0 in let i = List.nth args 1 in @@ -550,8 +550,6 @@ let deal_with_prim tac rd (prim: Primitive.prim) args = | Primitive.Praise -> _ | Primitive.Punreachable -> _ | Primitive.Pcatch -> _ - | Primitive.Psequand -> _ - | Primitive.Psequor -> _ | Primitive.Pclosure_to_extern_ref -> _ | Primitive.Pnull_string_extern -> _ | Primitive.Perror_to_string -> _ @@ -703,45 +701,6 @@ let rec do_convert tac (expr: Mcore.expr) = | Cexpr_prim { prim; args; ty; _ } -> let rd = new_temp ty in (match prim, args with - | Psequand, [rs1; rs2] -> - (* Short circuiting, compile into if-else *) - (* rd = rs1 && rs2 -> rd = if (rs1) rs2 else false *) - let ifso = new_label "sequand_if_" in - let ifnot = new_label "sequand_else_" in - let ifexit = new_label "sequand_exit_" in - let cond = do_convert tac rs1 in - Vec.push tac (Branch { cond; ifso; ifnot }); - - Vec.push tac (Label ifso); - let rs = do_convert tac rs2 in - Vec.push tac (Assign { rd; rs }); - Vec.push tac (Jump ifexit); - - Vec.push tac (Label ifnot); - Vec.push tac (AssignInt { rd; imm = 0; }); - Vec.push tac (Jump ifexit); - - Vec.push tac (Label ifexit) - - | Psequor, [rs1; rs2] -> - (* Short circuiting, compile into if-else *) - (* rd = rs1 || rs2 -> rd = if (rs1) true else rs2 *) - let ifso = new_label "sequor_if_" in - let ifnot = new_label "sequor_else_" in - let ifexit = new_label "sequor_exit_" in - let cond = do_convert tac rs1 in - Vec.push tac (Branch { cond; ifso; ifnot }); - - Vec.push tac (Label ifso); - Vec.push tac (AssignInt { rd; imm = 1; }); - Vec.push tac (Jump ifexit); - - Vec.push tac (Label ifnot); - let rs = do_convert tac rs2 in - Vec.push tac (Assign { rd; rs }); - Vec.push tac (Jump ifexit); - - Vec.push tac (Label ifexit); | _ -> let args = List.map (fun expr -> do_convert tac expr) args in @@ -836,9 +795,9 @@ let rec do_convert tac (expr: Mcore.expr) = rd ) - | Cexpr_sequence { expr1; expr2; _ } -> - do_convert tac expr1 |> ignore; - do_convert tac expr2 + | Cexpr_sequence { exprs; last_expr; _ } -> + List.iter (fun expr -> do_convert tac expr |> ignore) exprs; + do_convert tac last_expr (* Meaning: access the `pos`-th field of `record` *) (* Here `record` might be a record type or a tuple *) @@ -854,7 +813,7 @@ let rec do_convert tac (expr: Mcore.expr) = rd | Mtype.T_tuple { tys } -> - let precede = Basic_lst.take pos tys in + let precede = Basic_lst.take tys pos in let sizes = List.map sizeof precede in let offset = List.fold_left (fun acc x -> acc + x) 0 sizes in Vec.push tac (Load { rd; rs; offset; byte }); @@ -1059,7 +1018,7 @@ let rec do_convert tac (expr: Mcore.expr) = Vec.push tac (Malloc { rd; size }); let args = List.map (fun x -> do_convert tac x) exprs in - let sizes = List.map (fun x -> sizeof x.ty) args |> Basic_lst.take (List.length args - 1) in + let sizes = List.map (fun x -> sizeof x.ty) args |> fun list -> Basic_lst.take list (List.length args - 1) in let offsets = 0 :: Basic_lst.cumsum sizes in List.iter2 (fun arg offset -> Vec.push tac (Store { rd = arg; rs = rd; offset; byte = sizeof arg.ty }) @@ -1201,7 +1160,7 @@ let rec do_convert tac (expr: Mcore.expr) = (* Then store all arguments *) List.iter2 (fun arg offset -> Vec.push tac (Store { rd = arg; rs = rd; offset = 4 + offset; byte = sizeof arg.ty }) - ) args (Basic_lst.take len offsets); + ) args (Basic_lst.take offsets len); rd | Cexpr_switch_constr { obj; cases; default; ty; _ } -> @@ -1489,7 +1448,7 @@ let rec do_convert tac (expr: Mcore.expr) = List.iter (fun x -> Vec.push vec (Char.code x); Vec.push vec 0) vals; - let values = len :: Vec.map_into_list vec Int.to_string in + let values = len :: Vec.map_into_list vec ~unorder:Int.to_string in slot := !slot + 1; (* Each of them is still a single byte, since we separated strings into two bytes *) @@ -1526,12 +1485,14 @@ let rec do_convert tac (expr: Mcore.expr) = Vec.push tac (AssignFP { rd; imm = v; }) | C_double { v; _ } -> Vec.push tac (AssignFP { rd; imm = v; }) + | C_byte { v; _ } -> + Vec.push tac (AssignInt { rd; imm = v }) | C_bigint _ -> failwith "TODO: riscv_ssa.ml: bigint not supported" ); rd | Cexpr_function _ -> - Printf.printf "unconverted: %s\n" (Mcore.sexp_of_expr expr |> S.to_string); + Printf.printf "unconverted: Cexpr_function\n"; failwith "riscv_generate.ml: Cexpr_function should have been converted into letfn" let generate_vtables () = @@ -1575,7 +1536,7 @@ let rec iter_expr f (expr: Mcore.expr) = | Cexpr_mutate { record; field } -> go record; go field | Cexpr_array { exprs } -> List.iter go exprs | Cexpr_assign { expr } -> go expr - | Cexpr_sequence { expr1; expr2 } -> go expr1; go expr2 + | Cexpr_sequence { exprs; last_expr; _ } -> List.iter go exprs; go last_expr | Cexpr_if { cond; ifso; ifnot } -> go cond; go ifso; Option.iter go ifnot | Cexpr_switch_constr { obj; cases; default } -> go obj; List.iter (fun (a, b, c) -> go c) cases; Option.iter go default | Cexpr_switch_constant { obj; cases; default } -> go obj; List.iter (fun (a, b) -> go b) cases; go default @@ -1631,8 +1592,8 @@ let rec map_expr f (expr: Mcore.expr) = | Cexpr_assign ({ expr } as x) -> Mcore.Cexpr_assign { x with expr = go expr } - | Cexpr_sequence ({ expr1; expr2 } as x) -> - Mcore.Cexpr_sequence { x with expr1 = go expr1; expr2 = go expr2 } + | Cexpr_sequence ({ exprs; last_expr; _ } as x) -> + Mcore.Cexpr_sequence { x with exprs = List.map go exprs; last_expr = go last_expr } | Cexpr_if ({ cond; ifso; ifnot } as x) -> Mcore.Cexpr_if { x with cond = go cond; ifso = go ifso; ifnot = Option.map go ifnot } diff --git a/src/riscv_ssa.ml b/src/riscv_ssa.ml index 5622ad0..c6f0efa 100644 --- a/src/riscv_ssa.ml +++ b/src/riscv_ssa.ml @@ -546,11 +546,11 @@ let reg_iter fd fs t = (** Iterate on `rd` only. *) let reg_iterd fd t = - reg_iter fd (fun x -> x) t + reg_iter fd (fun _ -> ()) t (** Iterate on `rs` only. *) let reg_iters fs t = - reg_iter (fun x -> x) fs t + reg_iter (fun _ -> ()) fs t (** Counter of temporaries. *) let slot = ref 0 diff --git a/src/rloc.ml b/src/rloc.ml index 88e7866..41d5a4b 100644 --- a/src/rloc.ml +++ b/src/rloc.ml @@ -21,13 +21,13 @@ include struct let _ = sexp_of_rpos let compare_rpos = - (fun a__001_ b__002_ -> Stdlib.compare (a__001_ : int) b__002_ + (fun a__001_ -> fun b__002_ -> Stdlib.compare (a__001_ : int) b__002_ : rpos -> rpos -> int) let _ = compare_rpos let equal_rpos = - (fun a__003_ b__004_ -> Stdlib.( = ) (a__003_ : int) b__004_ + (fun a__003_ -> fun b__004_ -> Stdlib.( = ) (a__003_ : int) b__004_ : rpos -> rpos -> bool) let _ = equal_rpos @@ -58,23 +58,25 @@ include struct let _ = sexp_of_t let compare = - (fun a__010_ b__011_ -> - if Stdlib.( == ) a__010_ b__011_ then 0 - else - match compare_rpos a__010_.start b__011_.start with - | 0 -> compare_rpos a__010_._end b__011_._end - | n -> n + (fun a__010_ -> + fun b__011_ -> + if Stdlib.( == ) a__010_ b__011_ then 0 + else + match compare_rpos a__010_.start b__011_.start with + | 0 -> compare_rpos a__010_._end b__011_._end + | n -> n : t -> t -> int) let _ = compare let equal = - (fun a__012_ b__013_ -> - if Stdlib.( == ) a__012_ b__013_ then true - else - Stdlib.( && ) - (equal_rpos a__012_.start b__013_.start) - (equal_rpos a__012_._end b__013_._end) + (fun a__012_ -> + fun b__013_ -> + if Stdlib.( == ) a__012_ b__013_ then true + else + Stdlib.( && ) + (equal_rpos a__012_.start b__013_.start) + (equal_rpos a__012_._end b__013_._end) : t -> t -> bool) let _ = equal @@ -89,38 +91,41 @@ include struct let sexp_of_loced : 'a. ('a -> S.t) -> 'a loced -> S.t = let (drop_if__019_ : t -> Stdlib.Bool.t) = hide_loc in - fun _of_a__014_ { v = v__016_; loc_ = loc___020_ } -> - let bnds__015_ = ([] : _ Stdlib.List.t) in - let bnds__015_ = - if drop_if__019_ loc___020_ then bnds__015_ - else - let arg__022_ = sexp_of_t loc___020_ in - let bnd__021_ = S.List [ S.Atom "loc_"; arg__022_ ] in - (bnd__021_ :: bnds__015_ : _ Stdlib.List.t) - in - let bnds__015_ = - let arg__017_ = _of_a__014_ v__016_ in - (S.List [ S.Atom "v"; arg__017_ ] :: bnds__015_ : _ Stdlib.List.t) - in - S.List bnds__015_ + fun _of_a__014_ -> + fun { v = v__016_; loc_ = loc___020_ } -> + let bnds__015_ = ([] : _ Stdlib.List.t) in + let bnds__015_ = + if drop_if__019_ loc___020_ then bnds__015_ + else + let arg__022_ = sexp_of_t loc___020_ in + let bnd__021_ = S.List [ S.Atom "loc_"; arg__022_ ] in + (bnd__021_ :: bnds__015_ : _ Stdlib.List.t) + in + let bnds__015_ = + let arg__017_ = _of_a__014_ v__016_ in + (S.List [ S.Atom "v"; arg__017_ ] :: bnds__015_ : _ Stdlib.List.t) + in + S.List bnds__015_ let _ = sexp_of_loced end -let lex_pos_to_pos ~(base : Lexing.position) (pos : Lexing.position) : rpos = - let line = pos.pos_lnum - base.pos_lnum in - let col = pos.pos_cnum - pos.pos_bol in - (line lsl 16) lor col - -let pos_to_lex_pos ~(base : Lexing.position) (rpos : rpos) : Lexing.position = - let col = rpos land 0xFFFF in - let line = (rpos lsr 16) land 0xFFFF in - { - pos_fname = base.pos_fname; - pos_lnum = base.pos_lnum + line; - pos_bol = 0; - pos_cnum = col; - } +let lex_pos_to_pos ~(base : Lexing.position) (pos : Lexing.position) = + (let line = pos.pos_lnum - base.pos_lnum in + let col = pos.pos_cnum - pos.pos_bol in + (line lsl 16) lor col + : rpos) + +let pos_to_lex_pos ~(base : Lexing.position) (rpos : rpos) = + (let col = rpos land 0xFFFF in + let line = (rpos lsr 16) land 0xFFFF in + { + pos_fname = base.pos_fname; + pos_lnum = base.pos_lnum + line; + pos_bol = 0; + pos_cnum = col; + } + : Lexing.position) let no_location = { start = -1; _end = -1 } @@ -149,7 +154,13 @@ let to_loc ~(base : Loc.t) (rloc : t) = Loc.of_menhir (pos_to_lex_pos ~base rloc.start, pos_to_lex_pos ~base rloc._end)) -let merge (l1 : t) (l2 : t) : t = { start = l1.start; _end = l2._end } +let merge (l1 : t) (l2 : t) = + (let { start = s1; _end = e1 } = l1 in + let { start = s2; _end = e2 } = l2 in + let start = if compare_rpos s1 s2 < 0 then s1 else s2 in + let _end = if compare_rpos e1 e2 > 0 then e1 else e2 in + { start; _end } + : t) let of_menhir ~base ((start, _end) : Lexing.position * Lexing.position) = of_loc ~base (Loc.of_menhir (start, _end)) @@ -194,29 +205,33 @@ let loc_range_string ~(base : Loc.t) l = Int.to_string end_col; ] -let sexp_of_rpos (p : rpos) : S.t = - let line = get_line p in - let col = get_col p in - S.Atom (Int.to_string line ^ ":" ^ Int.to_string col : Stdlib.String.t) - -let sexp_of_t (l : t) : S.t = - let start_line = get_line l.start in - let end_line = get_line l._end in - let start_col = get_col l.start in - let end_col = get_col l._end in - S.Atom - (Stdlib.String.concat "" - [ - Int.to_string start_line; - ":"; - Int.to_string start_col; - "-"; - Int.to_string end_line; - ":"; - Int.to_string end_col; - ]) +let sexp_of_rpos (p : rpos) = + (let line = get_line p in + let col = get_col p in + S.Atom (Int.to_string line ^ ":" ^ Int.to_string col : Stdlib.String.t) + : S.t) + +let sexp_of_t (l : t) = + (let start_line = get_line l.start in + let end_line = get_line l._end in + let start_col = get_col l.start in + let end_col = get_col l._end in + S.Atom + (Stdlib.String.concat "" + [ + Int.to_string start_line; + ":"; + Int.to_string start_col; + "-"; + Int.to_string end_line; + ":"; + Int.to_string end_col; + ]) + : S.t) let trim_first_char loc = { loc with start = loc.start + 1 } +[@@dead "+trim_first_char"] + let trim_last_char loc = { loc with _end = loc._end - 1 } let only_last_n_char loc n = diff --git a/src/runtime_gc.ml b/src/runtime_gc.ml index 529b614..064b155 100644 --- a/src/runtime_gc.ml +++ b/src/runtime_gc.ml @@ -13,4079 +13,830 @@ *) -let runtime_gc_sexp = - (List - (List.cons - (Atom "module" : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$print_i32" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"spectest\"" : W.t) - ([ Atom "\"print_i32\"" ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$i" : W.t) - ([ Atom "i32" ] : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$print_i64" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"spectest\"" : W.t) - ([ Atom "\"print_i64\"" ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$i" : W.t) - ([ Atom "i64" ] : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$printc" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"spectest\"" : W.t) - ([ Atom "\"print_char\"" ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$i" : W.t) - ([ Atom "i32" ] : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$print_f64" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"spectest\"" : W.t) - ([ Atom "\"print_f64\"" ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$i" : W.t) - ([ Atom "f64" ] : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.enum" : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - ([ - List - (List.cons - (Atom "struct" : W.t) - ([ - List - (List.cons - (Atom "field" : W.t) - ([ Atom "i32" ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.string" : W.t) - ([ - List - (List.cons - (Atom "array" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ Atom "i16" ] : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.bytes" : W.t) - ([ - List - (List.cons - (Atom "array" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ Atom "i8" ] : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.open_empty_struct" - : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - ([ - List - ([ Atom "struct" ] - : W.t list); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.string_pool_type" - : W.t) - ([ - List - (List.cons - (Atom "array" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - (List.cons - (Atom - "null" - : W.t) - ([ - Atom - "$moonbit.string"; - ] - : W.t - list))); - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.string_equal" - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$stra" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - ([ - Atom - "$moonbit.string"; - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$strb" - : W.t) - ([ - List - (List.cons - (Atom - "ref" - : W.t) - ([ - Atom - "$moonbit.string"; - ] - : W.t - list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "result" - : W.t) - ([ Atom "i32" ] - : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "local" - : W.t) - (List.cons - (Atom - "$counter" - : W.t) - ([ - Atom - "i32"; - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "local" - : W.t) - (List.cons - (Atom - "$stra_len" - : W.t) - ([ - Atom - "i32"; - ] - : W.t - list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "local.set" - : W.t) - (List - .cons - (Atom - "$stra_len" - : W - .t) - ([ - List - (List - .cons - (Atom - "array.len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$stra"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : W.t) - ([ - List - (List.cons - (Atom - "if" - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "result" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list)) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "i32.eq" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$stra_len"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strb"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "loop" - : W - .t) - ( - List - .cons - (Atom - "$loop" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "result" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "if" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "result" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.lt_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$stra_len"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "if" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "result" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.eq" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$stra"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strb"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$counter" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "br" - : W - .t) - ([ - Atom - "$loop"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "else" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "return" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))))); - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "else" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "return" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))))); - ] - : W - .t - list)))); - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "else" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "return" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))))); - ] - : W.t list))))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.println" - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$str" - : W.t) - ([ - List - (List.cons - (Atom - "ref" - : W.t) - ([ - Atom - "$moonbit.string"; - ] - : W.t - list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "local" - : W.t) - (List.cons - (Atom - "$counter" - : W.t) - ([ Atom "i32" ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "loop" - : W.t) - (List.cons - (Atom - "$loop" - : W.t) - ([ - List - (List - .cons - (Atom - "if" - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "i32.lt_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$str"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "call" - : W - .t) - ( - List - .cons - (Atom - "$printc" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$str"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$counter" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$counter"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "br" - : W - .t) - ([ - Atom - "$loop"; - ] - : W - .t - list)); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ([ - Atom - "else"; - ] - : W - .t - list); - ] - : W - .t - list)))); - ] - : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "call" - : W.t) - (List.cons - (Atom - "$printc" - : W.t) - ([ - List - (List - .cons - (Atom - "i32.const" - : - W - .t) - ([ - Atom - "10"; - ] - : - W - .t - list)); - ] - : W.t - list))); - ] - : W.t list)))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.unsafe_make_string" - : W.t) - (List.cons - (List - (List.cons - (Atom "param" - : W.t) - (List.cons - (Atom "$len" - : W.t) - ([ Atom "i32" ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" - : W.t) - (List.cons - (Atom "$val" - : W.t) - ([ - Atom - "i32"; - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "result" - : W.t) - ([ - List - (List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom - "array.new" - : W.t) - (List.cons - (Atom - "$moonbit.string" - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$val"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$len"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W.t list)))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.add_string" - : W.t) - (List.cons - (List - (List.cons - (Atom "param" - : W.t) - (List.cons - (Atom "$x" - : W.t) - ([ - List - (List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List.cons - (Atom - "$y" - : W.t) - ([ - List - (List - .cons - (Atom - "ref" - : - W - .t) - ([ - Atom - "$moonbit.string"; - ] - : - W - .t - list)); - ] - : W.t - list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "result" - : W.t) - ([ - List - (List - .cons - (Atom - "ref" - : - W - .t) - ([ - Atom - "$moonbit.string"; - ] - : - W - .t - list)); - ] - : W.t - list)) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "local" - : W - .t) - (List - .cons - (Atom - "$lenx" - : - W - .t) - ([ - Atom - "i32"; - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "local" - : - W - .t) - (List - .cons - (Atom - "$leny" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$len" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$ptr" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$lenx" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$x"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$leny" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$y"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$len" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$lenx"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$leny"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$ptr" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.new_default" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$len"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.copy" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$ptr"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$x"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$lenx"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.copy" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$ptr"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$lenx"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$y"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$leny"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$ptr"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))))))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.string_literal" - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List.cons - (Atom - "$index" - : W.t) - ([ - Atom - "i32"; - ] - : W.t - list))) - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List - .cons - (Atom - "$offset" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$length" - : - W - .t) - ([ - Atom - "i32"; - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "result" - : - W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : - W - .t - list)) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$cached" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ( - List - .cons - (Atom - "null" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$new_string" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "if" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.eqz" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref.is_null" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.tee" - : W - .t) - ( - List - .cons - (Atom - "$cached" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.get" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string_pool_type" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "global.get" - : W - .t) - ([ - Atom - "$moonbit.string_pool"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$index"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W - .t - list))); - ] - : W - .t - list)); - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "then" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "return" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref.as_non_null" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$cached"; - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$new_string" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.new_data" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.const_data" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$offset"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$length"; - ] - : W - .t - list)); - ] - : W - .t - list))))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.set" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string_pool_type" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "global.get" - : W - .t) - ([ - Atom - "$moonbit.string_pool"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$index"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$new_string"; - ] - : W - .t - list)); - ] - : W - .t - list))))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$new_string"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.unsafe_bytes_blit" - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List - .cons - (Atom - "$dst" - : W - .t) - ([ - List - (List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$dst_offset" - : - W - .t) - ([ - Atom - "i32"; - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : - W - .t) - (List - .cons - (Atom - "$src" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$src_offset" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$length" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : - W - .t) - ([ - List - ( - List - .cons - (Atom - "array.copy" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst_offset"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src_offset"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$length"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))); - ] - : - W - .t - list)))))))) - : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.unsafe_bytes_sub_string" - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List - .cons - (Atom - "$src" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$offset" - : - W - .t) - ([ - Atom - "i32"; - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : - W - .t) - (List - .cons - (Atom - "$length" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "result" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W - .t - list)) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$dst" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$strlen" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$ch" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$i" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$j" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$strlen" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shr_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$length"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$dst" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.new" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strlen"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "loop" - : W - .t) - ( - List - .cons - (Atom - "$loop" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "if" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.lt_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strlen"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$j" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$offset"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shl" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$ch" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.or" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$j"; - ] - : W - .t - list)); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shl" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$j"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "8"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.set" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$ch"; - ] - : W - .t - list)); - ] - : W - .t - list))))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$i" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "br" - : W - .t) - ([ - Atom - "$loop"; - ] - : W - .t - list)); - ] - : W - .t - list)))))) - : W - .t) - ([ - List - ([ - Atom - "else"; - ] - : W - .t - list); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)); - ] - : W - .t - list))))))))))))))); - ] - : W.t list))))))))))))))))) - : W.t) +let runtime_gc : Dwarfsm_ast.module_ = + { + id = { id = None; index = -1 }; + fields = + [ + Import + { + module_ = "spectest"; + name = "print_i32"; + desc = + Func + ( { id = Some "$print_i32"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [] ) ); + }; + Import + { + module_ = "spectest"; + name = "print_i64"; + desc = + Func + ( { id = Some "$print_i64"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I64; + source_type = None; + }; + ], + [] ) ); + }; + Import + { + module_ = "spectest"; + name = "print_char"; + desc = + Func + ( { id = Some "$printc"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [] ) ); + }; + Import + { + module_ = "spectest"; + name = "print_f64"; + desc = + Func + ( { id = Some "$print_f64"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype F64; + source_type = None; + }; + ], + [] ) ); + }; + Rectype + [ + ( { id = Some "$moonbit.enum"; index = -1 }, + { + final = false; + super = []; + type_ = + Structtype + (Struct + [ + { + id = { id = None; index = -1 }; + fieldtype = + { mut = Const; type_ = Valtype (Numtype I32) }; + }; + ]); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.string"; index = -1 }, + { + final = true; + super = []; + type_ = Arraytype (Array { mut = Var; type_ = Packedtype I16 }); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.bytes"; index = -1 }, + { + final = true; + super = []; + type_ = Arraytype (Array { mut = Var; type_ = Packedtype I8 }); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.open_empty_struct"; index = -1 }, + { final = false; super = []; type_ = Structtype (Struct []) } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.string_pool_type"; index = -1 }, + { + final = true; + super = []; + type_ = + Arraytype + (Array + { + mut = Var; + type_ = + Valtype + (Reftype + (Ref + ( Nullable, + Type { var = Unresolve "$moonbit.string" } + ))); + }); + } ); + ]; + Func + { + id = { id = Some "$moonbit.string_equal"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$stra"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( NonNull, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + { + id = { id = Some "$strb"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( NonNull, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + ], + [ Numtype I32 ] ); + locals = + [ + { + id = { id = Some "$counter"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$stra_len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$stra" }; + Array_len; + Local_set { var = Unresolve "$stra_len" }; + Local_get { var = Unresolve "$stra_len" }; + Local_get { var = Unresolve "$strb" }; + Array_len; + I32_eq; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Loop + { + label = Some "$loop"; + typeuse = Inline ([], [ Numtype I32 ]); + instrs = + [ + Local_get { var = Unresolve "$counter" }; + Local_get { var = Unresolve "$stra_len" }; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get { var = Unresolve "$stra" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.string" }; + Local_get { var = Unresolve "$strb" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.string" }; + I32_eq; + If + { + label = None; + typeuse = + Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get + { var = Unresolve "$counter" }; + I32_const 1l; + I32_add; + Local_set + { var = Unresolve "$counter" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = [ I32_const 0l; Return ]; + }; + ]; + else_ = [ I32_const 1l; Return ]; + }; + ]; + }; + ]; + else_ = [ I32_const 0l; Return ]; + }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.bytes_equal"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$lhs"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$rhs"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + ], + [ Numtype I32 ] ); + locals = + [ + { + id = { id = Some "$counter"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$lhs" }; + Array_len; + Local_set { var = Unresolve "$len" }; + Local_get { var = Unresolve "$len" }; + Local_get { var = Unresolve "$rhs" }; + Array_len; + I32_eq; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Loop + { + label = Some "$loop"; + typeuse = Inline ([], [ Numtype I32 ]); + instrs = + [ + Local_get { var = Unresolve "$counter" }; + Local_get { var = Unresolve "$len" }; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get { var = Unresolve "$lhs" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.bytes" }; + Local_get { var = Unresolve "$rhs" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.bytes" }; + I32_eq; + If + { + label = None; + typeuse = + Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get + { var = Unresolve "$counter" }; + I32_const 1l; + I32_add; + Local_set + { var = Unresolve "$counter" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = [ I32_const 0l; Return ]; + }; + ]; + else_ = [ I32_const 1l; Return ]; + }; + ]; + }; + ]; + else_ = [ I32_const 0l ]; + }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.println"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$str"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( NonNull, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + ], + [] ); + locals = + [ + { + id = { id = Some "$counter"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Loop + { + label = Some "$loop"; + typeuse = Inline ([], []); + instrs = + [ + Local_get { var = Unresolve "$counter" }; + Local_get { var = Unresolve "$str" }; + Array_len; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], []); + then_ = + [ + Local_get { var = Unresolve "$str" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.string" }; + Call { var = Unresolve "$printc" }; + Local_get { var = Unresolve "$counter" }; + I32_const 1l; + I32_add; + Local_set { var = Unresolve "$counter" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = []; + }; + ]; + }; + I32_const 10l; + Call { var = Unresolve "$printc" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.unsafe_make_string"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$val"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + ] ); + locals = []; + code = + [ + Local_get { var = Unresolve "$val" }; + Local_get { var = Unresolve "$len" }; + Array_new { var = Unresolve "$moonbit.string" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.add_string"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$x"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( NonNull, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + { + id = { id = Some "$y"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( NonNull, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + ], + [ + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + ] ); + locals = + [ + { + id = { id = Some "$lenx"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$leny"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$ptr"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$x" }; + Array_len; + Local_set { var = Unresolve "$lenx" }; + Local_get { var = Unresolve "$y" }; + Array_len; + Local_set { var = Unresolve "$leny" }; + Local_get { var = Unresolve "$lenx" }; + Local_get { var = Unresolve "$leny" }; + I32_add; + Local_set { var = Unresolve "$len" }; + Local_get { var = Unresolve "$len" }; + Array_new_default { var = Unresolve "$moonbit.string" }; + Local_set { var = Unresolve "$ptr" }; + Local_get { var = Unresolve "$ptr" }; + I32_const 0l; + Local_get { var = Unresolve "$x" }; + I32_const 0l; + Local_get { var = Unresolve "$lenx" }; + Array_copy + ( { var = Unresolve "$moonbit.string" }, + { var = Unresolve "$moonbit.string" } ); + Local_get { var = Unresolve "$ptr" }; + Local_get { var = Unresolve "$lenx" }; + Local_get { var = Unresolve "$y" }; + I32_const 0l; + Local_get { var = Unresolve "$leny" }; + Array_copy + ( { var = Unresolve "$moonbit.string" }, + { var = Unresolve "$moonbit.string" } ); + Local_get { var = Unresolve "$ptr" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.string_literal"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$index"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$length"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + ] ); + locals = + [ + { + id = { id = Some "$cached"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref (Nullable, Type { var = Unresolve "$moonbit.string" })); + source_type = None; + }; + { + id = { id = Some "$new_string"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + source_type = None; + }; + ]; + code = + [ + Global_get { var = Unresolve "$moonbit.string_pool" }; + Local_get { var = Unresolve "$index" }; + Array_get { var = Unresolve "$moonbit.string_pool_type" }; + Local_tee { var = Unresolve "$cached" }; + Ref_is_null; + I32_eqz; + If + { + label = None; + typeuse = Inline ([], []); + then_ = + [ + Local_get { var = Unresolve "$cached" }; + Ref_as_non_null; + Return; + ]; + else_ = []; + }; + Local_get { var = Unresolve "$offset" }; + Local_get { var = Unresolve "$length" }; + Array_new_data + ( { var = Unresolve "$moonbit.string" }, + { var = Unresolve "$moonbit.const_data" } ); + Local_set { var = Unresolve "$new_string" }; + Global_get { var = Unresolve "$moonbit.string_pool" }; + Local_get { var = Unresolve "$index" }; + Local_get { var = Unresolve "$new_string" }; + Array_set { var = Unresolve "$moonbit.string_pool_type" }; + Local_get { var = Unresolve "$new_string" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.unsafe_bytes_blit"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$dst"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$dst_offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$src"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$src_offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$length"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [] ); + locals = []; + code = + [ + Local_get { var = Unresolve "$dst" }; + Local_get { var = Unresolve "$dst_offset" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$src_offset" }; + Local_get { var = Unresolve "$length" }; + Array_copy + ( { var = Unresolve "$moonbit.bytes" }, + { var = Unresolve "$moonbit.bytes" } ); + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.unsafe_bytes_sub_string"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$src"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$length"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + ] ); + locals = + [ + { + id = { id = Some "$dst"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + source_type = None; + }; + { + id = { id = Some "$strlen"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$ch"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$j"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$length" }; + I32_const 1l; + I32_shr_s; + Local_set { var = Unresolve "$strlen" }; + I32_const 0l; + Local_get { var = Unresolve "$strlen" }; + Array_new { var = Unresolve "$moonbit.string" }; + Local_set { var = Unresolve "$dst" }; + Loop + { + label = Some "$loop"; + typeuse = Inline ([], []); + instrs = + [ + Local_get { var = Unresolve "$i" }; + Local_get { var = Unresolve "$strlen" }; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], []); + then_ = + [ + Local_get { var = Unresolve "$offset" }; + Local_get { var = Unresolve "$i" }; + I32_const 1l; + I32_shl; + I32_add; + Local_set { var = Unresolve "$j" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$j" }; + Array_get_u { var = Unresolve "$moonbit.bytes" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$j" }; + I32_const 1l; + I32_add; + Array_get_u { var = Unresolve "$moonbit.bytes" }; + I32_const 8l; + I32_shl; + I32_or; + Local_set { var = Unresolve "$ch" }; + Local_get { var = Unresolve "$dst" }; + Local_get { var = Unresolve "$i" }; + Local_get { var = Unresolve "$ch" }; + Array_set { var = Unresolve "$moonbit.string" }; + Local_get { var = Unresolve "$i" }; + I32_const 1l; + I32_add; + Local_set { var = Unresolve "$i" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = []; + }; + ]; + }; + Local_get { var = Unresolve "$dst" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + ]; + } diff --git a/src/runtime_gc_js_string_api.ml b/src/runtime_gc_js_string_api.ml index a7fb1a6..1c44780 100644 --- a/src/runtime_gc_js_string_api.ml +++ b/src/runtime_gc_js_string_api.ml @@ -13,2143 +13,628 @@ *) -let runtime_gc_sexp = - (List - (List.cons - (Atom "module" : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$printc" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"spectest\"" : W.t) - ([ Atom "\"print_char\"" ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$i" : W.t) - ([ Atom "i32" ] : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.js_string.cast" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" : W.t) - ([ Atom "\"test\"" ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)); - ] - : W.t list))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.js_string.length" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" : W.t) - ([ Atom "\"length\"" ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)); - ] - : W.t list))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.js_string.charCodeAt" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" : W.t) - ([ Atom "\"charCodeAt\"" ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)); - ] - : W.t list)))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.string_equal" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" : W.t) - ([ Atom "\"equals\"" ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)); - ] - : W.t list)))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.add_string" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" : W.t) - ([ Atom "\"concat\"" ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - ([ Atom "extern" ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list)))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.js_string.substring" - : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" - : W.t) - ([ Atom "\"substring\"" ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "externref" ] - : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "i32" ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - ([ - Atom - "extern"; - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.js_string.fromCharCode" - : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"wasm:js-string\"" - : W.t) - ([ - Atom "\"fromCharCode\""; - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - ([ - Atom "extern"; - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.js_string.fromCharCodeArray" - : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom - "\"wasm:js-string\"" - : W.t) - ([ - Atom - "\"fromCharCodeArray\""; - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - (List.cons - (Atom "null" - : W.t) - ([ - Atom - "$moonbit.string"; - ] - : W.t list))); - ] - : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ Atom "i32" ] - : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "param" - : W.t) - ([ Atom "i32" ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "result" - : W.t) - ([ - List - (List.cons - (Atom - "ref" - : W.t) - ([ - Atom - "extern"; - ] - : W.t - list)); - ] - : W.t list)); - ] - : W.t list))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom "$moonbit.println" : W.t) - (List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"console\"" - : W.t) - ([ Atom "\"log\"" ] - : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom "$str" : W.t) - ([ - List - (List.cons - (Atom "ref" - : W.t) - ([ - Atom - "extern"; - ] - : W.t - list)); - ] - : W.t list))); - ] - : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.enum" : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - ([ - List - (List.cons - (Atom "struct" - : W.t) - ([ - List - (List - .cons - (Atom - "field" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list)); - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.string" - : W.t) - ([ - List - (List.cons - (Atom "array" - : W.t) - ([ - List - (List.cons - (Atom "mut" - : W.t) - ([ - Atom - "i16"; - ] - : W.t - list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom "$moonbit.bytes" - : W.t) - ([ - List - (List.cons - (Atom "array" - : W.t) - ([ - List - (List.cons - (Atom - "mut" - : W.t) - ([ - Atom - "i8"; - ] - : W.t - list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom - "$moonbit.open_empty_struct" - : W.t) - ([ - List - (List.cons - (Atom "sub" - : W.t) - ([ - List - ([ - Atom - "struct"; - ] - : W.t - list); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom - "$moonbit.unsafe_make_string" - : W.t) - (List.cons - (List - (List.cons - (Atom - "param" - : W.t) - (List - .cons - (Atom - "$len" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$val" - : - W - .t) - ([ - Atom - "i32"; - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "result" - : - W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "extern"; - ] - : W - .t - list)); - ] - : - W - .t - list)) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "array.new" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$val"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$len"; - ] - : W - .t - list)); - ] - : W - .t - list)))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$len"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "call" - : W - .t) - ([ - Atom - "$moonbit.js_string.fromCharCodeArray"; - ] - : W - .t - list)); - ] - : W - .t - list))))))))) - : W.t) - (List.cons - (List - (List.cons - (Atom "func" - : W.t) - (List.cons - (Atom - "$moonbit.unsafe_bytes_blit" - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$dst" - : - W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : - W - .t) - (List - .cons - (Atom - "$dst_offset" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$src" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$src_offset" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$length" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.copy" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst_offset"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src_offset"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$length"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))); - ] - : W - .t - list)))))))) - : W.t) - ([ - List - (List.cons - (Atom "func" - : W.t) - (List.cons - (Atom - "$moonbit.unsafe_bytes_sub_string" - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : W - .t) - (List - .cons - (Atom - "$src" - : - W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.bytes"; - ] - : W - .t - list)); - ] - : - W - .t - list))) - : W.t) - (List.cons - (List - (List - .cons - (Atom - "param" - : - W - .t) - (List - .cons - (Atom - "$offset" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W.t) - (List - .cons - (List - (List - .cons - (Atom - "param" - : W - .t) - ( - List - .cons - (Atom - "$length" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "result" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "extern"; - ] - : W - .t - list)); - ] - : W - .t - list)) - : - W - .t) - (List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$dst" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "ref" - : W - .t) - ([ - Atom - "$moonbit.string"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$strlen" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$ch" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$i" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local" - : W - .t) - ( - List - .cons - (Atom - "$j" - : W - .t) - ([ - Atom - "i32"; - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$strlen" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shr_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$length"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$dst" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "array.new" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strlen"; - ] - : W - .t - list)); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "loop" - : W - .t) - ( - List - .cons - (Atom - "$loop" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "if" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.lt_s" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strlen"; - ] - : W - .t - list)); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "then" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$j" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$offset"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shl" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$ch" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.or" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$j"; - ] - : W - .t - list)); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.shl" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.get_u" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.bytes" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$src"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$j"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list)))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "8"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "array.set" - : W - .t) - ( - List - .cons - (Atom - "$moonbit.string" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$ch"; - ] - : W - .t - list)); - ] - : W - .t - list))))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.set" - : W - .t) - ( - List - .cons - (Atom - "$i" - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.add" - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$i"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "1"; - ] - : W - .t - list)); - ] - : W - .t - list))); - ] - : W - .t - list))) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "br" - : W - .t) - ([ - Atom - "$loop"; - ] - : W - .t - list)); - ] - : W - .t - list)))))) - : W - .t) - ([ - List - ([ - Atom - "else"; - ] - : W - .t - list); - ] - : W - .t - list)))); - ] - : W - .t - list))) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$dst"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "i32.const" - : W - .t) - ([ - Atom - "0"; - ] - : W - .t - list)) - : W - .t) - ( - List - .cons - (List - ( - List - .cons - (Atom - "local.get" - : W - .t) - ([ - Atom - "$strlen"; - ] - : W - .t - list)) - : W - .t) - ([ - List - ( - List - .cons - (Atom - "call" - : W - .t) - ([ - Atom - "$moonbit.js_string.fromCharCodeArray"; - ] - : W - .t - list)); - ] - : W - .t - list)))))))))))))))))); - ] - : W.t list)))))))))))))))))) - : W.t) +let runtime_gc : Dwarfsm_ast.module_ = + { + id = { id = None; index = -1 }; + fields = + [ + Import + { + module_ = "spectest"; + name = "print_char"; + desc = + Func + ( { id = Some "$printc"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "test"; + desc = + Func + ( { id = Some "$moonbit.js_string.cast"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + ], + [ Numtype I32 ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "length"; + desc = + Func + ( { id = Some "$moonbit.js_string.length"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + ], + [ Numtype I32 ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "charCodeAt"; + desc = + Func + ( { id = Some "$moonbit.js_string.charCodeAt"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Numtype I32 ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "equals"; + desc = + Func + ( { id = Some "$moonbit.string_equal"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + ], + [ Numtype I32 ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "concat"; + desc = + Func + ( { id = Some "$moonbit.add_string"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "substring"; + desc = + Func + ( { id = Some "$moonbit.js_string.substring"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Reftype (Ref (Nullable, Absheaptype Extern)); + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "fromCharCode"; + desc = + Func + ( { id = Some "$moonbit.js_string.fromCharCode"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "fromCodePoint"; + desc = + Func + ( { id = Some "$moonbit.js_string.fromCodePoint"; index = -1 }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ) ); + }; + Import + { + module_ = "wasm:js-string"; + name = "fromCharCodeArray"; + desc = + Func + ( { + id = Some "$moonbit.js_string.fromCharCodeArray"; + index = -1; + }, + Inline + ( [ + { + id = { id = None; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + ( Nullable, + Type { var = Unresolve "$moonbit.string" } )); + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = None; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ) ); + }; + Import + { + module_ = "console"; + name = "log"; + desc = + Func + ( { id = Some "$moonbit.println"; index = -1 }, + Inline + ( [ + { + id = { id = Some "$str"; index = -1 }; + source_name = None; + type_ = Reftype (Ref (NonNull, Absheaptype Extern)); + source_type = None; + }; + ], + [] ) ); + }; + Rectype + [ + ( { id = Some "$moonbit.enum"; index = -1 }, + { + final = false; + super = []; + type_ = + Structtype + (Struct + [ + { + id = { id = None; index = -1 }; + fieldtype = + { mut = Const; type_ = Valtype (Numtype I32) }; + }; + ]); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.string"; index = -1 }, + { + final = true; + super = []; + type_ = Arraytype (Array { mut = Var; type_ = Packedtype I16 }); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.bytes"; index = -1 }, + { + final = true; + super = []; + type_ = Arraytype (Array { mut = Var; type_ = Packedtype I8 }); + } ); + ]; + Rectype + [ + ( { id = Some "$moonbit.open_empty_struct"; index = -1 }, + { final = false; super = []; type_ = Structtype (Struct []) } ); + ]; + Func + { + id = { id = Some "$moonbit.unsafe_make_string"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$val"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ); + locals = []; + code = + [ + Local_get { var = Unresolve "$val" }; + Local_get { var = Unresolve "$len" }; + Array_new { var = Unresolve "$moonbit.string" }; + I32_const 0l; + Local_get { var = Unresolve "$len" }; + Call { var = Unresolve "$moonbit.js_string.fromCharCodeArray" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.bytes_equal"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$lhs"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$rhs"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + ], + [ Numtype I32 ] ); + locals = + [ + { + id = { id = Some "$counter"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$len"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$lhs" }; + Array_len; + Local_set { var = Unresolve "$len" }; + Local_get { var = Unresolve "$len" }; + Local_get { var = Unresolve "$rhs" }; + Array_len; + I32_eq; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Loop + { + label = Some "$loop"; + typeuse = Inline ([], [ Numtype I32 ]); + instrs = + [ + Local_get { var = Unresolve "$counter" }; + Local_get { var = Unresolve "$len" }; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get { var = Unresolve "$lhs" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.bytes" }; + Local_get { var = Unresolve "$rhs" }; + Local_get { var = Unresolve "$counter" }; + Array_get_u + { var = Unresolve "$moonbit.bytes" }; + I32_eq; + If + { + label = None; + typeuse = + Inline ([], [ Numtype I32 ]); + then_ = + [ + Local_get + { var = Unresolve "$counter" }; + I32_const 1l; + I32_add; + Local_set + { var = Unresolve "$counter" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = [ I32_const 0l; Return ]; + }; + ]; + else_ = [ I32_const 1l; Return ]; + }; + ]; + }; + ]; + else_ = [ I32_const 0l ]; + }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.unsafe_bytes_blit"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$dst"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$dst_offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$src"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$src_offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$length"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [] ); + locals = []; + code = + [ + Local_get { var = Unresolve "$dst" }; + Local_get { var = Unresolve "$dst_offset" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$src_offset" }; + Local_get { var = Unresolve "$length" }; + Array_copy + ( { var = Unresolve "$moonbit.bytes" }, + { var = Unresolve "$moonbit.bytes" } ); + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + Func + { + id = { id = Some "$moonbit.unsafe_bytes_sub_string"; index = -1 }; + type_ = + Inline + ( [ + { + id = { id = Some "$src"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref + (NonNull, Type { var = Unresolve "$moonbit.bytes" })); + source_type = None; + }; + { + id = { id = Some "$offset"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$length"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ], + [ Reftype (Ref (NonNull, Absheaptype Extern)) ] ); + locals = + [ + { + id = { id = Some "$dst"; index = -1 }; + source_name = None; + type_ = + Reftype + (Ref (NonNull, Type { var = Unresolve "$moonbit.string" })); + source_type = None; + }; + { + id = { id = Some "$strlen"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$ch"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$i"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + { + id = { id = Some "$j"; index = -1 }; + source_name = None; + type_ = Numtype I32; + source_type = None; + }; + ]; + code = + [ + Local_get { var = Unresolve "$length" }; + I32_const 1l; + I32_shr_s; + Local_set { var = Unresolve "$strlen" }; + I32_const 0l; + Local_get { var = Unresolve "$strlen" }; + Array_new { var = Unresolve "$moonbit.string" }; + Local_set { var = Unresolve "$dst" }; + Loop + { + label = Some "$loop"; + typeuse = Inline ([], []); + instrs = + [ + Local_get { var = Unresolve "$i" }; + Local_get { var = Unresolve "$strlen" }; + I32_lt_s; + If + { + label = None; + typeuse = Inline ([], []); + then_ = + [ + Local_get { var = Unresolve "$offset" }; + Local_get { var = Unresolve "$i" }; + I32_const 1l; + I32_shl; + I32_add; + Local_set { var = Unresolve "$j" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$j" }; + Array_get_u { var = Unresolve "$moonbit.bytes" }; + Local_get { var = Unresolve "$src" }; + Local_get { var = Unresolve "$j" }; + I32_const 1l; + I32_add; + Array_get_u { var = Unresolve "$moonbit.bytes" }; + I32_const 8l; + I32_shl; + I32_or; + Local_set { var = Unresolve "$ch" }; + Local_get { var = Unresolve "$dst" }; + Local_get { var = Unresolve "$i" }; + Local_get { var = Unresolve "$ch" }; + Array_set { var = Unresolve "$moonbit.string" }; + Local_get { var = Unresolve "$i" }; + I32_const 1l; + I32_add; + Local_set { var = Unresolve "$i" }; + Br { var = Unresolve "$loop" }; + ]; + else_ = []; + }; + ]; + }; + Local_get { var = Unresolve "$dst" }; + I32_const 0l; + Local_get { var = Unresolve "$strlen" }; + Call { var = Unresolve "$moonbit.js_string.fromCharCodeArray" }; + ]; + source_name = None; + aux = { low_pc = 0; high_pc = 0 }; + }; + ]; + } diff --git a/src/s.ml b/src/s.ml index 4bba20a..2b3c13c 100644 --- a/src/s.ml +++ b/src/s.ml @@ -28,7 +28,7 @@ let rec equal (x : t) (y : t) = | List ls, List ly -> (try List.for_all2 equal ls ly with _ -> false) | _ -> false -let sexp_of_t (x : t) : t = x [@@dead "+sexp_of_t"] +let sexp_of_t (x : t) = (x : t) [@@dead "+sexp_of_t"] let char_hex n = Char.unsafe_chr (n + if n < 10 then Char.code '0' else Char.code 'A' - 10) diff --git a/src/sexp_visitors.ml b/src/sexp_visitors.ml index 2208100..b14a180 100644 --- a/src/sexp_visitors.ml +++ b/src/sexp_visitors.ml @@ -29,9 +29,9 @@ and sexp_of_unit = Moon_sexp_conv.sexp_of_unit class ['self] sexp = object (self : 'self) - method private visit_array - : 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a array -> S.t = - fun f env -> sexp_of_array (f env) + method private visit_array : + 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a array -> S.t = + fun f -> fun env -> sexp_of_array (f env) method private visit_bool : 'env. 'env -> bool -> S.t = fun _env -> sexp_of_bool @@ -54,50 +54,56 @@ class ['self] sexp = method private visit_int64 : 'env. 'env -> int64 -> S.t = fun _env -> sexp_of_int64 - method private visit_list - : 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a list -> S.t = - fun f env -> sexp_of_list (f env) + method private visit_list : + 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a list -> S.t = + fun f -> fun env -> sexp_of_list (f env) - method private visit_option - : 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a option -> S.t = - fun f env -> sexp_of_option (f env) + method private visit_option : + 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a option -> S.t = + fun f -> fun env -> sexp_of_option (f env) method private visit_record : 'env. 'env -> (string * S.t) list -> S.t = - fun _env flds -> - S.List (List.map (fun (lbl, v) -> S.List [ Atom lbl; v ]) flds) + fun _env -> + fun flds -> + S.List (Basic_lst.map flds (fun (lbl, v) -> S.List [ Atom lbl; v ])) - method private visit_ref - : 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a ref -> S.t = - fun f env -> sexp_of_ref (f env) + method private visit_ref : + 'env 'a. ('env -> 'a -> S.t) -> 'env -> 'a ref -> S.t = + fun f -> fun env -> sexp_of_ref (f env) method private visit_string : 'env. 'env -> string -> S.t = fun _env -> sexp_of_string method private visit_tuple : 'env. 'env -> S.t list -> S.t = - fun _env xs -> S.List xs + fun _env -> fun xs -> S.List xs method private visit_unit : 'env. 'env -> unit -> S.t = fun _env -> sexp_of_unit method private visit_inline_tuple : 'env -> string -> S.t list -> S.t = - fun _env ct xs -> - let ct = self#visit_variant_ctor _env ct in - match xs with [] -> ct | _ -> S.List (ct :: xs) + fun _env -> + fun ct -> + fun xs -> + let ct = self#visit_variant_ctor _env ct in + match xs with [] -> ct | _ -> S.List (ct :: xs) method private visit_variant_ctor : 'env -> string -> S.t = - fun _env ct -> - let ct = - match String.index_opt ct '_' with - | Some i -> - String.capitalize_ascii - (String.sub ct (i + 1) (String.length ct - i - 1)) - | None -> ct - in - S.Atom ct - - method private visit_inline_record - : 'env -> string -> (string * S.t) list -> S.t = - fun _env ct flds -> - let s = self#visit_variant_ctor _env ct in - S.List (s :: List.map snd flds) + fun _env -> + fun ct -> + let ct = + match String.index_opt ct '_' with + | Some i -> + String.capitalize_ascii + (String.sub ct (i + 1) (String.length ct - i - 1)) + | None -> ct + in + S.Atom ct + + method private visit_inline_record : + 'env -> string -> (string * S.t) list -> S.t = + fun _env -> + fun ct -> + fun flds -> + let s = self#visit_variant_ctor _env ct in + S.List (s :: Basic_lst.map flds snd) end diff --git a/src/shrink_wasmir.ml b/src/shrink_wasmir.ml new file mode 100644 index 0000000..80149a6 --- /dev/null +++ b/src/shrink_wasmir.ml @@ -0,0 +1,300 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module StringSet = Basic_set_string +module Lst = Basic_lst +module Ast = Dwarfsm_ast +type program_item = + | Binding of (string * Ast.modulefield) + | Rec_type of (string list * Ast.modulefield) + | Raw of Ast.modulefield +let extract_item keep_types (mf : Ast.modulefield) = + (match mf with + | Ast.Func { id = { id = Some name;_};_} -> Binding (name, mf) + | Ast.Global { id = { id = Some name;_};_} | Ast.Data + { id = { id = Some name;_};_} | Ast.Import + { desc = Func ({ id = Some name;_}, _);_} | Ast.Import + { desc = Global ({ id = Some name;_}, _);_} | Ast.Rectype + (({ id = Some name;_}, _)::[]) -> + if keep_types then Raw mf else Binding (name, mf) + | Ast.Rectype typs -> + let names = + Lst.fold_right typs [] + (fun t -> + fun acc -> + match t with + | ({ id = Some name;_}, _) -> name :: acc + | _ -> acc) in + Rec_type (names, mf) + | _ -> Raw mf : program_item) +let get_all_ident_var ~except:(except : StringSet.t) (cell : Ast.var) = + (match cell with + | Resolved { var_name;_} | Unresolve var_name -> + if not (StringSet.mem except var_name) + then StringSet.singleton var_name + else StringSet.empty : StringSet.t) +let get_all_ident_binder ~except:(except : StringSet.t) + (binder : Ast.binder) = + (match binder with + | { id = Some name;_} -> + if not (StringSet.mem except name) + then StringSet.singleton name + else StringSet.empty + | _ -> StringSet.empty : StringSet.t) +let get_all_ident_heaptype ~except:(except : StringSet.t) + (ht : Ast.heaptype) = + match ht with + | Type { var = v } -> get_all_ident_var ~except v + | _ -> StringSet.empty +let get_all_ident_valtype ~except:(except : StringSet.t) (vt : Ast.valtype) + = + match vt with + | Reftype (Ref (_, ht)) -> get_all_ident_heaptype ~except ht + | _ -> StringSet.empty +let get_all_ident_storagetype ~except:(except : StringSet.t) + (stt : Ast.storagetype) = + match stt with + | Valtype vt -> get_all_ident_valtype ~except vt + | Packedtype _ -> StringSet.empty +let get_all_ident_local ~except:(except : StringSet.t) (local : Ast.local) = + StringSet.union (get_all_ident_binder ~except local.id) + (get_all_ident_valtype ~except local.type_) +let get_all_ident_locals ~except:(except : StringSet.t) + (locals : Ast.local list) = + List.fold_left + (fun acc -> + fun local -> StringSet.union (get_all_ident_local ~except local) acc) + StringSet.empty locals +let rec get_all_ident_typeuse ~except:(except : StringSet.t) + (fntype : Ast.typeuse) = + let get_all_ident_vts ~except:(except : StringSet.t) + (vts : Ast.valtype list) = + List.fold_left + (fun acc -> + fun vt -> StringSet.union (get_all_ident_valtype ~except vt) acc) + StringSet.empty vts in + match fntype with + | Use ({ var = id }, params, results) -> + StringSet.union (get_all_ident_var ~except id) + (get_all_ident_typeuse ~except (Inline (params, results))) + | Inline (params, results) -> + StringSet.union (get_all_ident_vts ~except results) + (get_all_ident_locals ~except params) +let get_all_ident_comptype ~except:(except : StringSet.t) + (ct : Ast.comptype) = + let unwarp (field : Ast.field) = (field.fieldtype).type_ in + match ct with + | Arraytype (Array ft) -> get_all_ident_storagetype ~except ft.type_ + | Structtype (Struct fl) -> + let sttl = Lst.map fl unwarp in + List.fold_left + (fun acc -> + fun stt -> + StringSet.union (get_all_ident_storagetype ~except stt) acc) + StringSet.empty sttl + | Functype (Func (params, results)) -> + get_all_ident_typeuse ~except (Inline (params, results)) +let get_all_ident_subtype ~except:(except : StringSet.t) (st : Ast.subtype) + = + StringSet.union (get_all_ident_comptype ~except st.type_) + (Lst.fold_left st.super StringSet.empty + (fun acc -> + fun super -> + StringSet.union acc (get_all_ident_var ~except super.var))) +let get_all_ident_typedef ~except:(except : StringSet.t) (td : Ast.typedef) + = + let (v, st) = td in + StringSet.union (get_all_ident_binder ~except v) + (get_all_ident_subtype ~except st) +let get_all_ident_rectype ~except:(except : StringSet.t) (rt : Ast.rectype) + = + List.fold_left + (fun acc -> + fun typedef -> + StringSet.union (get_all_ident_typedef ~except typedef) acc) + StringSet.empty rt +let get_all_ident_importdesc ~except:(except : StringSet.t) + (importdesc : Ast.importdesc) = + match importdesc with + | Func (v, typeuse) -> + StringSet.union (get_all_ident_binder ~except v) + (get_all_ident_typeuse ~except typeuse) + | Table (v, tabletype) -> + let Ref (_, ht) = tabletype.element_type in + StringSet.union (get_all_ident_binder ~except v) + (get_all_ident_heaptype ~except ht) + | Memory (v, _) -> get_all_ident_binder ~except v + | Global (v, gt) -> + StringSet.union (get_all_ident_binder ~except v) + (get_all_ident_valtype ~except gt.type_) + | Tag (v, typeuse) -> + StringSet.union (get_all_ident_binder ~except v) + (get_all_ident_typeuse ~except typeuse) +let rec get_all_ident_catchs ~except:(except : StringSet.t) + (catchs : Ast.catch list) = + match catchs with + | [] -> StringSet.empty + | (Catch ({ var = var1 }, { var = var2 }))::catchs -> + StringSet.union (get_all_ident_var ~except var1) + (StringSet.union (get_all_ident_var ~except var2) + (get_all_ident_catchs ~except catchs)) +let get_all_ident_instrs ~except:(except : StringSet.t) + (instrs : Ast.instr list) = + let identifiers = ref StringSet.empty in + let rec aux (instrs : Ast.instr list) = + match instrs with + | [] -> () + | (Call { var })::instrs | (Call_ref { var })::instrs | (Array_fill + { var })::instrs | (Array_get { var })::instrs | (Array_get_u + { var })::instrs | (Array_new { var })::instrs | (Array_new_default + { var })::instrs | (Array_new_fixed ({ var }, _))::instrs | (Array_set + { var })::instrs | (Ref_func { var })::instrs | (Struct_new + { var })::instrs | (Struct_new_default { var })::instrs | (Struct_get + ({ var }, _))::instrs | (Struct_set ({ var }, _))::instrs | (Global_get + { var })::instrs | (Global_set { var })::instrs | (Table_get + { var })::instrs | (Memory_init { var })::instrs | (Throw + { var })::instrs -> + (identifiers := + (StringSet.union (!identifiers) (get_all_ident_var ~except var)); + aux instrs) + | (Call_indirect (_, typ))::instrs -> + (identifiers := + (StringSet.union (!identifiers) + (get_all_ident_typeuse ~except typ)); + aux instrs) + | (Array_new_data ({ var = v1 }, { var }))::instrs -> + (identifiers := + (StringSet.union (!identifiers) + (StringSet.union (get_all_ident_var ~except v1) + (get_all_ident_var ~except var))); + aux instrs) + | (Array_copy ({ var = v1 }, { var = v2 }))::instrs -> + (identifiers := + (StringSet.union (!identifiers) + (StringSet.union (get_all_ident_var ~except v1) + (get_all_ident_var ~except v2))); + aux instrs) + | (Ref_null ht)::instrs | (Ref_cast (Ref (_, ht)))::instrs -> + (identifiers := + (StringSet.union (!identifiers) + (get_all_ident_heaptype ~except ht)); + aux instrs) + | (Try_table { typeuse; catchs; instrs;_})::rest -> + (identifiers := + (StringSet.union (!identifiers) + (StringSet.union (get_all_ident_typeuse ~except typeuse) + (get_all_ident_catchs ~except catchs))); + aux instrs; + aux rest) + | (If { then_; else_;_})::rest -> (aux then_; aux else_; aux rest) + | (Block { instrs;_})::rest -> (aux instrs; aux rest) + | (Loop { instrs;_})::rest -> (aux instrs; aux rest) + | _::instrs -> aux instrs in + aux instrs; !identifiers +let get_all_ident ~except:(except : StringSet.t) (mf : Ast.modulefield) = + (match mf with + | Rectype rectype -> get_all_ident_rectype ~except rectype + | Import import -> get_all_ident_importdesc ~except import.desc + | Func func -> + StringSet.union (get_all_ident_binder ~except func.id) + (StringSet.union (get_all_ident_locals ~except func.locals) + (StringSet.union (get_all_ident_typeuse ~except func.type_) + (get_all_ident_instrs ~except func.code))) + | Global global -> + StringSet.union (get_all_ident_instrs ~except global.init) + (StringSet.union + (get_all_ident_valtype ~except (global.type_).type_) + (get_all_ident_binder ~except global.id)) + | Data data -> get_all_ident_binder ~except data.id + | _ -> StringSet.empty : StringSet.t) +let get_all_ident_elem ~except:(except : StringSet.t) + (expr : Ast.instr list) = + match expr with + | (Ref_func { var = Unresolve name })::[] -> + if not (StringSet.mem except name) + then StringSet.singleton name + else StringSet.empty + | _ -> assert false +let get_exported (mfs : Ast.modulefield list) = + (let exports = ref StringSet.empty in + let go mf = + match mf with + | Ast.Export { desc = Func { var = Unresolve name };_} | Ast.Export + { desc = Table { var = Unresolve name };_} | Ast.Export + { desc = Memory { var = Unresolve name };_} | Ast.Export + { desc = Global { var = Unresolve name };_} | Ast.Start + { var = Unresolve name } -> exports := (StringSet.add (!exports) name) + | Ast.Elem { list = elems;_} -> + exports := + (StringSet.union (!exports) + (List.fold_left StringSet.union StringSet.empty + (Lst.map elems (get_all_ident_elem ~except:StringSet.empty)))) + | _ -> () in + Basic_lst.iter mfs ~f:go; !exports : StringSet.t) +let slice_prog keep_types (body : Ast.modulefield list) = + (Lst.map body (extract_item keep_types) : program_item list) +let dependency_of_exports + (get_all_ident : except:StringSet.t -> Ast.modulefield -> StringSet.t) + (items : program_item list) (exported : StringSet.t) = + (let tbl = Hashtbl.create 50 in + let collect_item (item : program_item) = + match item with + | Binding (x, mf) -> Hashtbl.add tbl x mf + | Rec_type (names, mf) -> + Lst.iter names ~f:(fun name -> Hashtbl.add tbl name mf) + | Raw _ -> () in + Lst.iter items ~f:collect_item; + (let deps_of_exported = ref exported in + let update_bit = ref true in + let visited = ref StringSet.empty in + while !update_bit do + (update_bit := false; + StringSet.iter (!deps_of_exported) + (fun name -> + if not (StringSet.mem (!visited) name) + then + (visited := (StringSet.add (!visited) name); + (match Hashtbl.find_opt tbl name with + | Some mf -> + let new_deps = + get_all_ident ~except:(!deps_of_exported) mf in + (update_bit := + ((!update_bit) || (not (StringSet.is_empty new_deps))); + deps_of_exported := + (StringSet.union (!deps_of_exported) new_deps)) + | None -> ())))) + done; + !deps_of_exported) : StringSet.t) +let rebuild_program (items : program_item list) usage = + (Lst.fold_right items [] + (fun item -> + fun acc -> + match item with + | Binding (name, mf) -> + if StringSet.mem usage name then mf :: acc else acc + | Rec_type (names, mf) -> + if Lst.exists names (fun name -> StringSet.mem usage name) + then mf :: acc + else acc + | Raw mf -> mf :: acc) : Ast.modulefield list) +let shrink ?(keep_types= false) (mod_ : Ast.module_) = + (let code = mod_.fields in + let items = slice_prog keep_types code in + let exported = get_exported code in + let usage = dependency_of_exports get_all_ident items exported in + { + id = (Wasmlinear_constr.empty_binder ()); + fields = (rebuild_program items usage) + } : Ast.module_) diff --git a/src/specialize_operator.ml b/src/specialize_operator.ml index e0db7fa..431d706 100644 --- a/src/specialize_operator.ml +++ b/src/specialize_operator.ml @@ -31,7 +31,9 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) ty_args_; arity_ = Some (Fn_arity.simple 2); kind; - ty = Builtin.type_arrow [ ty_lhs; ty_rhs ] ret_ty ~err_ty:None; + ty = + Builtin.type_arrow [ ty_lhs; ty_rhs ] ret_ty ~err_ty:None + ~is_async:false; loc_ = loc; } in @@ -42,6 +44,11 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) (Qual_ident.meth ~self_typ ~name:op_info.method_name) [@@inline] in + let return_impl ~ret_ty ~trait ~self_typ ~kind = + return ~ty_args_:[||] ~ret_ty ~kind + (Qual_ident.ext_meth ~trait ~self_typ ~name:op_info.method_name) + [@@inline] + in match (op_info.op_name, Stype.type_repr ty_lhs) with | "+", T_builtin T_string -> return_method ~self_typ:Type_path.Builtin.type_path_string @@ -68,14 +75,14 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) | T_double when operator <> Mod -> return (Prim (Parith { operator; operand_type = F64 })) | T_string -> return (Prim Primitive.add_string) - | T_byte -> return Normal + | T_byte | T_int16 | T_uint16 -> return Normal | T_unit | T_bool | T_char | T_bytes | T_float | T_double | T_int64 | T_uint64 -> None) | "==", T_builtin b -> ( let return kind = - return_method ~self_typ:(Stype.tpath_of_builtin b) ~ret_ty:Stype.bool - ~kind + return_impl ~trait:Type_path.Builtin.trait_eq + ~self_typ:(Stype.tpath_of_builtin b) ~ret_ty:Stype.bool ~kind [@@local] in match b with @@ -88,7 +95,8 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) | T_double -> return (Prim (Pcomparison { operator = Eq; operand_type = F64 })) | T_string -> return (Prim Pstringequal) - | T_unit | T_bytes | T_byte -> return Normal + | T_bytes -> return (Prim Pbytesequal) + | T_unit | T_byte | T_int16 | T_uint16 -> return Normal | T_int64 | T_uint64 -> None) | ("<" | ">" | "<=" | ">=" | "!="), T_builtin b -> ( let return kind = @@ -107,7 +115,7 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) | _ -> assert false in match b with - | T_int | T_char | T_byte -> + | T_int | T_char | T_byte | T_int16 | T_uint16 -> return (Prim (Pcomparison { operator; operand_type = I32 })) | T_uint -> return (Prim (Pcomparison { operator; operand_type = U32 })) | T_float -> return (Prim (Pcomparison { operator; operand_type = F32 })) @@ -130,7 +138,7 @@ let try_specialize_op ~(op_info : Operators.operator_info) ~(ty_lhs : Stype.t) match b with | T_int -> return (Prim (Pbitwise { operator; operand_type = I32 })) | T_uint -> return (Prim (Pbitwise { operator; operand_type = U32 })) - | T_byte -> return Normal + | T_byte | T_int16 | T_uint16 -> return Normal | T_float | T_double | T_unit | T_bool | T_char | T_string | T_bytes | T_int64 | T_uint64 -> None) diff --git a/src/stub_type.ml b/src/stub_type.ml index c7cd0fb..c4f2312 100644 --- a/src/stub_type.ml +++ b/src/stub_type.ml @@ -99,33 +99,34 @@ include struct let _ = sexp_of_t let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - (fun hsv arg -> - match arg with - | Import _ir -> - let hsv = Ppx_base.hash_fold_int hsv 0 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_string hsv _ir.module_name - in - Ppx_base.hash_fold_string hsv _ir.func_name - | Internal _ir -> - let hsv = Ppx_base.hash_fold_int hsv 1 in - let hsv = hsv in - Ppx_base.hash_fold_string hsv _ir.func_name - | Inline_code_sexp _ir -> - let hsv = Ppx_base.hash_fold_int hsv 2 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_string hsv _ir.language - in - hsv - | Inline_code_text _ir -> - let hsv = Ppx_base.hash_fold_int hsv 3 in - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_string hsv _ir.language - in - hsv + (fun hsv -> + fun arg -> + match arg with + | Import _ir -> + let hsv = Ppx_base.hash_fold_int hsv 0 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_string hsv _ir.module_name + in + Ppx_base.hash_fold_string hsv _ir.func_name + | Internal _ir -> + let hsv = Ppx_base.hash_fold_int hsv 1 in + let hsv = hsv in + Ppx_base.hash_fold_string hsv _ir.func_name + | Inline_code_sexp _ir -> + let hsv = Ppx_base.hash_fold_int hsv 2 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_string hsv _ir.language + in + hsv + | Inline_code_text _ir -> + let hsv = Ppx_base.hash_fold_int hsv 3 in + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_string hsv _ir.language + in + hsv : Ppx_base.state -> t -> Ppx_base.state) let _ = hash_fold_t @@ -141,93 +142,170 @@ include struct let _ = hash let equal = - (fun a__025_ b__026_ -> - if Stdlib.( == ) a__025_ b__026_ then true - else - match (a__025_, b__026_) with - | Import _a__027_, Import _b__028_ -> - Stdlib.( && ) - (Stdlib.( = ) - (_a__027_.module_name : string) - _b__028_.module_name) - (Stdlib.( = ) (_a__027_.func_name : string) _b__028_.func_name) - | Import _, _ -> false - | _, Import _ -> false - | Internal _a__029_, Internal _b__030_ -> - Stdlib.( = ) (_a__029_.func_name : string) _b__030_.func_name - | Internal _, _ -> false - | _, Internal _ -> false - | Inline_code_sexp _a__031_, Inline_code_sexp _b__032_ -> - Stdlib.( = ) (_a__031_.language : string) _b__032_.language - | Inline_code_sexp _, _ -> false - | _, Inline_code_sexp _ -> false - | Inline_code_text _a__033_, Inline_code_text _b__034_ -> - Stdlib.( = ) (_a__033_.language : string) _b__034_.language + (fun a__025_ -> + fun b__026_ -> + if Stdlib.( == ) a__025_ b__026_ then true + else + match (a__025_, b__026_) with + | Import _a__027_, Import _b__028_ -> + Stdlib.( && ) + (Stdlib.( = ) + (_a__027_.module_name : string) + _b__028_.module_name) + (Stdlib.( = ) (_a__027_.func_name : string) _b__028_.func_name) + | Import _, _ -> false + | _, Import _ -> false + | Internal _a__029_, Internal _b__030_ -> + Stdlib.( = ) (_a__029_.func_name : string) _b__030_.func_name + | Internal _, _ -> false + | _, Internal _ -> false + | Inline_code_sexp _a__031_, Inline_code_sexp _b__032_ -> + Stdlib.( = ) (_a__031_.language : string) _b__032_.language + | Inline_code_sexp _, _ -> false + | _, Inline_code_sexp _ -> false + | Inline_code_text _a__033_, Inline_code_text _b__034_ -> + Stdlib.( = ) (_a__033_.language : string) _b__034_.language : t -> t -> bool) let _ = equal end -let from_syntax ~loc (stub : Syntax.func_stubs) : t Partial_info.t = - match stub with - | Import { module_name; func_name } -> - Ok - (Import - { - module_name = module_name.string_val; - func_name = func_name.string_val; - }) - | Embedded { language; code } -> ( - let aux s : _ Partial_info.t = - if Option.is_none language && String.length s >= 1 && s.[0] = '$' then - Ok (Internal { func_name = s }) - else - let language = - match language with Some s -> s.string_val | None -> "wasm" - in - match language with - | "wasm" -> ( - match Dwarfsm_sexp_parse.parse s with - | ((List (Atom "func" :: _) : W.t) as func_body) :: [] -> - Ok (Inline_code_sexp { language = "wasm"; func_body }) - | _ -> Ok (Internal { func_name = s }) - | exception Dwarfsm_sexp_parse_error.Unmatched_parenthesis (l, r) - -> - let loc_inside_wasm = Loc.of_menhir (l, r) in - let message = "unmatched parenthesis" in - Partial - ( Internal { func_name = s }, - [ - Errors.inline_wasm_syntax_error ~loc_inside_wasm ~loc - ~message; - ] ) - | exception Wasm_lex.Syntax ({ left; right }, message) -> - let loc_inside_wasm = Loc.of_menhir (left, right) in - Partial - ( Internal { func_name = s }, - [ - Errors.inline_wasm_syntax_error ~loc_inside_wasm ~loc - ~message; - ] )) - | "C" | "c" -> - let all_chars_valid = - String.for_all - (fun c -> - ('0' <= c && c <= '9') - || ('a' <= c && c <= 'z') - || ('A' <= c && c <= 'Z') - || c = '_' || c = '$') - s - in - let stub = Inline_code_text { language; func_body = s } in - if - all_chars_valid - && String.length s > 1 - && not ('0' <= s.[0] && s.[0] <= '9') - then Ok stub - else Partial (stub, [ Errors.c_stub_invalid_function_name loc ]) - | language -> Ok (Inline_code_text { language; func_body = s }) - in - match code with - | Code_string s -> aux s.string_val - | Code_multiline_string xs -> aux (String.concat " " xs)) +exception Invalid_wasm_function_call of string + +let wasm_linear_whitelist = + [ "$moonbit.malloc"; "$moonbit.gc.malloc"; "$moonbit.decref" ] + +let wasm_gc_whitelist = [] + +let check_inlinewasm (func : Dwarfsm_ast.func) = + let whitelist = + match !Basic_config.target with + | Wasm_gc -> wasm_gc_whitelist + | Riscv -> [] + in + Dwarfsm_instr_utils.iter func.code (fun instr -> + match instr with + | Call { var = Unresolve name } | Ref_func { var = Unresolve name } -> + if not (Basic_lst.mem_string whitelist name) then + raise (Invalid_wasm_function_call name) + | _ -> ()) + +let from_syntax ~loc ~diagnostics (stub : Syntax.func_stubs) = + (match stub with + | Import { module_name; func_name } -> + Ok + (Import + { + module_name = module_name.string_val; + func_name = func_name.string_val; + }) + | Embedded { language; code } -> ( + let aux s = + (if + (match language with None -> true | _ -> false) + && String.length s >= 1 + && s.[0] = '$' + then Ok (Internal { func_name = s }) + else + let language = + match language with Some s -> s.string_val | None -> "wasm" + in + match language with + | "wasm" -> ( + match Dwarfsm_sexp_parse.parse s with + | ((List (Atom "func" :: _) : W.t) as func_body) :: [] -> ( + match !Basic_config.target with + | Wasm_gc -> ( + match Dwarfsm_parse.modulefield func_body with + | Dwarfsm_ast.Func func :: [] -> ( + match check_inlinewasm func with + | () -> + Ok + (Inline_code_sexp + { language = "wasm"; func_body }) + | exception Invalid_wasm_function_call name -> + let backend = + match !Basic_config.target with + | Wasm_gc -> "wasm_gc" + | Riscv -> "riscv" + in + let warning_msg = + (Stdlib.String.concat "" + [ + "Inline wasm invalid function call: \ + function "; + name; + " is not on the whitelist of the "; + backend; + " backend"; + ] [@merlin.hide]) + in + Diagnostics.add_warning diagnostics + { + loc; + kind = Invalid_inline_wasm warning_msg; + }; + Ok + (Inline_code_sexp + { language = "wasm"; func_body })) + | exception exn -> + let warning_msg = + (("Invalid inline wasm: " ^ Printexc.to_string exn + : Stdlib.String.t) + [@merlin.hide]) + in + Diagnostics.add_warning diagnostics + { loc; kind = Invalid_inline_wasm warning_msg }; + Ok + (Inline_code_sexp { language = "wasm"; func_body }) + | _ -> assert false) + | Riscv -> + (* RISC-V backend doesn't support inline WASM *) + Ok (Internal { func_name = s })) + | _ -> Ok (Internal { func_name = s }) + | exception Dwarfsm_sexp_parse_error.Unmatched_parenthesis (l, r) + -> + let loc_inside_wasm = Loc.of_menhir (l, r) in + let message = "unmatched parenthesis" in + Partial + ( Internal { func_name = s }, + [ + Errors.inline_wasm_syntax_error ~loc_inside_wasm ~loc + ~message; + ] ) + | exception Wasm_lex.Syntax ({ left; right }, message) -> + let loc_inside_wasm = + Loc.of_menhir + ( Lexing.of_stdlib_position left, + Lexing.of_stdlib_position right ) + in + Partial + ( Internal { func_name = s }, + [ + Errors.inline_wasm_syntax_error ~loc_inside_wasm ~loc + ~message; + ] )) + | "C" | "c" -> + let all_chars_valid = + String.for_all + (fun c -> + ('0' <= c && c <= '9') + || ('a' <= c && c <= 'z') + || ('A' <= c && c <= 'Z') + || c = '_' || c = '$') + s + in + let stub = Inline_code_text { language; func_body = s } in + if + all_chars_valid + && String.length s > 1 + && not ('0' <= s.[0] && s.[0] <= '9') + then Ok stub + else Partial (stub, [ Errors.c_stub_invalid_function_name loc ]) + | language -> Ok (Inline_code_text { language; func_body = s }) + : _ Partial_info.t) + in + match code with + | Code_string s -> aux s.string_val + | Code_multiline_string xs -> aux (String.concat " " xs)) + : t Partial_info.t) diff --git a/src/stype.ml b/src/stype.ml index 5256f1d..8f899a9 100644 --- a/src/stype.ml +++ b/src/stype.ml @@ -24,8 +24,10 @@ type builtin = | T_byte | T_char | T_int + | T_int16 | T_int64 | T_uint + | T_uint16 | T_uint64 | T_float | T_double @@ -39,13 +41,13 @@ type t = params_ty : t list; ret_ty : t; err_ty : t option; + is_async : bool; generic_ : bool; } | T_constr of { type_constructor : Type_path.t; tys : t list; generic_ : bool; - only_tag_enum_ : bool; is_suberror_ : bool; } | Tvar of tlink ref @@ -61,9 +63,11 @@ let unit = T_builtin T_unit let bool = T_builtin T_bool let byte = T_builtin T_byte let char = T_builtin T_char +let int16 = T_builtin T_int16 let int = T_builtin T_int let int64 = T_builtin T_int64 let uint = T_builtin T_uint +let uint16 = T_builtin T_uint16 let uint64 = T_builtin T_uint64 let float = T_builtin T_float let double = T_builtin T_double @@ -76,7 +80,6 @@ let error = type_constructor = Type_path.Builtin.type_path_error; tys = []; generic_ = false; - only_tag_enum_ = false; is_suberror_ = false; } @@ -86,7 +89,6 @@ let json = type_constructor = Type_path.Builtin.type_path_json; tys = []; generic_ = false; - only_tag_enum_ = false; is_suberror_ = false; } @@ -96,7 +98,6 @@ let bigint = type_constructor = Type_path.Builtin.type_path_bigint; tys = []; generic_ = false; - only_tag_enum_ = false; is_suberror_ = false; } @@ -104,52 +105,58 @@ let blackhole = T_blackhole let tnolink_normal = Tnolink Tvar_normal let tnolink_error = Tnolink Tvar_error -let new_type_var kind : t = - match kind with - | Tvar_normal -> Tvar (ref tnolink_normal) - | Tvar_error -> Tvar (ref tnolink_error) +let new_type_var kind = + (match kind with + | Tvar_normal -> Tvar (ref tnolink_normal) + | Tvar_error -> Tvar (ref tnolink_error) + : t) let rec sexp_of_t = function - | Tarrow { params_ty; ret_ty; err_ty; generic_ } -> ( + | Tarrow { params_ty; ret_ty; err_ty; is_async; generic_ } -> ( + let async = if is_async then [ S.Atom "async" ] else [] in match err_ty with | None -> (List - (List.cons - (sexp_of_ts params_ty : S.t) + (List.append + (async : S.t list) (List.cons - (Atom "->" : S.t) + (sexp_of_ts params_ty : S.t) (List.cons - (sexp_of_t ret_ty : S.t) - ([ - List - (List.cons - (Atom "generic_" : S.t) - ([ Moon_sexp_conv.sexp_of_bool generic_ ] - : S.t list)); - ] - : S.t list)))) + (Atom "->" : S.t) + (List.cons + (sexp_of_t ret_ty : S.t) + ([ + List + (List.cons + (Atom "generic_" : S.t) + ([ Moon_sexp_conv.sexp_of_bool generic_ ] + : S.t list)); + ] + : S.t list))))) : S.t) | Some err_ty -> let exclamation = S.Atom "!" in (List - (List.cons - (sexp_of_ts params_ty : S.t) + (List.append + (async : S.t list) (List.cons - (Atom "->" : S.t) + (sexp_of_ts params_ty : S.t) (List.cons - (sexp_of_t ret_ty : S.t) + (Atom "->" : S.t) (List.cons - (exclamation : S.t) + (sexp_of_t ret_ty : S.t) (List.cons - (sexp_of_t err_ty : S.t) - ([ - List - (List.cons - (Atom "generic_" : S.t) - ([ Moon_sexp_conv.sexp_of_bool generic_ ] - : S.t list)); - ] - : S.t list)))))) + (exclamation : S.t) + (List.cons + (sexp_of_t err_ty : S.t) + ([ + List + (List.cons + (Atom "generic_" : S.t) + ([ Moon_sexp_conv.sexp_of_bool generic_ ] + : S.t list)); + ] + : S.t list))))))) : S.t)) | T_constr { @@ -241,8 +248,10 @@ let rec sexp_of_t = function | T_builtin T_byte -> (Atom "Byte" : S.t) | T_builtin T_char -> (Atom "Char" : S.t) | T_builtin T_int -> (Atom "Int" : S.t) + | T_builtin T_int16 -> (Atom "Int16" : S.t) | T_builtin T_int64 -> (Atom "Int64" : S.t) | T_builtin T_uint -> (Atom "UInt" : S.t) + | T_builtin T_uint16 -> (Atom "UInt16" : S.t) | T_builtin T_uint64 -> (Atom "UInt64" : S.t) | T_builtin T_float -> (Atom "Float" : S.t) | T_builtin T_double -> (Atom "Double" : S.t) @@ -261,8 +270,10 @@ let tpath_of_builtin (t : builtin) = | T_byte -> B.type_path_byte | T_char -> B.type_path_char | T_int -> B.type_path_int + | T_int16 -> B.type_path_int16 | T_int64 -> B.type_path_int64 | T_uint -> B.type_path_uint + | T_uint16 -> B.type_path_uint16 | T_uint64 -> B.type_path_uint64 | T_float -> B.type_path_float | T_double -> B.type_path_double @@ -291,22 +302,24 @@ let is_external t = match p with | Toplevel { pkg; _ } -> pkg <> !Basic_config.current_package | Constr { ty; tag = _ } -> tpath_is_external ty - | Tuple _ | T_unit | T_bool | T_byte | T_char | T_int | T_int64 | T_uint - | T_uint64 | T_float | T_double | T_string | T_option | T_result - | T_error_value_result | T_fixedarray | T_bytes | T_ref | T_error -> + | Tuple _ | T_unit | T_bool | T_byte | T_char | T_int | T_int16 | T_int64 + | T_uint | T_uint16 | T_uint64 | T_float | T_double | T_string | T_option + | T_result | T_error_value_result | T_fixedarray | T_bytes | T_ref | T_error + -> false + | T_local _ -> false in match extract_tpath t with Some p -> tpath_is_external p | None -> false -let f desc : t = - T_constr - { - type_constructor = desc; - tys = []; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } +let f desc = + (T_constr + { + type_constructor = desc; + tys = []; + generic_ = false; + is_suberror_ = false; + } + : t) let type_sourceloc = f B.type_path_sourceloc let type_argsloc = f B.type_path_argsloc @@ -317,7 +330,6 @@ let type_iter_result = type_constructor = B.type_path_iter_result; tys = []; generic_ = false; - only_tag_enum_ = true; is_suberror_ = false; } @@ -330,7 +342,6 @@ let make_multi_value_result_ty ~ok_ty ~err_ty = { type_constructor = Type_path.Builtin.type_path_multi_value_result; tys = [ ok_ty; err_ty ]; - only_tag_enum_ = false; generic_ = false; is_suberror_ = false; } @@ -340,23 +351,20 @@ let make_result_ty ~ok_ty ~err_ty = { type_constructor = Type_path.Builtin.type_path_result; tys = [ ok_ty; err_ty ]; - only_tag_enum_ = false; generic_ = false; is_suberror_ = false; } -let is_error_function (t : t) : bool = - match t with Tarrow { err_ty = Some _; _ } -> true | _ -> false - -let rec type_repr (ty : t) : t = - match ty with - | Tvar ({ contents = Tlink (Tvar ({ contents = Tlink ty } as a0)) } as a1) -> - let ty = type_repr ty in - let link = Tlink ty in - a0 := link; - a1 := link; - ty - | Tvar { contents = Tlink ty } -> ty - | Tarrow _ | T_constr _ | Tvar _ | Tparam _ | T_trait _ | T_builtin _ - | T_blackhole -> - ty +let rec type_repr (ty : t) = + (match ty with + | Tvar ({ contents = Tlink (Tvar ({ contents = Tlink ty } as a0)) } as a1) -> + let ty = type_repr ty in + let link = Tlink ty in + a0 := link; + a1 := link; + ty + | Tvar { contents = Tlink ty } -> ty + | Tarrow _ | T_constr _ | Tvar _ | Tparam _ | T_trait _ | T_builtin _ + | T_blackhole -> + ty + : t) diff --git a/src/tag.ml b/src/tag.ml index fb2e62d..24ab497 100644 --- a/src/tag.ml +++ b/src/tag.ml @@ -23,31 +23,34 @@ include struct let _ = fun (_ : t) -> () let compare = - (fun a__001_ b__002_ -> - if Stdlib.( == ) a__001_ b__002_ then 0 - else Stdlib.compare (a__001_.index : int) b__002_.index + (fun a__001_ -> + fun b__002_ -> + if Stdlib.( == ) a__001_ b__002_ then 0 + else Stdlib.compare (a__001_.index : int) b__002_.index : t -> t -> int) let _ = compare let equal = - (fun a__003_ b__004_ -> - if Stdlib.( == ) a__003_ b__004_ then true - else Stdlib.( = ) (a__003_.index : int) b__004_.index + (fun a__003_ -> + fun b__004_ -> + if Stdlib.( == ) a__003_ b__004_ then true + else Stdlib.( = ) (a__003_.index : int) b__004_.index : t -> t -> bool) let _ = equal let (hash_fold_t : Ppx_base.state -> t -> Ppx_base.state) = - fun hsv arg -> - let hsv = - let hsv = - let hsv = hsv in - Ppx_base.hash_fold_int hsv arg.index - in - hsv - in - hsv + fun hsv -> + fun arg -> + let hsv = + let hsv = + let hsv = hsv in + Ppx_base.hash_fold_int hsv arg.index + in + hsv + in + hsv let _ = hash_fold_t @@ -62,13 +65,21 @@ include struct let _ = hash end -let sexp_of_t { name_; index = _ } : S.t = - List (List.cons (Atom "Constr_tag_regular" : S.t) ([ Atom name_ ] : S.t list)) +let sexp_of_t { name_; index = _ } = + (List + (List.cons (Atom "Constr_tag_regular" : S.t) ([ Atom name_ ] : S.t list)) + : S.t) let of_core_tag (extensible_tag_info : int Basic_hash_string.t) (tag : Basic_constr_info.constr_tag) = match tag with - | Constr_tag_regular { index; name_; is_constant_; _ } -> + | Constr_tag_regular { index; name_; repr_; _ } -> + let is_constant_ = + match repr_ with + | Constant -> true + | Non_constant -> false + | Integer _ -> assert false + in { index; name_; is_constant_ } | Extensible_tag { pkg; type_name; name; total = _; index = _ } -> ( let str = Basic_constr_info.ext_tag_to_str ~pkg ~type_name ~name in @@ -81,6 +92,12 @@ let of_core_tag (extensible_tag_info : int Basic_hash_string.t) let of_core_tag_no_ext (tag : Basic_constr_info.constr_tag) = match tag with - | Constr_tag_regular { index; name_; is_constant_; _ } -> + | Constr_tag_regular { index; name_; repr_; _ } -> + let is_constant_ = + match repr_ with + | Constant -> true + | Non_constant -> false + | Integer _ -> assert false + in { index; name_; is_constant_ } | Extensible_tag _ -> assert false diff --git a/src/text_segment.ml b/src/text_segment.ml new file mode 100644 index 0000000..128a9e6 --- /dev/null +++ b/src/text_segment.ml @@ -0,0 +1,93 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +type t = { + text_start_line : int; + text_name : string; + text_segment_code : string; +} + +include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (fun { + text_start_line = text_start_line__002_; + text_name = text_name__004_; + text_segment_code = text_segment_code__006_; + } + -> + let bnds__001_ = ([] : _ Stdlib.List.t) in + let bnds__001_ = + let arg__007_ = + Moon_sexp_conv.sexp_of_string text_segment_code__006_ + in + (S.List [ S.Atom "text_segment_code"; arg__007_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__005_ = Moon_sexp_conv.sexp_of_string text_name__004_ in + (S.List [ S.Atom "text_name"; arg__005_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__003_ = Moon_sexp_conv.sexp_of_int text_start_line__002_ in + (S.List [ S.Atom "text_start_line"; arg__003_ ] :: bnds__001_ + : _ Stdlib.List.t) + in + S.List bnds__001_ + : t -> S.t) + + let _ = sexp_of_t +end + +let of_string ?(name = "") str = + (let get i = if i >= String.length str then '\000' else str.[i] in + let rec loop i lnum (bol : int) acc = + match get i with + | '\n' -> match_block_line (i + 1) (lnum + 1) (i + 1) acc + | '\r' -> ( + match get (i + 1) with + | '\n' -> match_block_line (i + 2) (lnum + 1) (i + 2) acc + | _ -> loop (i + 1) lnum bol acc) + | '\000' -> List.rev ((lnum, String.length str) :: acc) + | _ -> loop (i + 1) lnum bol acc + and match_block_line i lnum bol acc = + if + get i = '/' + && get (i + 1) = '/' + && get (i + 2) = '/' + && get (i + 3) = '|' + then loop (i + 4) lnum bol ((lnum, bol) :: acc) + else loop i lnum bol acc + in + let points = loop 0 1 0 [ (1, 0) ] in + let rec slice points acc = + match points with + | (line, start_offset) :: ((_, end_offset) :: _ as remain) -> + let offset = start_offset in + let length = end_offset - start_offset in + let buf = String.sub str offset length in + slice remain + ({ + text_segment_code = buf; + text_start_line = line; + text_name = name; + } + :: acc) + | _ -> List.rev acc + in + slice points [] + : t list) diff --git a/src/toplevel_segments.ml b/src/toplevel_segments.ml new file mode 100644 index 0000000..13819f5 --- /dev/null +++ b/src/toplevel_segments.ml @@ -0,0 +1,71 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Vec = Basic_vec +module Vec_token = Lex_vec_token + +type t = Parsing_segment.t + +let toplevel_segments (tokens : Vec_token.t) = + (let start = 0 in + let rec get_slice_points index (topmost_related_token : int option) acc = + let tok, loca, _ = Vec.get tokens index in + let left_aligned = loca.pos_cnum = loca.pos_bol in + match tok with + | PUB | PRIV | TYPE | STRUCT | ENUM | ASYNC | FN | LET | CONST | TRAIT + | TRAITALIAS | TEST | IMPL | EXTERN | TYPEALIAS + when left_aligned -> + let point = + match topmost_related_token with + | Some top_index -> top_index + | None -> index + in + get_slice_points (index + 1) None (point :: acc) + | EOF -> List.rev (index :: acc) + | ATTRIBUTE _ -> + let topmost_related_token = + match topmost_related_token with + | None -> Some index + | _ -> topmost_related_token + in + let next = + if index + 2 < Vec.length tokens then index + 2 else index + 1 + in + get_slice_points next topmost_related_token acc + | COMMENT _ -> + let topmost_related_token = + match topmost_related_token with + | None when left_aligned -> Some index + | Some _ when not left_aligned -> None + | _ -> topmost_related_token + in + let next = + if index + 2 < Vec.length tokens then index + 2 else index + 1 + in + get_slice_points next topmost_related_token acc + | _ -> get_slice_points (index + 1) None acc + in + let rec slice ps = + match ps with + | l :: (r :: _ as remain) -> + if r - l > 0 then + let seg = Parsing_segment.from ~start:l ~len:(r - l) tokens in + seg :: slice remain + else slice remain + | _ -> [] + [@@tail_mod_cons] + in + slice (get_slice_points start None [ start ]) + : t list) diff --git a/src/toplevel_typer.ml b/src/toplevel_typer.ml index fb75cb9..4970e14 100644 --- a/src/toplevel_typer.ml +++ b/src/toplevel_typer.ml @@ -18,8 +18,10 @@ module Config = Basic_config module Constr_info = Basic_constr_info module Lst = Basic_lst module Vec = Basic_vec +module Arr = Basic_arr module Type_path = Basic_type_path module Hash_string = Basic_hash_string +module Hash_int = Basic_hash_int module Strutil = Basic_strutil module Syntax = Parsing_syntax module Operators = Parsing_operators @@ -31,10 +33,11 @@ let trait_not_implemented ~trait ~type_name ~failure_reasons ~loc = Lst.map failure_reasons (fun reason -> match reason with | `Method_missing name -> - ("method " ^ name ^ " is missing" : Stdlib.String.t) + ("method " ^ name ^ " is missing" : Stdlib.String.t) [@merlin.hide] | `Private_method name -> ("implementation of method " ^ name ^ " is private" : Stdlib.String.t) + [@merlin.hide] | `Type_mismatch (name, expected, actual) -> Stdlib.String.concat "" [ @@ -44,10 +47,15 @@ let trait_not_implemented ~trait ~type_name ~failure_reasons ~loc = expected; ", but has type "; actual; - ] + ] [@merlin.hide] | `Method_constraint_not_satisfied name -> ("constraints of method " ^ name ^ " are not satisfied" - : Stdlib.String.t)) + : Stdlib.String.t) + [@merlin.hide] + | `Method_type_params_unsolved name -> + ("cannot decide type parameters of method " ^ name + : Stdlib.String.t) + [@merlin.hide]) in Errors.trait_not_implemented ~trait ~type_name ~failure_reasons ~loc @@ -64,10 +72,12 @@ let rec check_duplicate (xs : 'a list) (f : 'a -> 'a -> bool) = | x :: rest -> if Lst.exists rest (f x) then Some x else check_duplicate rest f -let duplicate_import_help_message kind : Stdlib.String.t = - "This " ^ kind - ^ " is imported implicitly because \"test-import-all\" is set to true in the \ - config file" +let duplicate_import_help_message kind = + ("This " ^ kind + ^ " is imported implicitly because \"test-import-all\" is set to true \ + implicitly. If you want to avoid this, set \"test-import-all\" to false \ + in moon.pkg.json." + : Stdlib.String.t) let get_duplicate_loc_info (v : Value_info.toplevel) = match v.direct_use_loc_ with @@ -78,99 +88,134 @@ let get_duplicate_loc_info (v : Value_info.toplevel) = let typing_type ~(allow_private : bool) ?(placeholder_env : Placeholder_env.t option) (te : Syntax.typ) - ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) ~diagnostics : - Typedtree.typ = - Typeutil.typing_type ~allow_private ~is_toplevel:true ?placeholder_env - ~tvar_env ~types te - |> take_info_partial ~diagnostics + ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) ~diagnostics = + (Typeutil.typing_type ~allow_private ~allow_partial:false ?placeholder_env + ~tvar_env ~types ~local_type_env:None te ~diagnostics + : Typedtree.typ) let typing_error_type ~(allow_private : bool) ?(placeholder_env : Placeholder_env.t option) (err_ty : Syntax.error_typ) ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) ~has_error - ~header_loc ~diagnostics : Stype.t option * Typedtree.error_typ = - match err_ty with - | Error_typ { ty } -> - let typ = - typing_type ~allow_private ?placeholder_env ~tvar_env ~types - ~diagnostics ty - in - let stype = Typedtree_util.stype_of_typ typ in - if not (Type.is_error_type ~tvar_env stype) then - add_error diagnostics - (Errors.not_error_subtype - (Printer.type_to_string stype) - (Typedtree.loc_of_typ typ)); - (Some stype, Error_typ { ty = typ }) - | Default_error_typ { loc_ } -> - (Some Typeutil.default_err_type, Default_error_typ { loc_ }) - | No_error_typ when has_error -> - (Some Typeutil.default_err_type, Default_error_typ { loc_ = header_loc }) - | No_error_typ -> (None, No_error_typ) + ~header_loc ~diagnostics = + (match err_ty with + | Error_typ { ty } -> + let typ = + typing_type ~allow_private ?placeholder_env ~tvar_env ~types + ~diagnostics ty + in + let stype = Typedtree_util.stype_of_typ typ in + if not (Type.is_error_type ~tvar_env stype) then + add_error diagnostics + (Errors.not_error_subtype + (Printer.type_to_string stype) + (Typedtree.loc_of_typ typ)); + (Some stype, Error_typ { ty = typ }) + | Default_error_typ { loc_ } -> + (Some Typeutil.default_err_type, Default_error_typ { loc_ }) + | No_error_typ when has_error -> + (Some Typeutil.default_err_type, Default_error_typ { loc_ = header_loc }) + | No_error_typ -> (None, No_error_typ) + : Stype.t option * Typedtree.error_typ) let typing_trait_name ~types ~allow_private trait ~diagnostics = - Typeutil.typing_trait_name ~types ~allow_private trait - |> take_info_partial ~diagnostics + Typeutil.typing_trait_name ~types ~allow_private trait ~diagnostics let collect_types_and_traits (impls : Syntax.impls) ~foreign_types - ~(diagnostics : Diagnostics.t) : Placeholder_env.t = - let type_defs : Syntax.type_decl Hash_string.t = Hash_string.create 17 in - let trait_defs : Syntax.trait_decl Hash_string.t = Hash_string.create 17 in - let find_declared_type name = - match Hash_string.find_opt type_defs name with - | Some { loc_; _ } -> Some (loc_, None) - | None -> ( - match - Global_env.All_types.find_type_alias foreign_types - (Basic_longident.Lident name) - with - | Some alias -> - Some (alias.loc_, Some (duplicate_import_help_message "type")) - | None -> None) - in - let go (impl : Syntax.impl) = - match impl with - | Ptop_expr _ | Ptop_test _ | Ptop_letdef _ | Ptop_funcdef _ | Ptop_impl _ - | Ptop_impl_relation _ -> - () - | Ptop_typedef decl -> ( - let base = decl.loc_ in - let tycon_loc_ = Rloc.to_loc ~base decl.tycon_loc_ in - let name = decl.tycon in - match find_declared_type name with - | Some (first_loc, extra_message) -> - add_global_error diagnostics - (Errors.type_redeclare ~name ~first_loc ~second_loc:tycon_loc_ - ~extra_message); - if extra_message <> None then Hash_string.add type_defs name decl - | None -> ( - Hash_string.add type_defs name decl; - match Hash_string.find_opt trait_defs name with - | Some i -> - add_global_error diagnostics - (Errors.type_trait_duplicate ~name ~first_kind:"trait" - ~first_loc:i.trait_loc_ ~second_kind:"type" - ~second_loc:tycon_loc_ ~extra_message:None) - | None -> ())) - | Ptop_trait trait_decl -> ( - let name = trait_decl.trait_name.binder_name in - let trait_loc_ = trait_decl.trait_loc_ in - match Hash_string.find_opt trait_defs name with - | Some i -> - add_global_error diagnostics - (Errors.trait_redeclare ~name ~first_loc:i.trait_loc_ - ~second_loc:trait_loc_) - | None -> ( - Hash_string.add trait_defs name trait_decl; - match find_declared_type name with - | Some (loc, extra_message) -> - add_global_error diagnostics - (Errors.type_trait_duplicate ~name ~first_kind:"type" - ~first_loc:loc ~second_kind:"trait" ~second_loc:trait_loc_ - ~extra_message) - | None -> ())) - in - Lst.iter impls go; - Placeholder_env.make ~foreign_types ~type_defs ~trait_defs + ~(diagnostics : Diagnostics.t) = + (let type_defs : Syntax.type_decl Hash_string.t = Hash_string.create 17 in + let trait_defs : Syntax.trait_decl Hash_string.t = Hash_string.create 17 in + let trait_alias : Syntax.impl Hash_string.t = Hash_string.create 17 in + let find_declared_type name = + match Hash_string.find_opt type_defs name with + | Some { loc_; _ } -> Some (loc_, None) + | None -> ( + match + Global_env.All_types.find_type_alias foreign_types + (Basic_longident.Lident name) + with + | Some alias -> + Some (alias.loc_, Some (duplicate_import_help_message "type")) + | None -> None) + in + let go (impl : Syntax.impl) = + match impl with + | Ptop_expr _ | Ptop_test _ | Ptop_letdef _ | Ptop_funcdef _ | Ptop_impl _ + | Ptop_impl_relation _ -> + () + | Ptop_typedef decl -> ( + let base = decl.loc_ in + let tycon_loc_ = Rloc.to_loc ~base decl.tycon_loc_ in + let name = decl.tycon in + match find_declared_type name with + | Some (first_loc, extra_message) -> + add_global_error diagnostics + (Errors.type_redeclare ~name ~first_loc ~second_loc:tycon_loc_ + ~extra_message); + if extra_message <> None then Hash_string.add type_defs name decl + | None -> ( + Hash_string.add type_defs name decl; + match Hash_string.find_opt trait_defs name with + | Some i -> + add_global_error diagnostics + (Errors.type_trait_duplicate ~name ~first_kind:"trait" + ~first_loc:i.trait_loc_ ~second_kind:"type" + ~second_loc:tycon_loc_ ~extra_message:None) + | None -> ())) + | Ptop_trait trait_decl -> ( + let name = trait_decl.trait_name.binder_name in + let trait_loc_ = trait_decl.trait_loc_ in + match Hash_string.find_opt trait_alias name with + | Some first_def -> ( + match[@warning "-fragile-match"] first_def with + | Ptop_trait_alias first_def -> + add_global_error diagnostics + (Errors.trait_redeclare ~name ~first_loc:first_def.loc_ + ~second_loc:trait_loc_) + | _ -> assert false) + | None -> ( + match Hash_string.find_opt trait_defs name with + | Some i -> + add_global_error diagnostics + (Errors.trait_redeclare ~name ~first_loc:i.trait_loc_ + ~second_loc:trait_loc_) + | None -> ( + Hash_string.add trait_defs name trait_decl; + match find_declared_type name with + | Some (loc, extra_message) -> + add_global_error diagnostics + (Errors.type_trait_duplicate ~name ~first_kind:"type" + ~first_loc:loc ~second_kind:"trait" + ~second_loc:trait_loc_ ~extra_message) + | None -> ()))) + | Ptop_trait_alias { binder; loc_; _ } -> ( + let name = binder.binder_name in + match Hash_string.find_opt trait_alias name with + | Some first_def -> ( + match[@warning "-fragile-match"] first_def with + | Ptop_trait_alias first_def -> + add_global_error diagnostics + (Errors.trait_redeclare ~name ~first_loc:first_def.loc_ + ~second_loc:loc_) + | _ -> assert false) + | None -> ( + match Hash_string.find_opt trait_defs name with + | Some first_def -> + add_global_error diagnostics + (Errors.trait_redeclare ~name ~first_loc:first_def.trait_loc_ + ~second_loc:loc_) + | None -> ( + Hash_string.add trait_alias name impl; + match find_declared_type name with + | Some (loc, extra_message) -> + add_global_error diagnostics + (Errors.type_trait_duplicate ~name ~first_kind:"type" + ~first_loc:loc ~second_kind:"trait" ~second_loc:loc_ + ~extra_message) + | None -> ()))) + in + Lst.iter impls ~f:go; + Placeholder_env.make ~foreign_types ~type_defs ~trait_defs ~trait_alias + : Placeholder_env.t) let check_operator_decl ~(diagnostics : Local_diagnostics.t) ~(loc : Rloc.t) method_name ty = @@ -204,138 +249,114 @@ let check_operator_decl ~(diagnostics : Local_diagnostics.t) ~(loc : Rloc.t) let typing_trait_method_decl ~is_pub (method_decl : Syntax.trait_method_decl) ~(placeholder_env : Placeholder_env.t) ~(types : Global_env.All_types.t) - ~(base : Loc.t) ~diagnostics : - Trait_decl.method_decl * Typedtree.method_decl = - let (Trait_method - { name; has_error; quantifiers = _; params; return_type; loc_ }) = - method_decl - in - let meth_loc = Rloc.to_loc ~base loc_ in - let tvar_env = Tvar_env.tvar_env_self in - let params_ty, tast_params = - Lst.map_split params (fun p -> - let typ = - typing_type ~allow_private:(not is_pub) ~placeholder_env ~types - ~tvar_env p.tmparam_typ ~diagnostics - in - (Typedtree_util.stype_of_typ typ, (p.tmparam_label, typ))) - in - let ret_ty, ret_typ, err_ty, err_typ = - match return_type with - | Some (return_type, err_type) -> - let typ = - typing_type ~allow_private:(not is_pub) ~placeholder_env ~types - ~tvar_env return_type ~diagnostics - in - let error_stype, error_typ = - typing_error_type ~allow_private:(not is_pub) ~placeholder_env ~types - ~tvar_env ~diagnostics ~has_error ~header_loc:name.loc_ err_type - in - let error_typ = - match error_typ with - | Error_typ { ty } -> Some ty - | Default_error_typ _ -> Some Typeutil.default_err_typedtree_type - | No_error_typ -> None - in - (Typedtree_util.stype_of_typ typ, Some typ, error_stype, error_typ) - | None -> - add_error diagnostics (Errors.missing_return_annot name.loc_); - (Stype.blackhole, None, None, None) - in - let method_arity = - Fn_arity.from_trait_method_params params ~base - |> take_info_partial ~diagnostics - in - let method_name = name.binder_name in - let method_typ : Stype.t = - Tarrow { params_ty; ret_ty; err_ty; generic_ = true } - in - check_operator_decl ~diagnostics ~loc:name.loc_ method_name method_typ; - let method_decl : Trait_decl.method_decl = - { - method_name = name.binder_name; - method_typ; - method_arity; - method_loc_ = meth_loc; - } - in - let tast_decl : Typedtree.method_decl = - { - method_name = name; - method_params = tast_params; - method_ret = ret_typ; - method_err = err_typ; - method_loc_ = loc_; - } - in - (method_decl, tast_decl) + ~(base : Loc.t) ~diagnostics = + (let (Trait_method + { name; has_error; quantifiers = _; params; return_type; loc_ }) = + method_decl + in + let meth_loc = Rloc.to_loc ~base loc_ in + let tvar_env = Tvar_env.tvar_env_self in + let params_ty, tast_params = + Lst.map_split params (fun p -> + let typ = + typing_type ~allow_private:(not is_pub) ~placeholder_env ~types + ~tvar_env p.tmparam_typ ~diagnostics + in + (Typedtree_util.stype_of_typ typ, (p.tmparam_label, typ))) + in + let ret_ty, ret_typ, err_ty, err_typ = + match return_type with + | Some (return_type, err_type) -> + let typ = + typing_type ~allow_private:(not is_pub) ~placeholder_env ~types + ~tvar_env return_type ~diagnostics + in + let error_stype, error_typ = + typing_error_type ~allow_private:(not is_pub) ~placeholder_env ~types + ~tvar_env ~diagnostics ~has_error ~header_loc:name.loc_ err_type + in + let error_typ = + match error_typ with + | Error_typ { ty } -> Some ty + | Default_error_typ _ -> Some Typeutil.default_err_typedtree_type + | No_error_typ -> None + in + (Typedtree_util.stype_of_typ typ, Some typ, error_stype, error_typ) + | None -> + add_error diagnostics (Errors.missing_return_annot name.loc_); + (Stype.blackhole, None, None, None) + in + let method_arity = + take_info_partial ~diagnostics + (Fn_arity.from_trait_method_params params ~base) + in + let method_name = name.binder_name in + let method_typ : Stype.t = + Tarrow { params_ty; ret_ty; err_ty; generic_ = true; is_async = false } + in + check_operator_decl ~diagnostics ~loc:name.loc_ method_name method_typ; + let method_decl : Trait_decl.method_decl = + { + method_name = name.binder_name; + method_typ; + method_arity; + method_loc_ = meth_loc; + } + in + let tast_decl : Typedtree.method_decl = + { + method_name = name; + method_params = tast_params; + method_ret = ret_typ; + method_err = err_typ; + method_loc_ = loc_; + } + in + (method_decl, tast_decl) + : Trait_decl.method_decl * Typedtree.method_decl) type toplevel_env = Typing_info.values -let transl_type_vis ~diagnostics (vis : Syntax.visibility) : - Typedecl_info.visibility = - match vis with - | Vis_priv _ -> Vis_priv - | Vis_default -> Vis_default - | Vis_pub { attr = None; loc_ } -> - Local_diagnostics.add_warning diagnostics - { - loc = loc_; - kind = - Deprecated_syntax - { - old_usage = "`pub`"; - purpose = "declaring a fully public struct/enum/newtype"; - new_usage = - Some - "`pub` will default to the semantic of `pub(readonly)` in \ - the future, to declare a fully public type, use \ - `pub(all)`"; - }; - }; - Vis_fully_pub - | Vis_pub { attr = Some "all" } -> Vis_fully_pub - | Vis_pub { attr = Some "" } -> Vis_fully_pub - | Vis_pub { attr = Some "readonly" } -> Vis_readonly - | Vis_pub { attr = Some attr; loc_ } -> - add_error diagnostics - (Errors.unsupported_modifier - ~modifier:("pub(" ^ attr ^ ")" : Stdlib.String.t) - ~loc:loc_); - Vis_fully_pub +let transl_type_vis ~diagnostics (vis : Syntax.visibility) = + (match vis with + | Vis_priv _ -> Vis_priv + | Vis_default -> Vis_default + | Vis_pub { attr = None } -> Vis_readonly + | Vis_pub { attr = Some "all" } -> Vis_fully_pub + | Vis_pub { attr = Some "" } -> Vis_fully_pub + | Vis_pub { attr = Some attr; loc_ } -> + add_error diagnostics + (Errors.unsupported_modifier + ~modifier:(("pub(" ^ attr ^ ")" : Stdlib.String.t) [@merlin.hide]) + ~loc:loc_); + Vis_fully_pub + : Typedecl_info.visibility) + +let transl_trait_vis ~diagnostics (vis : Syntax.visibility) = + (match vis with + | Vis_priv _ -> Vis_priv + | Vis_default -> Vis_default + | Vis_pub { attr = None } -> Vis_readonly + | Vis_pub { attr = Some "" } -> Vis_fully_pub + | Vis_pub { attr = Some "open" } -> Vis_fully_pub + | Vis_pub { attr = Some attr; loc_ } -> + add_error diagnostics + (Errors.unsupported_modifier + ~modifier:(("pub(" ^ attr ^ ")" : Stdlib.String.t) [@merlin.hide]) + ~loc:loc_); + Vis_fully_pub + : Typedecl_info.visibility) -let transl_trait_vis ~diagnostics (vis : Syntax.visibility) : - Typedecl_info.visibility = +let transl_value_visibility ~local_diagnostics ~entity (vis : Syntax.visibility) + = match vis with - | Vis_priv _ -> Vis_priv - | Vis_default -> Vis_default - | Vis_pub { attr = None; loc_ } -> - Local_diagnostics.add_warning diagnostics - { - loc = loc_; - kind = - Deprecated_syntax - { - old_usage = "`pub trait`"; - purpose = - "declaring a fully public trait that can be implemented \ - outside current package"; - new_usage = - Some - "`pub trait` will default to `pub(readonly)` trait in the \ - future, to declare a fully public trait, use `pub(open)`"; - }; - }; - Vis_fully_pub - | Vis_pub { attr = Some "" } -> Vis_fully_pub - | Vis_pub { attr = Some "readonly" } -> Vis_readonly - | Vis_pub { attr = Some "open" } -> Vis_fully_pub - | Vis_pub { attr = Some attr; loc_ } -> - add_error diagnostics - (Errors.unsupported_modifier - ~modifier:("pub(" ^ attr ^ ")" : Stdlib.String.t) + | Vis_default -> false + | Vis_pub { attr = None } -> true + | Vis_priv { loc_ } | Vis_pub { attr = Some _; loc_ } -> + add_error local_diagnostics + (Errors.invalid_visibility ~entity ~vis:(Syntax.string_of_vis vis) ~loc:loc_); - Vis_fully_pub + false let transl_component_vis = function | Typedecl_info.Vis_default | Vis_priv -> Typedecl_info.Invisible @@ -345,703 +366,930 @@ let transl_component_vis = function let submit_variant (ty_res : Stype.t) (ty_vis : Typedecl_info.visibility) (cs : Syntax.constr_decl list) (tvar_env : Tvar_env.t) ~(placeholder_env : Placeholder_env.t) ~(types : Global_env.All_types.t) - (toplevel : toplevel_env) ~(is_exn : bool) ~(type_name : string) - ~(base : Loc.t) ~diagnostics : - Typedecl_info.type_components * Typedtree.type_desc = - let n = List.length cs in - let allow_private = - match ty_vis with - | Vis_default | Vis_priv -> true - | Vis_readonly | Vis_fully_pub -> false - in - let cds, tast_cds = - Lst.mapi cs (fun i constr -> - let ({ constr_name; constr_args = args; constr_loc_ = cs_loc_ } - : Syntax.constr_decl) = - constr - in - let name = constr_name.name in - let args, cs_arity_ = - match args with - | None -> ([], Fn_arity.simple 0) - | Some args -> - ( args, - take_info_partial ~diagnostics - (Fn_arity.from_constr_params ~base args) ) - in - let cs_args, tast_args = - Lst.map_split args (fun arg -> - let typ = - typing_type ~allow_private ~tvar_env ~placeholder_env ~types - ~diagnostics arg.cparam_typ - in - let tast_arg : Typedtree.constr_decl_arg = - { - carg_typ = typ; - carg_mut = arg.cparam_mut; - carg_label = arg.cparam_label; - } - in - (Typedtree_util.stype_of_typ typ, tast_arg)) - in - let cs_vis = transl_component_vis ty_vis in - let cs_tag : Constr_info.constr_tag = - if is_exn then - Extensible_tag - { - pkg = !Config.current_package; - type_name; - name; - total = n; - index = i; - } - else - Constr_tag_regular - { - total = n; - index = i; - name_ = name; - is_constant_ = cs_args = []; - } - in - let constr : Typedecl_info.constructor = - let cs_constr_loc_ = Rloc.to_loc ~base constr_name.loc_ in - let cs_loc_ = Rloc.to_loc ~base cs_loc_ in - { - constr_name = name; - cs_res = ty_res; - cs_args; - cs_tag; - cs_vis; - cs_ty_params_ = tvar_env; - cs_arity_; - cs_constr_loc_; - cs_loc_; - } - in - let constr_decl : Typedtree.constr_decl = - { - constr_name = { label_name = name; loc_ = constr_name.loc_ }; - constr_tag = cs_tag; - constr_args = tast_args; - constr_arity_ = cs_arity_; - constr_loc_ = cs_loc_; - } - in - Typing_info.add_constructor toplevel constr; - (constr, constr_decl)) - |> List.split - in - if is_exn then (ErrorEnum_type cds, Td_error (Enum_payload tast_cds)) - else (Variant_type cds, Td_variant tast_cds) + (toplevel : toplevel_env) ~(is_exn : bool) ~(is_only_tag_enum : bool) + ~(type_name : string) ~(base : Loc.t) ~diagnostics = + (let total = + let n = List.length cs in + if n = 0 then Constr_info.Index_set.empty + else Constr_info.Index_set.singleton 0 (n - 1) + in + let allow_private = + match ty_vis with + | Vis_default | Vis_priv -> true + | Vis_readonly | Vis_fully_pub -> false + in + let curr_repr = ref 0 in + let repr_dedup_map = Hash_int.create 7 in + let cds, tast_cds = + List.split + (Lst.mapi cs (fun i -> + fun constr -> + let ({ + constr_name; + constr_args = args; + constr_tag; + constr_loc_ = cs_loc_; + } + : Syntax.constr_decl) = + constr + in + let name = constr_name.name in + let args, cs_arity_ = + match args with + | None -> ([], Fn_arity.simple 0) + | Some args -> + ( args, + take_info_partial ~diagnostics + (Fn_arity.from_constr_params ~base args) ) + in + let cs_args, tast_args = + Lst.map_split args (fun arg -> + let typ = + typing_type ~allow_private ~tvar_env ~placeholder_env + ~types ~diagnostics arg.cparam_typ + in + let tast_arg : Typedtree.constr_decl_arg = + { + carg_typ = typ; + carg_mut = arg.cparam_mut; + carg_label = arg.cparam_label; + } + in + (Typedtree_util.stype_of_typ typ, tast_arg)) + in + let cs_vis = transl_component_vis ty_vis in + let repr_ : Constr_info.constr_repr = + if is_only_tag_enum then + match constr_tag with + | None -> + let value = !curr_repr in + curr_repr := value + 1; + (match Hash_int.find_opt repr_dedup_map value with + | None -> + Hash_int.add repr_dedup_map value constr_name.name + | Some first -> + Local_diagnostics.add_error diagnostics + (Errors.enum_tag_duplicate ~first + ~tag:(string_of_int value) ~loc:constr_name.loc_)); + Integer value + | Some (tag_repr, tag_loc) -> ( + match Int32.of_string_opt tag_repr with + | None -> + Local_diagnostics.add_error diagnostics + (Errors.overflow ~value:tag_repr ~loc:tag_loc); + Constant + | Some value -> + let value = Int32.to_int value in + curr_repr := value + 1; + (match Hash_int.find_opt repr_dedup_map value with + | None -> + Hash_int.add repr_dedup_map value constr_name.name + | Some first -> + Local_diagnostics.add_error diagnostics + (Errors.enum_tag_duplicate ~first ~tag:tag_repr + ~loc:tag_loc)); + Integer value) + else ( + (match constr_tag with + | Some (_, tag_loc) -> + Local_diagnostics.add_error diagnostics + (Errors.non_constant_enum_no_custom_tag tag_loc) + | _ -> ()); + match cs_args with [] -> Constant | _ -> Non_constant) + in + let cs_tag : Constr_info.constr_tag = + if is_exn then + Extensible_tag + { + pkg = !Config.current_package; + type_name; + name; + total; + index = i; + } + else Constr_tag_regular { total; index = i; name_ = name; repr_ } + in + let constr : Typedecl_info.constructor = + let cs_constr_loc_ = Rloc.to_loc ~base constr_name.loc_ in + let cs_loc_ = Rloc.to_loc ~base cs_loc_ in + { + constr_name = name; + cs_res = ty_res; + cs_args; + cs_tag; + cs_vis; + cs_ty_params_ = tvar_env; + cs_arity_; + cs_constr_loc_; + cs_loc_; + } + in + let constr_decl : Typedtree.constr_decl = + { + constr_name = { label_name = name; loc_ = constr_name.loc_ }; + constr_tag = cs_tag; + constr_args = tast_args; + constr_arity_ = cs_arity_; + constr_loc_ = cs_loc_; + } + in + Typing_info.add_constructor toplevel constr; + (constr, constr_decl))) + in + if is_exn then (ErrorEnum_type cds, Td_error (Enum_payload tast_cds)) + else (Variant_type cds, Td_variant tast_cds) + : Typedecl_info.type_components * Typedtree.type_desc) let submit_field (ty_record : Stype.t) (ty_vis : Typedecl_info.visibility) (fs : Syntax.field_decl list) (tvar_env : Tvar_env.t) ~(placeholder_env : Placeholder_env.t) ~(types : Global_env.All_types.t) - (toplevel : toplevel_env) ~diagnostics ~base : - Typedecl_info.type_components * Typedtree.type_desc = - let all_labels = Lst.map fs (fun f -> f.field_name.label) in - let has_private_field = ref false in - let fields, tast_fields = - Lst.mapi fs (fun i f -> - let ({ - field_name = name; - field_ty = ty_expr; - field_mut = mut; - field_loc_ = loc_; - field_vis; - } - : Syntax.field_decl) = - f - in - let field_vis : Typedecl_info.visibility = - match field_vis with - | Vis_priv _ -> - has_private_field := true; - Vis_priv - | Vis_pub _ | Vis_default -> ty_vis - in - let vis = transl_component_vis field_vis in - let allow_private = - match vis with Read_write | Readable -> false | Invisible -> true - in - let field_typ = - typing_type ty_expr ~allow_private ~placeholder_env ~tvar_env ~types - ~diagnostics - in - let field : Typedecl_info.field = - { - field_name = name.label; - all_labels; - pos = i; - ty_field = Typedtree_util.stype_of_typ field_typ; - mut; - vis; - ty_record; - ty_params_ = tvar_env; - label_loc_ = Rloc.to_loc ~base name.loc_; - loc_ = Rloc.to_loc ~base loc_; - } - in - let field_decl : Typedtree.field_decl = - { - field_label = { label_name = name.label; loc_ = name.loc_ }; - field_typ; - field_mut = mut; - field_vis; - field_loc_ = loc_; - } - in - Typing_info.add_field toplevel ~field; - (field, field_decl)) - |> List.split - in - let has_private_field_ = !has_private_field in - (Record_type { fields; has_private_field_ }, Td_record tast_fields) + (toplevel : toplevel_env) ~diagnostics ~base = + (let all_labels = Lst.map fs (fun f -> f.field_name.label) in + let has_private_field = ref false in + let fields, tast_fields = + List.split + (Lst.mapi fs (fun i -> + fun f -> + let ({ + field_name = name; + field_ty = ty_expr; + field_mut = mut; + field_loc_ = loc_; + field_vis; + } + : Syntax.field_decl) = + f + in + let vis : Typedecl_info.type_component_visibility = + match field_vis with + | Vis_priv _ -> + has_private_field := true; + Invisible + | Vis_pub _ | Vis_default -> transl_component_vis ty_vis + in + let allow_private = + match vis with + | Read_write | Readable -> false + | Invisible -> true + in + let field_typ = + typing_type ty_expr ~allow_private ~placeholder_env ~tvar_env + ~types ~diagnostics + in + let field : Typedecl_info.field = + { + field_name = name.label; + all_labels; + pos = i; + ty_field = Typedtree_util.stype_of_typ field_typ; + mut; + vis; + ty_record; + ty_params_ = tvar_env; + label_loc_ = Rloc.to_loc ~base name.loc_; + loc_ = Rloc.to_loc ~base loc_; + } + in + let field_decl : Typedtree.field_decl = + { + field_label = { label_name = name.label; loc_ = name.loc_ }; + field_typ; + field_mut = mut; + field_vis = vis; + field_loc_ = loc_; + } + in + Typing_info.add_field toplevel ~field; + (field, field_decl))) + in + let has_private_field_ = !has_private_field in + (Record_type { fields; has_private_field_ }, Td_record tast_fields) + : Typedecl_info.type_components * Typedtree.type_desc) let typing_typedef (decl : Syntax.type_decl) ~(placeholder_env : Placeholder_env.t) (types : Global_env.All_types.t) - (toplevel : toplevel_env) ~(diagnostics : Local_diagnostics.t) : - Typedtree.type_decl = - let name = decl.tycon in - let tvar_env = Typeutil.typing_type_decl_binders decl.params in - let base = decl.loc_ in - let ty_vis = transl_type_vis ~diagnostics decl.type_vis in - let tycon_loc_ = Rloc.to_loc ~base decl.tycon_loc_ in - let type_constructor = - Type_path.toplevel_type ~pkg:!Basic_config.current_package decl.tycon - in - let ty_args = Tvar_env.get_types tvar_env in - let only_tag_enum_ = - match decl.components with - | Ptd_variant cs -> - Lst.for_all cs (fun { constr_args; _ } -> constr_args = None) - | _ -> false - in - let is_suberror_ = - match decl.components with Ptd_error _ -> true | _ -> false - in - let ty_res : Stype.t = - T_constr - { - type_constructor; - tys = ty_args; - generic_ = ty_args <> []; - only_tag_enum_; - is_suberror_; - } - in - let ty_comp, ty_desc = - match decl.components with - | Ptd_variant cs -> - (match - check_duplicate cs (fun c1 c2 -> - c1.constr_name.name = c2.constr_name.name) - with - | Some { constr_name = { name; loc_ }; _ } -> - add_error diagnostics (Errors.constructor_duplicate ~name ~loc:loc_) - | None -> ()); - submit_variant ty_res ty_vis cs tvar_env ~placeholder_env ~types - toplevel ~is_exn:false ~type_name:name ~diagnostics ~base - | Ptd_error ty -> ( - let allow_private = - match ty_vis with - | Vis_priv | Vis_default -> true - | Vis_readonly | Vis_fully_pub -> false - in - match ty with - | No_payload -> - let constr : Typedecl_info.constructor = - { - constr_name = decl.tycon; - cs_res = ty_res; - cs_args = []; - cs_tag = - Extensible_tag - { - pkg = !Config.current_package; - type_name = name; - name; - total = 1; - index = 0; - }; - cs_vis = transl_component_vis ty_vis; - cs_ty_params_ = tvar_env; - cs_arity_ = Fn_arity.simple 0; - cs_constr_loc_ = tycon_loc_; - cs_loc_ = tycon_loc_; - } - in - Typing_info.add_constructor toplevel constr; - (Error_type constr, Td_error No_payload) - | Single_payload ty -> - let typ = - typing_type ty ~allow_private ~placeholder_env ~tvar_env ~types - ~diagnostics - in - let constr : Typedecl_info.constructor = - { - constr_name = decl.tycon; - cs_res = ty_res; - cs_args = [ Typedtree_util.stype_of_typ typ ]; - cs_tag = - Extensible_tag - { - pkg = !Config.current_package; - type_name = name; - name; - total = 1; - index = 0; - }; - cs_vis = transl_component_vis ty_vis; - cs_ty_params_ = tvar_env; - cs_arity_ = Fn_arity.simple 1; - cs_constr_loc_ = tycon_loc_; - cs_loc_ = tycon_loc_; - } - in - Typing_info.add_constructor toplevel constr; - (Error_type constr, Td_error (Single_payload typ)) - | Enum_payload cs -> - (match - check_duplicate cs (fun c1 c2 -> - c1.constr_name.name = c2.constr_name.name) - with - | Some { constr_name = { name; loc_ }; _ } -> - add_error diagnostics - (Errors.constructor_duplicate ~name ~loc:loc_) - | None -> ()); - submit_variant ty_res ty_vis cs tvar_env ~placeholder_env ~types - toplevel ~is_exn:true ~type_name:name ~diagnostics ~base) - | Ptd_newtype ty -> - let allow_private = - match ty_vis with - | Vis_priv | Vis_default -> true - | Vis_readonly | Vis_fully_pub -> false - in - let typ = - typing_type ty ~allow_private ~placeholder_env ~tvar_env ~types - ~diagnostics - in - let sty = Typedtree_util.stype_of_typ typ in - let name = decl.tycon in - let constr : Typedecl_info.constructor = - { - constr_name = name; - cs_res = ty_res; - cs_args = [ sty ]; - cs_tag = - Constr_tag_regular - { total = 1; index = 0; name_ = name; is_constant_ = false }; - cs_vis = transl_component_vis ty_vis; - cs_ty_params_ = tvar_env; - cs_arity_ = Fn_arity.simple 1; - cs_constr_loc_ = tycon_loc_; - cs_loc_ = tycon_loc_; - } - in - Typing_info.add_constructor toplevel constr; - let recursive = Placeholder_env.newtype_in_cycle placeholder_env name in - ( New_type { newtype_constr = constr; underlying_typ = sty; recursive }, - Td_newtype typ ) - | Ptd_record fs -> - (match - check_duplicate fs (fun f1 f2 -> - f1.field_name.label = f2.field_name.label) - with - | Some { field_name = { label = name; loc_ }; _ } -> - add_error diagnostics (Errors.field_duplicate ~name ~loc:loc_) - | None -> ()); - submit_field ty_res ty_vis fs tvar_env ~placeholder_env ~types toplevel - ~diagnostics ~base - | Ptd_abstract -> (Extern_type, Td_abstract) - | Ptd_alias _ -> assert false - in - let ty_constr = - Type_path.toplevel_type ~pkg:!Basic_config.current_package name - in - let typedecl_info : Typedecl_info.t = - { - ty_constr; - ty_arity = List.length decl.params; - ty_desc = ty_comp; - ty_vis; - ty_params_ = tvar_env; - ty_loc_ = tycon_loc_; - ty_doc_ = decl.doc_; - ty_is_only_tag_enum_ = only_tag_enum_; - ty_is_suberror_ = is_suberror_; - } - in - Global_env.All_types.add_type types name typedecl_info; - { - td_binder = { name = ty_constr; kind = Type; loc_ = decl.tycon_loc_ }; - td_params = tvar_env; - td_desc = ty_desc; - td_vis = ty_vis; - td_loc_ = decl.loc_; - td_doc_ = decl.doc_; - td_deriving_ = - Lst.map decl.deriving_ - (fun { type_name_ = { name; loc_ }; _ } : Syntax.constrid_loc -> - { lid = name; loc_ }); - } + (toplevel : toplevel_env) ~ext_method_env ~trait_impls + ~(value_worklist : Local_typing_worklist.value Vec.t) + ~(diagnostics : Local_diagnostics.t) = + (let name = decl.tycon in + let tvar_env = Typeutil.typing_type_decl_binders decl.params in + let base = decl.loc_ in + let ty_vis = transl_type_vis ~diagnostics decl.type_vis in + let tycon_loc_ = Rloc.to_loc ~base decl.tycon_loc_ in + let type_constructor = + Type_path.toplevel_type ~pkg:!Basic_config.current_package decl.tycon + in + let ty_args = Tvar_env.get_types tvar_env in + let only_tag_enum_ = + match decl.components with + | Ptd_variant cs -> + Lst.for_all cs (fun { constr_args; _ } -> constr_args = None) + | _ -> false + in + let is_suberror_ = + match decl.components with Ptd_error _ -> true | _ -> false + in + let ty_res : Stype.t = + T_constr + { + type_constructor; + tys = ty_args; + generic_ = ty_args <> []; + is_suberror_; + } + in + let ty_comp, ty_desc = + match decl.components with + | Ptd_variant cs -> + (match + check_duplicate cs (fun c1 -> + fun c2 -> c1.constr_name.name = c2.constr_name.name) + with + | Some { constr_name = { name; loc_ }; _ } -> + add_error diagnostics + (Errors.constructor_duplicate ~name ~loc:loc_) + | None -> ()); + submit_variant ty_res ty_vis cs tvar_env ~placeholder_env ~types + toplevel ~is_exn:false ~is_only_tag_enum:only_tag_enum_ + ~type_name:name ~diagnostics ~base + | Ptd_error ty -> ( + let allow_private = + match ty_vis with + | Vis_priv | Vis_default -> true + | Vis_readonly | Vis_fully_pub -> false + in + match ty with + | No_payload -> + let constr : Typedecl_info.constructor = + { + constr_name = decl.tycon; + cs_res = ty_res; + cs_args = []; + cs_tag = + Extensible_tag + { + pkg = !Config.current_package; + type_name = name; + name; + total = Constr_info.Index_set.singleton 0 0; + index = 0; + }; + cs_vis = transl_component_vis ty_vis; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple 0; + cs_constr_loc_ = tycon_loc_; + cs_loc_ = tycon_loc_; + } + in + Typing_info.add_constructor toplevel constr; + (Error_type constr, Td_error No_payload) + | Single_payload ty -> + let typ = + typing_type ty ~allow_private ~placeholder_env ~tvar_env ~types + ~diagnostics + in + let constr : Typedecl_info.constructor = + { + constr_name = decl.tycon; + cs_res = ty_res; + cs_args = [ Typedtree_util.stype_of_typ typ ]; + cs_tag = + Extensible_tag + { + pkg = !Config.current_package; + type_name = name; + name; + total = Constr_info.Index_set.singleton 0 0; + index = 0; + }; + cs_vis = transl_component_vis ty_vis; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple 1; + cs_constr_loc_ = tycon_loc_; + cs_loc_ = tycon_loc_; + } + in + Typing_info.add_constructor toplevel constr; + (Error_type constr, Td_error (Single_payload typ)) + | Enum_payload cs -> + (match + check_duplicate cs (fun c1 -> + fun c2 -> c1.constr_name.name = c2.constr_name.name) + with + | Some { constr_name = { name; loc_ }; _ } -> + add_error diagnostics + (Errors.constructor_duplicate ~name ~loc:loc_) + | None -> ()); + submit_variant ty_res ty_vis cs tvar_env ~placeholder_env ~types + toplevel ~is_exn:true ~is_only_tag_enum:false ~type_name:name + ~diagnostics ~base) + | Ptd_newtype ty -> + let allow_private = + match ty_vis with + | Vis_priv | Vis_default -> true + | Vis_readonly | Vis_fully_pub -> false + in + let typ = + typing_type ty ~allow_private ~placeholder_env ~tvar_env ~types + ~diagnostics + in + let sty = Typedtree_util.stype_of_typ typ in + let name = decl.tycon in + let constr : Typedecl_info.constructor = + { + constr_name = name; + cs_res = ty_res; + cs_args = [ sty ]; + cs_tag = + Constr_tag_regular + { + total = Constr_info.Index_set.singleton 0 0; + index = 0; + name_ = name; + repr_ = Non_constant; + }; + cs_vis = transl_component_vis ty_vis; + cs_ty_params_ = tvar_env; + cs_arity_ = Fn_arity.simple 1; + cs_constr_loc_ = tycon_loc_; + cs_loc_ = tycon_loc_; + } + in + Typing_info.add_constructor toplevel constr; + let recursive = + Placeholder_env.newtype_in_cycle placeholder_env name + in + ( New_type { newtype_constr = constr; underlying_typ = sty; recursive }, + Td_newtype typ ) + | Ptd_record fs -> + (match + check_duplicate fs (fun f1 -> + fun f2 -> f1.field_name.label = f2.field_name.label) + with + | Some { field_name = { label = name; loc_ }; _ } -> + add_error diagnostics (Errors.field_duplicate ~name ~loc:loc_) + | None -> ()); + submit_field ty_res ty_vis fs tvar_env ~placeholder_env ~types toplevel + ~diagnostics ~base + | Ptd_abstract -> + Local_diagnostics.add_warning diagnostics + { + kind = + Deprecated_syntax + { + old_usage = + ("`type " ^ decl.tycon ^ "`" + : Stdlib.String.t) + [@merlin.hide]; + purpose = "declare an external type for FFI use"; + new_usage = + Some + (("`extern type " ^ decl.tycon ^ "`" + : Stdlib.String.t) + [@merlin.hide]); + }; + loc = Rloc.of_loc ~base:(Loc.get_start base) base; + }; + (Extern_type, Td_abstract) + | Ptd_extern -> (Extern_type, Td_abstract) + | Ptd_alias _ -> assert false + in + let ty_constr = + Type_path.toplevel_type ~pkg:!Basic_config.current_package name + in + let typedecl_info : Typedecl_info.t = + { + ty_constr; + ty_arity = List.length decl.params; + ty_desc = ty_comp; + ty_vis; + ty_params_ = tvar_env; + ty_loc_ = tycon_loc_; + ty_doc_ = decl.doc_; + ty_attrs = + Checked_attributes.check ~local_diagnostics:diagnostics + ~context:`TopTypeDecl decl.attrs; + ty_is_only_tag_enum_ = only_tag_enum_; + ty_is_suberror_ = is_suberror_; + } + in + Global_env.All_types.add_type types name typedecl_info; + let td_deriving_ = + Lst.map decl.deriving_ (fun directive -> + let trait = directive.type_name_ in + let trait = + { trait with name = Typeutil.resolve_derive_alias trait.name } + in + let trait_loc = Rloc.to_loc ~base:decl.loc_ trait.loc_ in + let trait_decl, tast_trait_name = + typing_trait_name trait ~types + ~allow_private:(Typedecl_info.vis_is_pub ty_vis) + ~diagnostics + in + (match trait_decl with + | Some trait_decl -> + Derive.generate_signatures ~types ~ext_method_env ~trait_impls + ~diagnostics ~loc:trait_loc typedecl_info trait trait_decl; + Vec.push value_worklist + (Wl_derive + { + directive = { directive with type_name_ = trait }; + ty_decl = typedecl_info; + syn_decl = decl; + trait_path = trait_decl.name; + loc_ = trait_loc; + }) + | None -> ()); + tast_trait_name) + in + { + td_binder = { name = ty_constr; kind = Type; loc_ = decl.tycon_loc_ }; + td_params = tvar_env; + td_desc = ty_desc; + td_vis = ty_vis; + td_loc_ = decl.loc_; + td_doc_ = decl.doc_; + td_deriving_; + } + : Typedtree.type_decl) -let typing_types_and_traits (impls : Syntax.impl list) - (types : Global_env.All_types.t) (toplevel_env : toplevel_env) - ~(diagnostics : Diagnostics.t) = - let placeholder_env = - collect_types_and_traits ~foreign_types:types impls ~diagnostics - in - let tast_of_alias = Hash_string.create 17 in - let rec typing_alias ~visiting name (decl : Syntax.type_decl) = - let base = decl.loc_ in - let local_diagnostics = Local_diagnostics.make ~base in - match decl.components with - | Ptd_alias typ -> - (if Hash_string.mem tast_of_alias name then () - else if Lst.mem_string visiting name then +let typing_alias ~(placeholder_env : Placeholder_env.t) + ~(types : Global_env.All_types.t) ~(diagnostics : Diagnostics.t) = + (let trait_tast_nodes = Hash_string.create 17 in + let rec go_trait ~visiting name (decl : Syntax.impl) = + match[@warning "-fragile-match"] decl with + | Ptop_trait_alias { binder; target; vis; doc_; loc_; _ } -> + let base = loc_ in + let local_diagnostics = Local_diagnostics.make ~base in + if Hash_string.mem trait_tast_nodes name then () + else if Lst.mem_string visiting name then ( add_error local_diagnostics (Errors.cycle_in_type_alias ~cycle:(List.rev (name :: visiting)) - ~loc:decl.tycon_loc_) + ~kind:`Trait ~loc:binder.loc_); + Local_diagnostics.add_to_global local_diagnostics diagnostics) else - let tvar_env = Typeutil.typing_type_decl_binders decl.params in let is_pub = - match decl.type_vis with - | Vis_pub _ -> true - | Vis_default -> false - | Vis_priv { loc_ = vis_loc } -> - add_error local_diagnostics - (Errors.invalid_visibility ~vis:"priv" ~entity:"type alias" - ~loc:vis_loc); - false + transl_value_visibility ~local_diagnostics ~entity:"trait alias" + vis in - let result : Typedecl_info.alias = + let path_of_alias = + Type_path.toplevel_type ~pkg:!Basic_config.current_package name + in + let result : Type_alias.t = { name; - arity = List.length decl.params; - ty_params = tvar_env; - alias = T_blackhole; + arity = 0; + ty_params = Tvar_env.empty; + target = Trait_alias { trait = path_of_alias }; is_pub; - doc_ = decl.doc_; - loc_ = decl.loc_; + doc_; + loc_; } in Global_env.All_types.add_type_alias types name result; - (match - Placeholder_env.find_type_alias_deps placeholder_env decl.tycon - with - | None -> () - | Some deps -> - Lst.iter deps (fun dep -> - match Placeholder_env.find_type_opt placeholder_env dep with - | None -> () - | Some dep_decl -> - typing_alias ~visiting:(name :: visiting) dep dep_decl)); - let typ = - typing_type ~allow_private:(not is_pub) ~placeholder_env ~tvar_env - ~types ~diagnostics:local_diagnostics typ + (match target.name with + | Lident target -> ( + match + Placeholder_env.find_trait_alias placeholder_env target + with + | Some target_decl -> + go_trait ~visiting:(name :: visiting) target target_decl + | None -> ()) + | Ldot _ -> ()); + let target : Typedtree.type_name = + match + Placeholder_env.typing_trait_name ~types placeholder_env target + with + | Error err -> + Local_diagnostics.add_error local_diagnostics err; + Tname_path + { + name = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + ""; + kind = Trait; + loc_ = target.loc_; + } + | Ok + ( (Local_trait (path, _) | Foreign_trait { name = path; _ }), + type_name ) -> + Global_env.All_types.add_type_alias types name + { result with target = Trait_alias { trait = path } }; + type_name in - let stype = Typedtree_util.stype_of_typ typ in - (match stype with - | T_constr _ | T_trait _ | T_builtin _ | Tarrow _ -> () - | T_blackhole -> () - | Tvar _ -> assert false - | Tparam _ -> - add_error local_diagnostics - (Errors.invalid_type_alias_target (Typedtree.loc_of_typ typ))); - (match decl.deriving_ with - | [] -> () - | trait1 :: rest -> - let loc = - Lst.fold_left rest trait1.loc_ (fun l r -> Rloc.merge l r.loc_) - in - add_error local_diagnostics (Errors.type_alias_cannot_derive loc)); - Global_env.All_types.add_type_alias types name - { result with alias = stype }; - let tast_node : Typedtree.type_decl = + let tast_node : Typedtree.trait_alias_decl = { - td_binder = - { - name = - Type_path.toplevel_type - ~pkg:!Basic_config.current_package - name; - kind = Type; - loc_ = decl.tycon_loc_; - }; - td_params = tvar_env; - td_desc = Td_alias typ; - td_vis = (if is_pub then Vis_fully_pub else Vis_priv); - td_loc_ = decl.loc_; - td_doc_ = decl.doc_; - td_deriving_ = []; + trait_alias_name = + { name = path_of_alias; kind = Trait; loc_ = binder.loc_ }; + trait_alias_target = target; + trait_alias_is_pub = is_pub; + trait_alias_loc_ = loc_; + trait_alias_doc_ = doc_; } in - Hash_string.add tast_of_alias name tast_node); - Local_diagnostics.add_to_global local_diagnostics diagnostics + Hash_string.add trait_tast_nodes name tast_node + | _ -> assert false + in + Placeholder_env.iter_trait_alias placeholder_env (go_trait ~visiting:[]); + let type_tast_nodes = Hash_string.create 17 in + let rec go_type ~visiting name (decl : Syntax.type_decl) = + let base = decl.loc_ in + let local_diagnostics = Local_diagnostics.make ~base in + match decl.components with + | Ptd_alias _ when Hash_string.mem type_tast_nodes name -> () + | Ptd_alias _ when Lst.mem_string visiting name -> + add_error local_diagnostics + (Errors.cycle_in_type_alias + ~cycle:(List.rev (name :: visiting)) + ~kind:`Type ~loc:decl.tycon_loc_); + Local_diagnostics.add_to_global local_diagnostics diagnostics + | Ptd_alias typ -> + let tvar_env = Typeutil.typing_type_decl_binders decl.params in + let is_pub = + match decl.type_vis with + | Vis_pub _ -> true + | Vis_default -> false + | Vis_priv { loc_ = vis_loc } -> + add_error local_diagnostics + (Errors.invalid_visibility ~vis:"priv" ~entity:"type alias" + ~loc:vis_loc); + false + in + let result : Type_alias.t = + { + name; + arity = List.length decl.params; + ty_params = tvar_env; + target = Type_alias T_blackhole; + is_pub; + doc_ = decl.doc_; + loc_ = decl.loc_; + } + in + Global_env.All_types.add_type_alias types name result; + (match + Placeholder_env.find_type_alias_deps placeholder_env decl.tycon + with + | None -> () + | Some deps -> + Lst.iter deps ~f:(fun dep -> + match Placeholder_env.find_type_opt placeholder_env dep with + | None -> () + | Some dep_decl -> + go_type ~visiting:(name :: visiting) dep dep_decl)); + let typ = + typing_type ~allow_private:(not is_pub) ~placeholder_env ~tvar_env + ~types ~diagnostics:local_diagnostics typ + in + let stype = Stype.type_repr (Typedtree_util.stype_of_typ typ) in + (match stype with + | Tparam _ -> + add_error local_diagnostics + (Errors.invalid_type_alias_target (Typedtree.loc_of_typ typ)) + | _ -> ()); + (match decl.deriving_ with + | [] -> () + | trait1 :: rest -> + let loc = + Lst.fold_left rest trait1.loc_ (fun l -> + fun r -> Rloc.merge l r.loc_) + in + add_error local_diagnostics (Errors.type_alias_cannot_derive loc)); + Global_env.All_types.add_type_alias types name + { result with target = Type_alias stype }; + let tast_node : Typedtree.type_decl = + { + td_binder = + { + name = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + name; + kind = Type; + loc_ = decl.tycon_loc_; + }; + td_params = tvar_env; + td_desc = Td_alias typ; + td_vis = (if is_pub then Vis_fully_pub else Vis_priv); + td_loc_ = decl.loc_; + td_doc_ = decl.doc_; + td_deriving_ = []; + } + in + Hash_string.add type_tast_nodes name tast_node; + Local_diagnostics.add_to_global local_diagnostics diagnostics + | _ -> () + in + Placeholder_env.iter_types placeholder_env (go_type ~visiting:[]); + let trait_alias_decls = Vec.empty () in + Placeholder_env.iter_trait_alias placeholder_env (fun name -> + fun _ -> + match Hash_string.find_opt trait_tast_nodes name with + | Some decl -> Vec.push trait_alias_decls decl + | _ -> ()); + (type_tast_nodes, Vec.to_list trait_alias_decls) + : Typedtree.type_decl Hash_string.t * Typedtree.trait_alias_decl list) + +let rec check_object_safety_in_typ ~types (typ : Typedtree.typ) ~diagnostics = + let go typ = check_object_safety_in_typ ~types typ ~diagnostics [@@inline] in + let check_stype sty ~loc = + match Stype.type_repr sty with + | T_trait trait when Type_path.get_pkg trait = !Basic_config.current_package + -> ( + match Global_env.All_types.find_trait_by_path types trait with + | Some decl -> ( + match + Trait_decl.check_object_safety + ~name:(Type_path_util.name trait) + ~loc decl.object_safety_ + with + | Some err -> Local_diagnostics.add_error diagnostics err + | None -> ()) + | None -> ()) | _ -> () in - Placeholder_env.iter_types placeholder_env (typing_alias ~visiting:[]); - let type_decls = - Placeholder_env.types_to_list_map placeholder_env (fun name decl -> - let local_diagnostics = Local_diagnostics.make ~base:decl.loc_ in - let res = - match decl.components with - | Ptd_alias _ -> Hash_string.find_exn tast_of_alias name - | _ -> - typing_typedef decl ~placeholder_env types toplevel_env - ~diagnostics:local_diagnostics - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res) + match typ with + | Tany _ -> () + | Tarrow { params; return; err_ty; ty = _ } -> ( + Lst.iter params ~f:go; + go return; + match err_ty with + | Error_typ { ty } -> go ty + | Default_error_typ _ | No_error_typ -> ()) + | T_tuple { params; ty = _ } -> Lst.iter params ~f:go + | Tname { constr; params; ty } -> + check_stype ty ~loc:constr.loc_; + Lst.iter params ~f:go + | Tobject { constr; ty } -> check_stype ty ~loc:constr.loc_ + +type partial_trait_info = { + method_decls : Trait_decl.method_decl list; + method_tast_nodes : Typedtree.method_decl list; + self_object_safety : Trait_decl.object_safety_status; +} + +let typing_types_and_traits (impls : Syntax.impl list) + (types : Global_env.All_types.t) (toplevel_env : toplevel_env) + ~ext_method_env ~trait_impls ~value_worklist ~(diagnostics : Diagnostics.t) + = + let placeholder_env = + collect_types_and_traits ~foreign_types:types impls ~diagnostics in - let method_decls_of_trait = Hash_string.create 17 in - Placeholder_env.iter_traits placeholder_env (fun name trait_info -> - let base = trait_info.decl.trait_loc_ in - let local_diagnostics = Local_diagnostics.make ~base in - let method_decls = - let is_pub = - match trait_info.decl.trait_vis with - | Vis_pub _ -> true - | Vis_priv _ | Vis_default -> false - in - Lst.map_split trait_info.decl.trait_methods - (typing_trait_method_decl ~is_pub ~placeholder_env ~types ~base - ~diagnostics:local_diagnostics) - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - Hash_string.add method_decls_of_trait name method_decls); + let tast_of_type_alias, tast_of_trait_alias = + typing_alias ~placeholder_env ~types ~diagnostics + in + let partial_trait_info = Hash_string.create 17 in + Placeholder_env.iter_traits placeholder_env (fun name -> + fun decl -> + let base = decl.trait_loc_ in + let local_diagnostics = Local_diagnostics.make ~base in + let method_decls, method_tast_nodes = + let is_pub = + match decl.trait_vis with + | Vis_pub _ -> true + | Vis_priv _ | Vis_default -> false + in + Lst.map_split decl.trait_methods + (typing_trait_method_decl ~is_pub ~placeholder_env ~types ~base + ~diagnostics:local_diagnostics) + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + let self_object_safety = Trait_decl.get_methods_object_safety decl in + Hash_string.add partial_trait_info name + { method_decls; method_tast_nodes; self_object_safety }); let trait_decls = - Placeholder_env.traits_to_list_map placeholder_env - (fun name trait_info : Typedtree.trait_decl -> - let local_diagnostics = - Local_diagnostics.make ~base:trait_info.decl.trait_loc_ - in - let trait_vis = - transl_trait_vis ~diagnostics:local_diagnostics - trait_info.decl.trait_vis - in - let supers = - Lst.fold_right trait_info.decl.trait_supers [] - (fun { tvc_trait; loc_ } acc -> - let builtin_or_foreign () = - match - typing_trait_name ~types ~diagnostics:local_diagnostics - ~allow_private:(Typedecl_info.vis_is_pub trait_vis) - { name = tvc_trait; loc_ } - with - | Some decl, _ -> decl.name :: acc - | None, _ -> acc - [@@inline] - in - match tvc_trait with - | Lident name -> ( - match Placeholder_env.find_trait_opt placeholder_env name with - | Some { decl = super_decl; _ } -> - (match - (trait_info.decl.trait_vis, super_decl.trait_vis) + Placeholder_env.traits_to_list_map placeholder_env (fun name -> + fun decl -> + (let local_diagnostics = + Local_diagnostics.make ~base:decl.trait_loc_ + in + let trait_vis = + transl_trait_vis ~diagnostics:local_diagnostics decl.trait_vis + in + let path = + Type_path.toplevel_type ~pkg:!Basic_config.current_package name + in + let trait_supers, closure = + Typeutil.typing_super_traits ~types ~placeholder_env + ~allow_private:(not (Typedecl_info.vis_is_pub trait_vis)) + ~self:path decl.trait_supers ~diagnostics:local_diagnostics + in + let supers = + Lst.map trait_supers (fun tast_trait_name -> + match tast_trait_name with + | Tname_path { name; _ } | Tname_alias { name; _ } -> name + | Tname_tvar _ -> assert false) + in + let { method_decls; method_tast_nodes; self_object_safety } = + Hash_string.find_exn partial_trait_info name + in + let closure_methods = + Lst.concat_map closure (fun trait -> + match trait with + | Toplevel { pkg; id } when pkg = !Basic_config.current_package + -> + Lst.map + (Hash_string.find_exn partial_trait_info id).method_decls + (fun meth_decl -> (trait, meth_decl)) + | _ -> ( + match + Global_env.All_types.find_trait_by_path types trait + with + | None -> [] + | Some trait_decl -> + Lst.map trait_decl.methods (fun meth_decl -> + (trait, meth_decl)))) + in + let object_safety_ = + self_object_safety + @ Lst.fold_right supers [] (fun super -> + fun acc -> + match super with + | Toplevel { pkg; id } + when pkg = !Basic_config.current_package -> ( + match + (Hash_string.find_exn partial_trait_info id) + .self_object_safety with - | Vis_pub _, Vis_priv _ -> - add_error local_diagnostics - (Errors.cannot_depend_private ~entity:"trait" - ~loc:loc_) - | _ -> ()); - Type_path.toplevel_type - ~pkg:!Basic_config.current_package - name - :: acc - | None -> builtin_or_foreign ()) - | Ldot _ -> builtin_or_foreign ()) - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - let methods, tast_methods = - Hash_string.find_exn method_decls_of_trait name - in - let path = - Type_path.toplevel_type ~pkg:!Basic_config.current_package name - in - let closure_methods = - Lst.concat_map trait_info.closure (fun trait -> - match trait with - | Toplevel { pkg; id } when pkg = !Basic_config.current_package -> - fst (Hash_string.find_exn method_decls_of_trait id) - |> List.map (fun meth_decl -> (trait, meth_decl)) - | _ -> ( - match Global_env.All_types.find_trait_by_path types trait with - | None -> [] - | Some trait_decl -> - Lst.map trait_decl.methods (fun meth_decl -> - (trait, meth_decl)))) - in - let trait_decl : Trait_decl.t = - { - name = path; - supers; - closure = trait_info.closure; - closure_methods; - methods; - vis_ = trait_vis; - loc_ = trait_info.decl.trait_loc_; - doc_ = trait_info.decl.trait_doc_; - object_safety_ = trait_info.object_safety_status; - } - in - Global_env.All_types.add_trait types name trait_decl; - { - trait_name = + | [] -> acc + | _ :: _ -> Trait_decl.Bad_super_trait super :: acc) + | _ -> ( + match + Global_env.All_types.find_trait_by_path types super + with + | Some { object_safety_ = _ :: _; _ } -> + Trait_decl.Bad_super_trait super :: acc + | Some { object_safety_ = []; _ } | None -> acc)) + in + let attrs = + Checked_attributes.check ~local_diagnostics ~context:`Trait + decl.trait_attrs + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + let trait_decl : Trait_decl.t = { name = path; - kind = Trait; - loc_ = trait_info.decl.trait_name.loc_; - }; - trait_methods = tast_methods; - trait_vis; - trait_doc_ = trait_info.decl.trait_doc_; - trait_loc_ = trait_info.decl.trait_loc_; - }) + supers; + closure; + closure_methods; + methods = method_decls; + vis_ = trait_vis; + loc_ = decl.trait_loc_; + doc_ = decl.trait_doc_; + attrs; + object_safety_; + } + in + Global_env.All_types.add_trait types name trait_decl; + { + trait_name = + { name = path; kind = Trait; loc_ = decl.trait_name.loc_ }; + trait_supers; + trait_methods = method_tast_nodes; + trait_vis; + trait_doc_ = decl.trait_doc_; + trait_attrs = attrs; + trait_loc_ = decl.trait_loc_; + } + : Typedtree.trait_decl)) in - (type_decls, trait_decls) - -type ret_annotation = - | Annotated of (Typedtree.typ * Typedtree.error_typ) - | Has_error_type of Rloc.t - | No_error_type_annotated - -type typed_fn_annotation = { - params_ty : (Stype.t * Typedtree.typ option) list; - ret_ty : Stype.t; - err_ty : Stype.t option; - ret_annotation : ret_annotation; -} - -type value_worklist_item = - | Wl_top_expr of { - expr : Syntax.expr; - is_main : bool; - id : Qual_ident.t; - loc_ : Loc.t; - } - | Wl_top_letdef of { - binder : Syntax.binder; - expr : top_let_body; - is_pub : bool; - loc_ : Loc.t; - doc_ : docstring; - konstraint : Typedtree.typ option; - id : Qual_ident.t; - typ : Stype.t; - } - | Wl_top_funcdef of { - fun_binder : Syntax.binder; - decl_params : Syntax.parameter list; - params_loc : Rloc.t; - is_pub : bool; - doc : docstring; - decl_body : Syntax.decl_body; - loc_ : Loc.t; - id : Qual_ident.t; - kind : Typedtree.fun_decl_kind; - arity : Fn_arity.t; - tvar_env : Tvar_env.t; - typed_fn_annotation : typed_fn_annotation; - } - | Wl_derive of { - ty_decl : Typedecl_info.t; - syn_decl : Syntax.type_decl; - directive : Syntax.deriving_directive; - trait_path : Type_path.t; - loc_ : Loc.t; - } - -and top_let_body = - | Wl_toplet_const of Typedtree.expr - | Wl_toplet_normal of Syntax.expr + let type_decls = + Placeholder_env.types_to_list_map placeholder_env (fun name -> + fun decl -> + let local_diagnostics = Local_diagnostics.make ~base:decl.loc_ in + let res = + match decl.components with + | Ptd_alias _ -> Hash_string.find_exn tast_of_type_alias name + | _ -> + typing_typedef decl ~placeholder_env types toplevel_env + ~ext_method_env ~trait_impls ~value_worklist + ~diagnostics:local_diagnostics + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + res) + in + Lst.iter type_decls ~f:(fun decl -> + let local_diagnostics = Local_diagnostics.make ~base:decl.td_loc_ in + (match decl.td_desc with + | Td_error (Single_payload typ) | Td_newtype typ | Td_alias typ -> + check_object_safety_in_typ ~types typ ~diagnostics:local_diagnostics + | Td_variant constrs | Td_error (Enum_payload constrs) -> + Lst.iter constrs ~f:(fun constr -> + Lst.iter constr.constr_args ~f:(fun constr_arg -> + check_object_safety_in_typ ~types constr_arg.carg_typ + ~diagnostics:local_diagnostics)) + | Td_record fields -> + Lst.iter fields ~f:(fun field -> + check_object_safety_in_typ ~types field.field_typ + ~diagnostics:local_diagnostics) + | Td_abstract | Td_error No_payload -> ()); + Local_diagnostics.add_to_global local_diagnostics diagnostics); + Lst.iter trait_decls ~f:(fun decl -> + let local_diagnostics = Local_diagnostics.make ~base:decl.trait_loc_ in + Lst.iter decl.trait_methods ~f:(fun meth -> + Lst.iter meth.method_params ~f:(fun (_, typ) -> + check_object_safety_in_typ ~types typ + ~diagnostics:local_diagnostics); + (match meth.method_ret with + | None -> () + | Some typ -> + check_object_safety_in_typ ~types typ + ~diagnostics:local_diagnostics); + match meth.method_err with + | None -> () + | Some typ -> + check_object_safety_in_typ ~types typ + ~diagnostics:local_diagnostics); + Local_diagnostics.add_to_global local_diagnostics diagnostics); + (type_decls, trait_decls, tast_of_trait_alias) let add_method (type_name : Type_path.t) (fun_type : Stype.t) (meth : Syntax.binder) is_pub ~is_trait ~(doc : Docstring.t) - ~(types : Global_env.All_types.t) ~tvar_env ~method_env - ~(toplevel : toplevel_env) ~arity ~param_names ~prim - ~(diagnostics : Local_diagnostics.t) ~(meth_loc : Loc.t) : Qual_ident.t = - let method_name = meth.binder_name in - let check_duplicate_method type_name = - (if is_trait then - match Global_env.All_types.find_trait_by_path types type_name with - | None -> () - | Some trait_decl -> ( - match - Lst.find_first trait_decl.methods (fun meth_decl -> - meth_decl.method_name = method_name) - with - | Some meth_decl -> - add_error diagnostics - (Errors.method_duplicate ~method_name ~type_name - ~first_loc:meth_decl.method_loc_ ~second_loc:meth.loc_) - | None -> ())); - let report_duplicate (method_info : Method_env.method_info) = - add_error diagnostics - (Errors.method_duplicate ~method_name ~type_name - ~first_loc:method_info.loc ~second_loc:meth.loc_) - [@@inline] - in - Method_env.find_regular_method method_env ~type_name ~method_name - |> Option.iter report_duplicate; - (match type_name with - | Toplevel { pkg; id = _ } when pkg <> !Config.current_package -> - Pkg.find_regular_method - (Global_env.All_types.get_pkg_tbl types) - ~pkg ~type_name ~method_name - |> Option.iter report_duplicate - | _ -> ()); - if Type_path.can_be_extended_from_builtin type_name then - Pkg.find_regular_method - (Global_env.All_types.get_pkg_tbl types) - ~pkg:Config.builtin_package ~type_name ~method_name - |> Option.iter report_duplicate - in - let check_duplicate_function () = - match Typing_info.find_value toplevel method_name with - | Some v -> - let first_loc, extra_message = get_duplicate_loc_info v in - add_error diagnostics - (Errors.method_func_duplicate ~name:method_name ~first_loc - ~second_loc:meth.loc_ ~extra_message) - | _ -> () - in - let check_self_type () = - match type_name with - | _ when not (Type_path_util.is_foreign type_name) -> true - | _ when !Basic_config.current_package = Basic_config.builtin_package -> - true - | _ -> - add_error diagnostics - (Errors.method_on_foreign_type ~method_name:meth.binder_name - ~type_name ~loc:meth.loc_); - false - in - check_operator_decl ~diagnostics ~loc:meth.loc_ method_name fun_type; - check_duplicate_function (); - check_duplicate_method type_name; - let id : Basic_qual_ident.t = - Qual_ident.meth ~self_typ:type_name ~name:method_name - in - (if check_self_type () then - let method_info : Method_env.method_info = - { - id; - prim; - typ = fun_type; - pub = is_pub; - loc = meth_loc; - doc_ = doc; - ty_params_ = tvar_env; - arity_ = arity; - param_names_ = param_names; - } + ~(attrs : Typedtree.attributes) ~(types : Global_env.All_types.t) ~tvar_env + ~method_env ~arity ~param_names ~prim ~(kind : Method_env.method_kind) + ~(diagnostics : Local_diagnostics.t) ~(meth_loc : Loc.t) = + (let method_name = meth.binder_name in + let check_duplicate_method type_name = + (if is_trait then + match Global_env.All_types.find_trait_by_path types type_name with + | None -> () + | Some trait_decl -> ( + match + Lst.find_first trait_decl.methods (fun meth_decl -> + meth_decl.method_name = method_name) + with + | Some meth_decl -> + add_error diagnostics + (Errors.method_duplicate ~method_name ~type_name + ~first_loc:meth_decl.method_loc_ ~second_loc:meth.loc_) + | None -> ())); + let report_duplicate (method_info : Method_env.method_info) = + add_error diagnostics + (Errors.method_duplicate ~method_name ~type_name + ~first_loc:method_info.loc ~second_loc:meth.loc_) + [@@inline] in - Method_env.add_method method_env ~type_name ~method_name ~method_info); - id + (match + Method_env.find_regular_method method_env ~type_name ~method_name + with + | Some x -> report_duplicate x + | _ -> ()); + (match type_name with + | Toplevel { pkg; id = _ } when pkg <> !Config.current_package -> ( + match + Pkg.find_regular_method + (Global_env.All_types.get_pkg_tbl types) + ~pkg ~type_name ~method_name + with + | Some x -> report_duplicate x + | _ -> ()) + | _ -> ()); + if Type_path.can_be_extended_from_builtin type_name then + match + Pkg.find_regular_method + (Global_env.All_types.get_pkg_tbl types) + ~pkg:Config.builtin_package ~type_name ~method_name + with + | Some x -> report_duplicate x + | _ -> () + in + let check_self_type () = + match type_name with + | _ when not (Type_path_util.is_foreign type_name) -> true + | _ when !Basic_config.current_package = Basic_config.builtin_package -> + true + | _ -> + add_error diagnostics + (Errors.method_on_foreign_type ~method_name:meth.binder_name + ~type_name ~loc:meth.loc_); + false + in + check_operator_decl ~diagnostics ~loc:meth.loc_ method_name fun_type; + check_duplicate_method type_name; + let id : Basic_qual_ident.t = + Qual_ident.meth ~self_typ:type_name ~name:method_name + in + (if check_self_type () then + let method_info : Method_env.method_info = + { + id; + prim; + typ = fun_type; + pub = is_pub; + loc = meth_loc; + doc_ = doc; + attrs; + ty_params_ = tvar_env; + kind_ = kind; + arity_ = arity; + param_names_ = param_names; + } + in + Method_env.add_method method_env ~type_name ~method_name ~method_info); + id + : Qual_ident.t) let check_method_self_type ~(diagnostics : Local_diagnostics.t) ~(loc : Rloc.t) (self_type : Stype.t) = @@ -1060,175 +1308,215 @@ let check_method_self_type ~(diagnostics : Local_diagnostics.t) ~(loc : Rloc.t) let add_self_method (self_type : Stype.t) (fun_type : Stype.t) (meth : Syntax.binder) is_pub ~(doc : docstring) - ~(types : Global_env.All_types.t) ~tvar_env ~method_env - ~(toplevel : toplevel_env) ~arity ~param_names ~prim - ~(diagnostics : Local_diagnostics.t) ~meth_loc : Qual_ident.t = - match check_method_self_type ~diagnostics ~loc:meth.loc_ self_type with - | Some (is_trait, type_name) -> - add_method type_name fun_type meth is_pub ~is_trait ~doc ~types ~tvar_env - ~method_env ~toplevel ~arity ~param_names ~prim ~diagnostics ~meth_loc - | None -> Qual_ident.toplevel_value ~name:meth.binder_name + ~(attrs : Typedtree.attributes) ~(types : Global_env.All_types.t) ~tvar_env + ~toplevel ~method_env ~arity ~param_names ~prim + ~(diagnostics : Diagnostics.t) ~(local_diagnostics : Local_diagnostics.t) + ~meth_loc = + (match + check_method_self_type ~diagnostics:local_diagnostics ~loc:meth.loc_ + self_type + with + | Some (is_trait, type_name) -> + let method_name = meth.binder_name in + let qid = + add_method type_name fun_type meth is_pub ~is_trait ~doc ~attrs ~types + ~tvar_env ~method_env ~arity ~param_names ~prim ~kind:Regular_method + ~diagnostics:local_diagnostics ~meth_loc + in + (match Typing_info.find_value toplevel method_name with + | Some v -> + let first_loc, extra_message = get_duplicate_loc_info v in + add_global_error diagnostics + (Errors.value_redeclare ~name:method_name ~first_loc + ~second_loc:meth_loc ~extra_message) + | None -> + Typing_info.add_value toplevel + { + id = qid; + typ = fun_type; + pub = is_pub; + kind = + (match prim with None -> Normal | Some prim -> Prim prim); + loc_ = meth_loc; + doc_ = doc; + attrs; + ty_params_ = tvar_env; + arity_ = Some arity; + param_names_ = param_names; + direct_use_loc_ = Not_direct_use; + }); + qid + | None -> Qual_ident.toplevel_value ~name:meth.binder_name + : Qual_ident.t) let add_ext_method (trait_decl : Trait_decl.t) ~(self_ty : Stype.t) (fun_type : Stype.t) (meth : Syntax.binder) is_pub ~(doc : Docstring.t) - ~types ~tvar_env ~ext_method_env ~trait_impls ~arity ~param_names ~prim - ~(diagnostics : Local_diagnostics.t) ~(global_diagnostics : Diagnostics.t) - ~header_loc ~meth_loc : Qual_ident.t = - let trait = trait_decl.name in - let method_name = meth.binder_name in - match Trait_decl.find_method trait_decl method_name ~loc:meth.loc_ with - | Error err -> - add_error diagnostics err; - Qual_ident.toplevel_value ~name:method_name - | Ok meth_decl -> ( - let check_type () = - let exception Arity_mismatch in - let expected_ty = - Poly_type.instantiate_method_decl meth_decl ~self:self_ty - in - try - Ctype.unify_exn expected_ty fun_type; - if not (Fn_arity.equal arity meth_decl.method_arity) then - raise_notrace Arity_mismatch - with _ -> - add_error diagnostics - (Errors.ext_method_type_mismatch ~trait ~method_name - ~expected: - (Printer.toplevel_function_type_to_string - ~arity:meth_decl.method_arity expected_ty) - ~actual: - (Printer.toplevel_function_type_to_string ~arity fun_type) - ~loc:meth.loc_) - [@@inline] - in - check_type (); - match check_method_self_type ~diagnostics ~loc:meth.loc_ self_ty with - | None -> Qual_ident.toplevel_value ~name:method_name - | Some (is_trait, type_name) -> - let check_duplication () = - if is_trait && Type_path.equal type_name trait then - add_error diagnostics - (Errors.method_duplicate ~method_name ~type_name - ~first_loc:meth_decl.method_loc_ ~second_loc:meth.loc_); - let prev_def = - match - Ext_method_env.find_method ext_method_env ~trait - ~self_type:type_name ~method_name - with - | Some _ as prev_def -> prev_def - | None -> - Pkg.find_ext_method_opt - (Global_env.All_types.get_pkg_tbl types) - ~pkg:Config.builtin_package ~trait ~self_type:type_name - ~method_name - in - match prev_def with - | None -> () - | Some prev_def -> - let trait_name = - Type_path.short_name - ~cur_pkg_name:(Some !Basic_config.current_package) trait - in - add_error diagnostics - (Errors.method_duplicate - ~method_name: - (trait_name ^ "::" ^ method_name : Stdlib.String.t) - ~type_name ~first_loc:prev_def.loc ~second_loc:meth.loc_) - [@@inline] - in - check_duplication (); - let id : Basic_qual_ident.t = - Qual_ident.ext_meth ~trait ~self_typ:type_name ~name:method_name - in - let method_info : Ext_method_env.method_info = - { - id; - prim; - typ = fun_type; - pub = is_pub; - loc = meth_loc; - doc_ = doc; - ty_params_ = tvar_env; - arity_ = arity; - param_names_ = param_names; - } - in - if - Type_path_util.is_foreign trait - && Type_path_util.is_foreign type_name - then - add_error diagnostics - (Errors.ext_method_foreign_trait_foreign_type ~trait ~type_name - ~method_name ~loc:meth.loc_) - else ( - (match Trait_impl.find_impl trait_impls ~trait ~type_name with - | None -> - let impl : Trait_impl.impl = - { - trait; - self_ty; - ty_params = tvar_env; - is_pub; - loc_ = header_loc; - } - in - Trait_impl.add_impl trait_impls ~trait ~type_name impl - | Some impl -> - if not (Type.same_type impl.self_ty self_ty) then - add_global_error global_diagnostics - (Errors.inconsistent_impl - ~trait:(Type_path_util.name trait) - ~type_name:(Type_path_util.name type_name) - ~reason: - (`Self_type_mismatch - ( Printer.type_to_string impl.self_ty, - Printer.type_to_string self_ty )) - ~loc1:impl.loc_ ~loc2:header_loc) - else if not (Tvar_env.equal impl.ty_params tvar_env) then - add_global_error global_diagnostics - (Errors.inconsistent_impl - ~trait:(Type_path_util.name trait) - ~type_name:(Type_path_util.name type_name) - ~reason:`Type_parameter_bound ~loc1:impl.loc_ - ~loc2:header_loc) - else if is_pub && not impl.is_pub then - Trait_impl.update trait_impls ~trait ~type_name (fun impl -> - { impl with is_pub = true; loc_ = header_loc })); - Ext_method_env.add_method ext_method_env ~trait ~self_type:type_name - ~method_name method_info); - id) + ~(attrs : Checked_attributes.t) ~types ~tvar_env ~ext_method_env + ~trait_impls ~arity ~param_names ~prim ~(diagnostics : Local_diagnostics.t) + ~(global_diagnostics : Diagnostics.t) ~header_loc ~meth_loc = + (let trait = trait_decl.name in + let method_name = meth.binder_name in + match Trait_decl.find_method trait_decl method_name ~loc:meth.loc_ with + | Error err -> + add_error diagnostics err; + Qual_ident.toplevel_value ~name:method_name + | Ok meth_decl -> ( + let check_type () = + let exception Arity_mismatch in + let expected_ty = + Poly_type.instantiate_method_decl meth_decl ~self:self_ty + in + try + Ctype.unify_exn expected_ty fun_type; + if not (Fn_arity.equal arity meth_decl.method_arity) then + raise_notrace Arity_mismatch + with _ -> + add_error diagnostics + (Errors.ext_method_type_mismatch ~trait ~method_name + ~expected: + (Printer.toplevel_function_type_to_string + ~arity:meth_decl.method_arity expected_ty) + ~actual: + (Printer.toplevel_function_type_to_string ~arity fun_type) + ~loc:meth.loc_) + [@@inline] + in + check_type (); + match check_method_self_type ~diagnostics ~loc:meth.loc_ self_ty with + | None -> Qual_ident.toplevel_value ~name:method_name + | Some (is_trait, type_name) -> + let check_duplication () = + if is_trait && Type_path.equal type_name trait then + add_error diagnostics + (Errors.method_duplicate ~method_name ~type_name + ~first_loc:meth_decl.method_loc_ ~second_loc:meth.loc_); + let prev_def = + match + Ext_method_env.find_method ext_method_env ~trait + ~self_type:type_name ~method_name + with + | Some _ as prev_def -> prev_def + | None -> + Pkg.find_ext_method_opt + (Global_env.All_types.get_pkg_tbl types) + ~pkg:Config.builtin_package ~trait ~self_type:type_name + ~method_name + in + match prev_def with + | None -> () + | Some prev_def -> + let trait_name = + Type_path.short_name + ~cur_pkg_name:(Some !Basic_config.current_package) trait + in + add_error diagnostics + (Errors.method_duplicate + ~method_name: + ((trait_name ^ "::" ^ method_name + : Stdlib.String.t) + [@merlin.hide]) + ~type_name ~first_loc:prev_def.loc ~second_loc:meth.loc_) + [@@inline] + in + check_duplication (); + let id : Basic_qual_ident.t = + Qual_ident.ext_meth ~trait ~self_typ:type_name ~name:method_name + in + let method_info : Ext_method_env.method_info = + { + id; + prim; + typ = fun_type; + pub = is_pub; + loc = meth_loc; + doc_ = doc; + attrs; + ty_params_ = tvar_env; + kind_ = Method_explicit_self { self_ty }; + arity_ = arity; + param_names_ = param_names; + } + in + if + Type_path_util.is_foreign trait + && Type_path_util.is_foreign type_name + then + add_error diagnostics + (Errors.ext_method_foreign_trait_foreign_type ~trait ~type_name + ~method_name ~loc:meth.loc_) + else ( + (match Trait_impl.find_impl trait_impls ~trait ~type_name with + | None -> + let impl : Trait_impl.impl = + { + trait; + self_ty; + ty_params = tvar_env; + is_pub; + is_implicit_ = false; + doc_ = Docstring.empty; + loc_ = header_loc; + } + in + Trait_impl.add_impl trait_impls ~trait ~type_name impl + | Some impl -> + if not (Type.same_type impl.self_ty self_ty) then + add_global_error global_diagnostics + (Errors.inconsistent_impl + ~trait:(Type_path_util.name trait) + ~type_name:(Type_path_util.name type_name) + ~reason: + (`Self_type_mismatch + ( Printer.type_to_string impl.self_ty, + Printer.type_to_string self_ty )) + ~loc1:impl.loc_ ~loc2:header_loc) + else if not (Tvar_env.equal impl.ty_params tvar_env) then + add_global_error global_diagnostics + (Errors.inconsistent_impl + ~trait:(Type_path_util.name trait) + ~type_name:(Type_path_util.name type_name) + ~reason:`Type_parameter_bound ~loc1:impl.loc_ + ~loc2:header_loc) + else if is_pub && not impl.is_pub then + Trait_impl.update trait_impls ~trait ~type_name (fun impl -> + { impl with is_pub = true; loc_ = header_loc })); + Ext_method_env.add_method ext_method_env ~trait + ~self_type:type_name ~method_name method_info); + id) + : Qual_ident.t) -let try_infer_expr ~types expr : (Stype.t * bool) option = - let exception Cannot_infer in - let is_literal = ref true in - let rec go (expr : Syntax.expr) = - match expr with - | Pexpr_constant { c } -> Typeutil.type_of_constant c - | Pexpr_interp _ | Pexpr_multiline_string _ -> Stype.string - | Pexpr_array { exprs = [] } -> raise_notrace Cannot_infer - | Pexpr_array { exprs = expr0 :: exprs } -> - let ty0 = go expr0 in - Lst.iter exprs (fun expr -> - let ty = go expr in - ignore (Ctype.try_unify ty0 ty)); - Builtin.type_array ty0 - | Pexpr_tuple { exprs } -> Builtin.type_product (List.map go exprs) - | Pexpr_ident { id = { var_name = Ldot { pkg; id } } } -> ( - match Global_env.All_types.find_foreign_value types ~pkg ~name:id with - | None -> raise_notrace Cannot_infer - | Some (Local_imm _ | Local_mut _) -> assert false - | Some (Toplevel_value { ty_params_; _ }) - when not (Tvar_env.is_empty ty_params_) -> - raise_notrace Cannot_infer - | Some (Toplevel_value { typ; _ }) -> - is_literal := false; - typ) - | _ -> raise_notrace Cannot_infer - in - try - let ty = go expr in - Some (ty, !is_literal) - with Cannot_infer -> None +let try_infer_expr ~types expr = + (let exception Cannot_infer in + let is_literal = ref true in + let rec go (expr : Syntax.expr) = + match expr with + | Pexpr_constant { c } -> Typeutil.type_of_constant c + | Pexpr_interp _ | Pexpr_multiline_string _ -> Stype.string + | Pexpr_array { exprs = [] } -> raise_notrace Cannot_infer + | Pexpr_array { exprs = expr0 :: exprs } -> + let ty0 = go expr0 in + Lst.iter exprs ~f:(fun expr -> + let ty = go expr in + ignore (Ctype.try_unify ty0 ty)); + Builtin.type_array ty0 + | Pexpr_tuple { exprs } -> Builtin.type_product (Lst.map exprs go) + | Pexpr_ident { id = { var_name = Ldot { pkg; id } } } -> ( + match Global_env.All_types.find_foreign_value types ~pkg ~name:id with + | None -> raise_notrace Cannot_infer + | Some (Local_imm _ | Local_mut _) -> assert false + | Some (Toplevel_value { ty_params_; _ }) + when not (Tvar_env.is_empty ty_params_) -> + raise_notrace Cannot_infer + | Some (Toplevel_value { typ; _ }) -> + is_literal := false; + typ) + | _ -> raise_notrace Cannot_infer + in + try + let ty = go expr in + Some (ty, !is_literal) + with Cannot_infer -> None + : (Stype.t * bool) option) let prim_of_decl (decl : Syntax.decl_body) (loc : Loc.t) ~(doc : Docstring.t) ~(diagnostics : Diagnostics.t) = @@ -1243,12 +1531,13 @@ let prim_of_decl (decl : Syntax.decl_body) (loc : Loc.t) ~(doc : Docstring.t) else None | Decl_body _ -> ( match - Lst.fold_right (Docstring.pragmas doc) [] (fun pragma acc -> - match pragma with - | Pragma_alert _ -> acc - | Pragma_gen_js _ -> acc - | Pragma_intrinsic intrinsic -> intrinsic :: acc - | Pragma_coverage_skip -> acc) + Lst.fold_right (Docstring.pragmas doc) [] (fun pragma -> + fun acc -> + match pragma with + | Pragma_alert _ -> acc + | Pragma_gen_js _ -> acc + | Pragma_intrinsic intrinsic -> intrinsic :: acc + | Pragma_coverage_skip -> acc) with | [] -> None | intrinsic :: [] -> @@ -1265,224 +1554,396 @@ let prim_of_decl (decl : Syntax.decl_body) (loc : Loc.t) ~(doc : Docstring.t) let check_toplevel_decl ~(toplevel : toplevel_env) (impls : Syntax.impls) (types : Global_env.All_types.t) ~(method_env : Method_env.t) ~(ext_method_env : Ext_method_env.t) ~(trait_impls : Trait_impl.t) - ~(worklist : value_worklist_item Vec.t) ~diagnostics - ~(build_context : Typeutil.build_context) : unit = - let add_symbol (toplevel : toplevel_env) (binder : Syntax.binder) ty is_pub - doc (tvar_env : Tvar_env.t) ~kind ~arity ~param_names - ~(binder_loc : Loc.t) : Qual_ident.t = - let name = binder.binder_name in - (match Typing_info.find_value toplevel name with - | Some v -> - let first_loc, extra_message = get_duplicate_loc_info v in - add_global_error diagnostics - (Errors.value_redeclare ~name ~first_loc ~second_loc:binder_loc - ~extra_message) - | None -> ( - match Method_env.find_methods_by_name method_env ~method_name:name with - | [] -> () - | (_, m) :: _ -> - add_global_error diagnostics - (Errors.value_redeclare ~name ~first_loc:m.loc - ~second_loc:binder_loc ~extra_message:None))); - let qid : Qual_ident.t = Qual_ident.toplevel_value ~name in - Typing_info.add_value toplevel - { - id = qid; - typ = ty; - pub = is_pub; - kind; - loc_ = binder_loc; - doc_ = doc; - ty_params_ = tvar_env; - arity_ = arity; - param_names_ = param_names; - direct_use_loc_ = Not_direct_use; - }; - qid - in - let main_loc = ref None in - let go (impl : Syntax.impl) : unit = - match impl with - | Ptop_expr { expr; is_main = true; local_types = _; loc_ } -> - if build_context = Lib then - add_global_error diagnostics (Errors.unexpected_main loc_); - if !main_loc <> None then + ~(worklist : Local_typing_worklist.value Vec.t) + ~(constant_worklist : Local_typing_worklist.const_decl Vec.t) ~diagnostics + ~(build_context : Typeutil.build_context) = + (let add_symbol (toplevel : toplevel_env) (binder : Syntax.binder) ty is_pub + doc (tvar_env : Tvar_env.t) ~(attrs : Checked_attributes.t) ~kind ~arity + ~param_names ~(binder_loc : Loc.t) = + (let name = binder.binder_name in + (match Typing_info.find_value toplevel name with + | Some v -> + let first_loc, extra_message = get_duplicate_loc_info v in add_global_error diagnostics - (Errors.multiple_main ~first_loc:(Option.get !main_loc) - ~second_loc:loc_) - else main_loc := Some loc_; - let id = - Basic_qual_ident.toplevel_value ~name:("*main" : Stdlib.String.t) - in - Vec.push worklist (Wl_top_expr { expr; is_main = true; id; loc_ }) - | Ptop_expr { expr; is_main = false; local_types = _; loc_ } -> - let id = - Basic_qual_ident.toplevel_value - ~name: - ("*init" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) - in - Vec.push worklist (Wl_top_expr { expr; is_main = false; id; loc_ }) - | Ptop_test _ -> assert false - | Ptop_typedef { components = Ptd_alias _; _ } -> () - | Ptop_typedef type_decl -> - let desc : Typedecl_info.t = - Global_env.All_types.find_toplevel_type_exn types type_decl.tycon - in - let local_diagnostics = Local_diagnostics.make ~base:type_decl.loc_ in - Lst.iter type_decl.deriving_ (fun directive -> - let trait = directive.type_name_ in - let trait = - { trait with name = Derive.resolve_derive_alias trait.name } + (Errors.value_redeclare ~name ~first_loc ~second_loc:binder_loc + ~extra_message) + | None -> ()); + let qid : Qual_ident.t = Qual_ident.toplevel_value ~name in + Typing_info.add_value toplevel + { + id = qid; + typ = ty; + pub = is_pub; + kind; + loc_ = binder_loc; + doc_ = doc; + attrs; + ty_params_ = tvar_env; + arity_ = arity; + param_names_ = param_names; + direct_use_loc_ = Not_direct_use; + }; + qid + : Qual_ident.t) + in + let main_loc = ref None in + let go (impl : Syntax.impl) = + (match impl with + | Ptop_expr { expr; is_main = true; local_types; loc_ } -> + if build_context = Lib then + add_global_error diagnostics (Errors.unexpected_main loc_); + if !main_loc <> None then + add_global_error diagnostics + (Errors.multiple_main ~first_loc:(Option.get !main_loc) + ~second_loc:loc_) + else main_loc := Some loc_; + let id = + Basic_qual_ident.toplevel_value + ~name:(("*main" : Stdlib.String.t) [@merlin.hide]) + in + Vec.push worklist + (Wl_top_expr { expr; is_main = true; id; loc_; local_types }) + | Ptop_expr { expr; is_main = false; local_types; loc_ } -> + let id = + Basic_qual_ident.toplevel_value + ~name: + (("*init" ^ Int.to_string (Basic_uuid.next ()) + : Stdlib.String.t) + [@merlin.hide]) + in + Vec.push worklist + (Wl_top_expr { expr; is_main = false; id; loc_; local_types }) + | Ptop_test _ -> assert false + | Ptop_typedef _ -> () + | Ptop_trait _ -> () + | Ptop_trait_alias _ -> () + | Ptop_letdef { binder; ty; expr; is_constant; vis; loc_; attrs; doc_ } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let binder_loc = Rloc.to_loc ~base:loc_ binder.loc_ in + let is_pub = + transl_value_visibility ~local_diagnostics ~entity:"value" vis + in + let check_toplevel_let (binder : Syntax.binder) (expr : Syntax.expr) + (ty_opt : Syntax.typ option) (toplevel : toplevel_env) = + (let add_letdef konstraint typ = + let attrs = + Checked_attributes.check ~local_diagnostics ~context:`TopLet + attrs + in + if is_constant then + Vec.push constant_worklist + { + binder; + expr; + is_pub; + loc_; + doc_; + attrs; + konstraint; + id = Qual_ident.toplevel_value ~name:binder.binder_name; + typ; + } + else + let id = + add_symbol toplevel binder typ is_pub doc_ Tvar_env.empty + ~attrs ~kind:Normal ~arity:None ~param_names:[] ~binder_loc + in + Vec.push worklist + (Wl_top_letdef + { + binder; + expr; + is_pub; + loc_; + doc_; + attrs; + konstraint; + id; + typ; + }) + [@@inline] + in + match (ty_opt, expr) with + | Some ty_expr, _ | None, Pexpr_constraint { ty = ty_expr; _ } -> + let konstraint = + typing_type ~allow_private:(not is_pub) ty_expr + ~tvar_env:Tvar_env.empty ~types + ~diagnostics:local_diagnostics + in + add_letdef (Some konstraint) + (Typedtree_util.stype_of_typ konstraint) + | None, expr -> ( + match try_infer_expr ~types expr with + | Some (ty, is_literal) -> + if (not is_literal) && is_pub then + add_error local_diagnostics + (Errors.let_missing_annot ~name:binder.binder_name + ~loc:binder.loc_ ~reason:`Pub_not_literal); + add_letdef None ty + | None -> + add_error local_diagnostics + (Errors.let_missing_annot ~name:binder.binder_name + ~loc:binder.loc_ ~reason:`Cannot_infer); + add_letdef None Stype.blackhole) + : unit) + in + let res = check_toplevel_let binder expr ty toplevel in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + res + | Ptop_funcdef { fun_decl; decl_body; loc_ } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let check_toplevel_fun (fun_decl : Syntax.fun_decl) + (toplevel : toplevel_env) = + let ({ + type_name; + name; + has_error; + is_async; + quantifiers; + return_type; + decl_params; + params_loc_; + vis; + doc_; + attrs; + } + : Syntax.fun_decl) = + fun_decl in - let trait_loc = Rloc.to_loc ~base:type_decl.loc_ trait.loc_ in - Derive.generate_signatures ~types ~ext_method_env ~trait_impls - ~diagnostics:local_diagnostics ~loc:trait_loc desc trait; - match - Global_env.All_types.find_trait types trait.name - ~loc:Rloc.no_location - with - | Ok { name = trait_path; _ } -> - Vec.push worklist - (Wl_derive - { - directive = { directive with type_name_ = trait }; - ty_decl = desc; - syn_decl = type_decl; - trait_path; - loc_ = trait_loc; - }) - | Error _ -> ()); - Local_diagnostics.add_to_global local_diagnostics diagnostics - | Ptop_trait _ -> () - | Ptop_letdef { binder; ty; expr; is_constant; is_pub; loc_; doc_ } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let binder_loc = Rloc.to_loc ~base:loc_ binder.loc_ in - let check_toplevel_let (binder : Syntax.binder) (expr : Syntax.expr) - (ty_opt : Syntax.typ option) (toplevel : toplevel_env) : unit = - let add_letdef konstraint typ = - let non_constant () = - (Value_info.Normal, Wl_toplet_normal expr) - [@@inline] + let attrs = + Checked_attributes.check ~local_diagnostics ~context:`TopFun attrs in - let (kind : Value_info.value_kind), expr = - if is_constant then ( - (match - Typing_info.find_constructor toplevel binder.binder_name - with - | constr :: _ -> - Diagnostics.add_error diagnostics - (Errors.constant_constr_duplicate ~name:binder.binder_name - ~constr_loc:constr.cs_loc_ ~const_loc:binder_loc) - | [] -> ()); - let is_valid_constant_type (b : Stype.builtin) = - match b with - | T_unit | T_bool | T_byte | T_char | T_int | T_int64 | T_uint - | T_uint64 | T_float | T_double | T_string -> - true - | T_bytes -> false - in - match Stype.type_repr typ with - | T_builtin b as typ when is_valid_constant_type b -> ( - match expr with - | Pexpr_constant { c; loc_ } -> - let actual_ty, c = - Typeutil.typing_constant ~expect_ty:(Some typ) c - ~loc:loc_ - |> take_info_partial ~diagnostics:local_diagnostics - in - Ctype.unify_expr ~expect_ty:typ ~actual_ty loc_ - |> Typeutil.store_error ~diagnostics:local_diagnostics; - ( Const c, - Wl_toplet_const - (Texpr_constant { c; ty = typ; name_ = None; loc_ }) - ) - | _ -> - add_error local_diagnostics - (Errors.constant_not_constant - (Syntax.loc_of_expression expr)); - non_constant ()) - | T_blackhole | Tvar { contents = Tnolink Tvar_error } -> - non_constant () - | _ -> - let loc = - match konstraint with - | Some konstraint -> Typedtree.loc_of_typ konstraint - | None -> Syntax.loc_of_expression expr - in - add_error local_diagnostics - (Errors.invalid_constant_type - ~ty:(Printer.type_to_string typ) - ~loc); - non_constant ()) - else non_constant () + let is_pub = + transl_value_visibility ~local_diagnostics ~entity:"function" vis + in + let tvar_env, constraint_names = + Typeutil.typing_func_def_tparam_binders + ~allow_private:(not is_pub) ~types quantifiers + ~diagnostics:local_diagnostics in - let id = - add_symbol toplevel binder typ is_pub doc_ Tvar_env.empty ~kind - ~arity:None ~param_names:[] ~binder_loc + let decl_params = Option.value ~default:[] decl_params in + let params_typ = + Lst.map decl_params (fun (p : Syntax.parameter) -> + match Syntax.ty_of_param p with + | None -> + let binder_name = Syntax.binder_name_of_param p in + let loc = Syntax.loc_of_param_binder p in + add_error local_diagnostics + (Errors.missing_param_annot ~name:binder_name ~loc); + (Stype.blackhole, None) + | Some ty -> + let typ = + typing_type ~allow_private:(not is_pub) ty ~tvar_env + ~types ~diagnostics:local_diagnostics + in + (Typedtree_util.stype_of_typ typ, Some typ)) + in + let ret_sty, err_sty, (ret_annotation : Typeutil.ret_annotation) = + match return_type with + | None -> ( + match decl_body with + | Decl_body _ -> + add_error local_diagnostics + (Errors.missing_return_annot fun_decl.name.loc_); + (Stype.blackhole, None, No_annotation) + | Decl_stubs _ -> (Stype.unit, None, No_annotation)) + | Some (res_ty, err_ty) -> + let typ = + typing_type ~allow_private:(not is_pub) res_ty ~tvar_env + ~types ~diagnostics:local_diagnostics + in + let err_sty, err_typ = + typing_error_type ~allow_private:(not is_pub) ~types + ~tvar_env err_ty ~diagnostics:local_diagnostics + ~has_error: + (match has_error with Some _ -> true | _ -> false) + ~header_loc:name.loc_ + in + ( Typedtree_util.stype_of_typ typ, + err_sty, + Annotated (typ, err_typ) ) + in + let typ_generic = not (quantifiers = []) in + let fun_type : Stype.t = + Tarrow + { + params_ty = Lst.map params_typ fst; + ret_ty = ret_sty; + err_ty = err_sty; + generic_ = typ_generic; + is_async; + } + in + let arity = + take_info_partial ~diagnostics:local_diagnostics + (Fn_arity.from_params decl_params ~base:loc_) + in + let param_names = Lst.map decl_params Syntax.binder_name_of_param in + let prim = prim_of_decl decl_body loc_ ~doc:doc_ ~diagnostics in + let kind, id = + match type_name with + | Some type_name -> ( + match + Typeutil.typing_type_name type_name + ~allow_private:(not is_pub) ~tvar_env:Tvar_env.empty + ~types ~local_type_env:None ~diagnostics:local_diagnostics + with + | Some ((Tname_param _ | Tname_local_type _), _) -> + assert false + | Some + ( (Tname_predef ty_constr | Tname_defined { ty_constr; _ }), + type_name ) -> + let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in + ( Typedtree.Fun_kind_method (Some type_name), + add_method ty_constr fun_type name is_pub + ~is_trait:false ~doc:doc_ ~attrs ~types ~tvar_env + ~method_env ~diagnostics:local_diagnostics ~arity + ~param_names ~prim ~kind:Regular_method_qualified + ~meth_loc ) + | Some (Tname_trait_object trait_decl, type_name) -> + let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in + ( Typedtree.Fun_kind_method (Some type_name), + add_method trait_decl.name fun_type name is_pub + ~is_trait:true ~doc:doc_ ~attrs ~types ~tvar_env + ~method_env ~diagnostics:local_diagnostics ~arity + ~param_names ~prim ~kind:Regular_method_qualified + ~meth_loc ) + | Some (Tname_trait _, tast_type_name) -> + Local_diagnostics.add_error local_diagnostics + (Errors.type_not_found + ~tycon:(Basic_longident.to_string type_name.name) + ~loc:type_name.loc_); + ( Typedtree.Fun_kind_method (Some tast_type_name), + Qual_ident.toplevel_value ~name:name.binder_name ) + | None -> + ( Typedtree.Fun_kind_regular, + Qual_ident.toplevel_value ~name:name.binder_name )) + | None -> ( + match Typeutil.classify_func decl_params with + | Method _ -> + let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in + let self_ty, _ = List.hd params_typ in + ( Typedtree.Fun_kind_method None, + add_self_method self_ty fun_type name is_pub ~doc:doc_ + ~attrs ~types ~tvar_env ~method_env ~toplevel + ~diagnostics ~local_diagnostics ~arity ~param_names + ~prim ~meth_loc ) + | Regular_func -> + let binder_loc = Rloc.to_loc ~base:loc_ name.loc_ in + ( Typedtree.Fun_kind_regular, + add_symbol toplevel name fun_type is_pub doc_ tvar_env + ~attrs ~arity:(Some arity) + ~kind: + (match prim with + | None -> Normal + | Some p -> Prim p) + ~param_names ~binder_loc )) + in + let typed_fn_annotation : Local_typing_worklist.typed_fn_annotation + = + { + params_ty = params_typ; + ret_ty = ret_sty; + err_ty = err_sty; + is_async; + ret_annotation; + } in Vec.push worklist - (Wl_top_letdef - { binder; expr; is_pub; loc_; doc_; konstraint; id; typ }) - [@@inline] + (Wl_top_funcdef + { + fun_binder = name; + decl_params; + params_loc = params_loc_; + is_pub; + doc = doc_; + attrs; + decl_body; + loc_; + id; + kind; + arity; + tvar_env; + constraint_names; + typed_fn_annotation; + }) in - match (ty_opt, expr) with - | Some ty_expr, _ | None, Pexpr_constraint { ty = ty_expr; _ } -> - let konstraint = - typing_type ~allow_private:(not is_pub) ty_expr - ~tvar_env:Tvar_env.empty ~types ~diagnostics:local_diagnostics - in - add_letdef (Some konstraint) - (Typedtree_util.stype_of_typ konstraint) - | None, expr -> ( - match try_infer_expr ~types expr with - | Some (ty, is_literal) -> - if (not is_literal) && is_pub then - add_error local_diagnostics - (Errors.let_missing_annot ~name:binder.binder_name - ~loc:binder.loc_ ~reason:`Pub_not_literal); - add_letdef None ty - | None -> - add_error local_diagnostics - (Errors.let_missing_annot ~name:binder.binder_name - ~loc:binder.loc_ ~reason:`Cannot_infer); - add_letdef None Stype.blackhole) - in - let res = check_toplevel_let binder expr ty toplevel in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res - | Ptop_funcdef { fun_decl; decl_body; loc_ } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let check_toplevel_fun (fun_decl : Syntax.fun_decl) - (toplevel : toplevel_env) = - let ({ - type_name; - name; - has_error; - quantifiers; - return_type; - decl_params; - params_loc_; - is_pub; - doc_; - } - : Syntax.fun_decl) = - fun_decl + let res = check_toplevel_fun fun_decl toplevel in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + res + | Ptop_impl + { + self_ty = None; + trait; + method_name = method_binder; + has_error; + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_; + attrs; + doc_; + } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let method_name = method_binder.binder_name in + let is_partial = method_name = "*" in + (match vis with + | Vis_default -> () + | Vis_pub { loc_; attr = _ } | Vis_priv { loc_ } -> + add_error local_diagnostics (Errors.no_vis_on_default_impl loc_)); + let is_pub, trait_decl, type_name = + match + typing_trait_name ~types ~allow_private:true trait + ~diagnostics:local_diagnostics + with + | Some trait_decl, type_name -> + let is_pub = + match trait_decl.vis_ with + | Vis_fully_pub -> true + | Vis_priv | Vis_default | Vis_readonly -> false + in + (is_pub, Some trait_decl, type_name) + | None, type_name -> (false, None, type_name) + in + let method_decl = + match trait_decl with + | None -> None + | Some trait_decl -> ( + match + Trait_decl.find_method trait_decl method_name + ~loc:method_binder.loc_ + with + | Ok meth_decl -> Some meth_decl + | Error err -> + if not is_partial then add_error local_diagnostics err; + None) in - let tvar_env = + let tvar_env, constraint_names = Typeutil.typing_func_def_tparam_binders ~allow_private:(not is_pub) - ~types quantifiers - |> Typeutil.take_info_partial ~diagnostics:local_diagnostics + ~types + ({ + tvar_name = "Self"; + tvar_constraints = + (match trait_decl with + | Some _ -> + [ { tvc_trait = trait.name; loc_ = Rloc.no_location } ] + | _ -> []); + loc_ = Rloc.no_location; + } + :: quantifiers) + ~diagnostics:local_diagnostics + in + let arity = + take_info_partial ~diagnostics:local_diagnostics + (Fn_arity.from_params params ~base:loc_) in - let decl_params = Option.value ~default:[] decl_params in let params_typ = - Lst.map decl_params (fun (p : Syntax.parameter) -> - match p.param_annot with - | None -> - add_error local_diagnostics - (Errors.missing_param_annot - ~name:p.param_binder.binder_name - ~loc:p.param_binder.loc_); - (Stype.blackhole, None) + Lst.map params (fun p -> + match Syntax.ty_of_param p with + | None -> (Stype.new_type_var Tvar_normal, None) | Some ty -> let typ = typing_type ~allow_private:(not is_pub) ty ~tvar_env @@ -1490,501 +1951,395 @@ let check_toplevel_decl ~(toplevel : toplevel_env) (impls : Syntax.impls) in (Typedtree_util.stype_of_typ typ, Some typ)) in - let ret_sty, err_sty, ret_annotation = - match return_type with - | None -> ( - match decl_body with - | Decl_body _ -> - add_error local_diagnostics - (Errors.missing_return_annot fun_decl.name.loc_); - (Stype.blackhole, None, No_error_type_annotated) - | Decl_stubs _ -> (Stype.unit, None, No_error_type_annotated)) + let ret_sty, err_sty, (ret_annotation : Typeutil.ret_annotation) = + match ret_ty with + | None -> + let has_error_type = + match method_decl with + | Some method_decl -> ( + match method_decl.method_typ with + | Tarrow { err_ty = Some _; _ } -> true + | _ -> false) + | None -> false + in + ( Stype.new_type_var Tvar_normal, + (if has_error_type then Some (Stype.new_type_var Tvar_normal) + else None), + if has_error_type then Has_super_error header_loc_ + else No_annotation ) | Some (res_ty, err_ty) -> let typ = typing_type ~allow_private:(not is_pub) res_ty ~tvar_env ~types ~diagnostics:local_diagnostics in let err_sty, err_typ = - typing_error_type ~allow_private:(not is_pub) ~types ~tvar_env - err_ty ~diagnostics:local_diagnostics ~has_error - ~header_loc:name.loc_ + typing_error_type ~allow_private:(not is_pub) err_ty ~tvar_env + ~types ~diagnostics:local_diagnostics ~has_error + ~header_loc:method_binder.loc_ in ( Typedtree_util.stype_of_typ typ, err_sty, Annotated (typ, err_typ) ) in - let typ_generic = not (quantifiers = []) in - let fun_type : Stype.t = + let ty_func : Stype.t = Tarrow { - params_ty = List.map fst params_typ; + params_ty = Lst.map params_typ fst; ret_ty = ret_sty; err_ty = err_sty; - generic_ = typ_generic; + generic_ = true; + is_async = false; } in - let arity = - Fn_arity.from_params decl_params ~base:loc_ - |> take_info_partial ~diagnostics:local_diagnostics - in - let param_names = - Lst.map decl_params (fun p -> p.param_binder.binder_name) - in - let prim = prim_of_decl decl_body loc_ ~doc:doc_ ~diagnostics in - let kind, id = - match type_name with - | Some type_name -> ( - match - Typeutil.typing_type_name type_name - ~allow_private:(not is_pub) ~tvar_env:Tvar_env.empty ~types - |> take_info_partial ~diagnostics:local_diagnostics - with - | Some (Tname_param _, _) -> assert false - | Some - ( (Tname_predef ty_constr | Tname_defined { ty_constr; _ }), - type_name ) -> - let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in - ( Typedtree.Fun_kind_method (Some type_name), - add_method ty_constr fun_type name is_pub ~is_trait:false - ~doc:doc_ ~types ~tvar_env ~method_env ~toplevel - ~diagnostics:local_diagnostics ~arity ~param_names ~prim - ~meth_loc ) - | Some (Tname_trait trait_decl, type_name) -> - let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in - ( Typedtree.Fun_kind_method (Some type_name), - add_method trait_decl.name fun_type name is_pub - ~is_trait:true ~doc:doc_ ~types ~tvar_env ~method_env - ~toplevel ~diagnostics:local_diagnostics ~arity - ~param_names ~prim ~meth_loc ) - | None -> - ( Typedtree.Fun_kind_regular, - Qual_ident.toplevel_value ~name:name.binder_name )) - | None -> ( - match Typeutil.classify_func decl_params with - | Method _ -> - let meth_loc = Rloc.to_loc ~base:loc_ name.loc_ in - let self_ty, _ = List.hd params_typ in - ( Typedtree.Fun_kind_method None, - add_self_method self_ty fun_type name is_pub ~doc:doc_ - ~types ~tvar_env ~method_env ~toplevel - ~diagnostics:local_diagnostics ~arity ~param_names ~prim - ~meth_loc ) - | Regular_func -> - let binder_loc = Rloc.to_loc ~base:loc_ name.loc_ in - ( Typedtree.Fun_kind_regular, - add_symbol toplevel name fun_type is_pub doc_ tvar_env - ~arity:(Some arity) - ~kind: - (match prim with None -> Normal | Some p -> Prim p) - ~param_names ~binder_loc )) + let attrs = + Checked_attributes.check ~local_diagnostics ~context:`Impl attrs in - let typed_fn_annotation = + let typed_fn_annotation : Local_typing_worklist.typed_fn_annotation = { params_ty = params_typ; ret_ty = ret_sty; err_ty = err_sty; + is_async = false; ret_annotation; } in - Vec.push worklist - (Wl_top_funcdef - { - fun_binder = name; - decl_params; - params_loc = params_loc_; - is_pub; - doc = doc_; - decl_body; - loc_; - id; - kind; - arity; - tvar_env; - typed_fn_annotation; - }) - in - let res = check_toplevel_fun fun_decl toplevel in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res - | Ptop_impl - { - self_ty = None; - trait; - method_name = method_binder; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub = _; - local_types; - header_loc_; - loc_; - doc_; - } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let method_name = method_binder.binder_name in - let is_partial = method_name = "*" in - let is_pub, trait_decl, type_name = - match - typing_trait_name ~types ~allow_private:true trait + let add_to_worklist id = + Vec.push worklist + (Wl_top_funcdef + { + fun_binder = method_binder; + decl_params = params; + params_loc = Rloc.no_location; + is_pub; + doc = doc_; + attrs; + decl_body = body; + loc_; + id; + kind = Fun_kind_default_impl type_name; + arity; + tvar_env; + constraint_names; + typed_fn_annotation; + }) + [@@inline] + in + let res = + match trait_decl with + | None -> + add_to_worklist (Qual_ident.toplevel_value ~name:method_name) + | Some trait_decl -> ( + let trait = trait_decl.name in + let id = + Qual_ident.ext_meth ~trait + ~self_typ:Type_path.Builtin.default_impl_placeholder + ~name:method_name + in + add_to_worklist id; + match + Trait_decl.find_method trait_decl method_name + ~loc:method_binder.loc_ + with + | Error err -> add_error local_diagnostics err + | Ok meth_decl -> ( + let exception Arity_mismatch in + (try + Ctype.unify_exn meth_decl.method_typ ty_func; + if not (Fn_arity.equal arity meth_decl.method_arity) then + raise_notrace Arity_mismatch + with _ -> + add_error local_diagnostics + (Errors.ext_method_type_mismatch ~trait ~method_name + ~expected: + (Printer.toplevel_function_type_to_string + ~arity:meth_decl.method_arity + meth_decl.method_typ) + ~actual: + (Printer.toplevel_function_type_to_string ~arity + ty_func) + ~loc:method_binder.loc_)); + if Type_path_util.is_foreign trait then + add_error local_diagnostics + (Errors.default_method_on_foreign ~trait + ~loc:method_binder.loc_) + else + match + Ext_method_env.find_method ext_method_env ~trait + ~self_type:Type_path.Builtin.default_impl_placeholder + ~method_name + with + | Some mi -> + add_error local_diagnostics + (Errors.default_method_duplicate ~trait ~method_name + ~first_loc:mi.loc ~second_loc:method_binder.loc_) + | None -> + let method_info : Ext_method_env.method_info = + { + id; + prim = + prim_of_decl body loc_ ~doc:doc_ ~diagnostics; + typ = ty_func; + pub = is_pub; + loc = loc_; + doc_; + attrs; + ty_params_ = tvar_env; + kind_ = + Method_explicit_self + { + self_ty = + (Tvar_env.find_by_index_exn tvar_env 0) + .typ; + }; + arity_ = arity; + param_names_ = + Lst.map params Syntax.binder_name_of_param; + } + in + Ext_method_env.add_method ext_method_env ~trait + ~self_type: + Type_path.Builtin.default_impl_placeholder + ~method_name method_info)) + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + res + | Ptop_impl + { + self_ty = Some self_ty; + trait; + method_name = method_binder; + has_error; + quantifiers; + params; + ret_ty; + body; + vis; + header_loc_; + loc_; + attrs; + doc_; + } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let method_name = method_binder.binder_name in + let is_pub = + transl_value_visibility ~local_diagnostics ~entity:"impl" vis + in + let tvar_env, constraint_names = + Typeutil.typing_func_def_tparam_binders ~allow_private:(not is_pub) + ~types quantifiers ~diagnostics:local_diagnostics + in + let self_typ = + typing_type ~allow_private:(not is_pub) self_ty ~tvar_env ~types ~diagnostics:local_diagnostics - with - | Some trait_decl, type_name -> - let is_pub = - match trait_decl.vis_ with - | Vis_fully_pub -> true - | Vis_priv | Vis_default | Vis_readonly -> false - in - (is_pub, Some trait_decl, type_name) - | None, type_name -> (false, None, type_name) - in - let method_decl = - match trait_decl with - | None -> None - | Some trait_decl -> ( - match - Trait_decl.find_method trait_decl method_name - ~loc:method_binder.loc_ - with - | Ok meth_decl -> Some meth_decl - | Error err -> - if not is_partial then add_error local_diagnostics err; - None) - in - let tvar_env = - Typeutil.typing_func_def_tparam_binders ~allow_private:(not is_pub) - ~types - ({ - tvar_name = "Self"; - tvar_constraints = - (if Option.is_some trait_decl then - [ { tvc_trait = trait.name; loc_ = Rloc.no_location } ] - else []); - loc_ = Rloc.no_location; - } - :: quantifiers) - |> Typeutil.take_info_partial ~diagnostics:local_diagnostics - in - let arity = - Fn_arity.from_params params ~base:loc_ - |> take_info_partial ~diagnostics:local_diagnostics - in - let params_typ = - Lst.map params (fun p -> - match p.param_annot with - | None -> (Stype.new_type_var Tvar_normal, None) - | Some ty -> - let typ = - typing_type ~allow_private:(not is_pub) ty ~tvar_env ~types - ~diagnostics:local_diagnostics - in - (Typedtree_util.stype_of_typ typ, Some typ)) - in - let ret_sty, err_sty, ret_annotation = - match ret_ty with - | None -> - let has_error_type = - match method_decl with - | Some method_decl -> ( - match method_decl.method_typ with - | Tarrow { err_ty = Some _; _ } -> true - | _ -> false) - | None -> false - in - ( Stype.new_type_var Tvar_normal, - (if has_error_type then Some (Stype.new_type_var Tvar_normal) - else None), - if has_error_type then Has_error_type header_loc_ - else No_error_type_annotated ) - | Some (res_ty, err_ty) -> - let typ = - typing_type ~allow_private:(not is_pub) res_ty ~tvar_env ~types - ~diagnostics:local_diagnostics - in - let err_sty, err_typ = - typing_error_type ~allow_private:(not is_pub) err_ty ~tvar_env - ~types ~diagnostics:local_diagnostics ~has_error - ~header_loc:method_binder.loc_ - in - ( Typedtree_util.stype_of_typ typ, - err_sty, - Annotated (typ, err_typ) ) - in - let ty_func : Stype.t = - Tarrow + in + let arity = + take_info_partial ~diagnostics:local_diagnostics + (Fn_arity.from_params params ~base:loc_) + in + let params_typ = + Lst.map params (fun p -> + match Syntax.ty_of_param p with + | None -> (Stype.new_type_var Tvar_normal, None) + | Some ty -> + let typ = + typing_type ~allow_private:(not is_pub) ty ~tvar_env + ~types ~diagnostics:local_diagnostics + in + (Typedtree_util.stype_of_typ typ, Some typ)) + in + let ret_sty, err_sty, (ret_annotation : Typeutil.ret_annotation) = + match ret_ty with + | None -> + let has_error_typ = + match + Global_env.All_types.find_trait types trait.name + ~loc:trait.loc_ + with + | Error _ -> false + | Ok trait_decl -> ( + match + Trait_decl.find_method trait_decl method_name + ~loc:method_binder.loc_ + with + | Ok method_decl -> ( + match method_decl.method_typ with + | Tarrow { err_ty = Some _; _ } -> true + | _ -> false) + | Error _ -> false) + in + ( Stype.new_type_var Tvar_normal, + (if has_error_typ then Some (Stype.new_type_var Tvar_normal) + else None), + if has_error_typ then Has_super_error header_loc_ + else No_annotation ) + | Some (res_ty, err_ty) -> + let typ = + typing_type ~allow_private:(not is_pub) res_ty ~tvar_env + ~types ~diagnostics:local_diagnostics + in + let err_sty, err_typ = + typing_error_type ~allow_private:(not is_pub) ~types ~tvar_env + err_ty ~diagnostics:local_diagnostics ~has_error + ~header_loc:method_binder.loc_ + in + ( Typedtree_util.stype_of_typ typ, + err_sty, + Annotated (typ, err_typ) ) + in + let ty_func : Stype.t = + Tarrow + { + params_ty = Lst.map params_typ fst; + ret_ty = ret_sty; + err_ty = err_sty; + is_async = false; + generic_ = true; + } + in + let typed_fn_annotation : Local_typing_worklist.typed_fn_annotation = { - params_ty = List.map fst params_typ; + params_ty = params_typ; ret_ty = ret_sty; err_ty = err_sty; - generic_ = true; + is_async = false; + ret_annotation; } - in - let typed_fn_annotation = - { - params_ty = params_typ; - ret_ty = ret_sty; - err_ty = err_sty; - ret_annotation; - } - in - let add_to_worklist id = - Vec.push worklist - (Wl_top_funcdef - { - fun_binder = method_binder; - decl_params = params; - params_loc = Rloc.no_location; - is_pub; - doc = doc_; - decl_body = Decl_body { expr = body; local_types }; - loc_; - id; - kind = Fun_kind_default_impl type_name; - arity; - tvar_env; - typed_fn_annotation; - }) - [@@inline] - in - let res = - match trait_decl with - | None -> - add_to_worklist (Qual_ident.toplevel_value ~name:method_name) - | Some trait_decl -> ( - let trait = trait_decl.name in - let id = - Qual_ident.ext_meth ~trait - ~self_typ:Type_path.Builtin.default_impl_placeholder - ~name:method_name - in - add_to_worklist id; - match - Trait_decl.find_method trait_decl method_name - ~loc:method_binder.loc_ - with - | Error err -> add_error local_diagnostics err - | Ok meth_decl -> ( - let exception Arity_mismatch in - (try - Ctype.unify_exn meth_decl.method_typ ty_func; - if not (Fn_arity.equal arity meth_decl.method_arity) then - raise_notrace Arity_mismatch - with _ -> - add_error local_diagnostics - (Errors.ext_method_type_mismatch ~trait ~method_name - ~expected: - (Printer.toplevel_function_type_to_string - ~arity:meth_decl.method_arity - meth_decl.method_typ) - ~actual: - (Printer.toplevel_function_type_to_string ~arity - ty_func) - ~loc:method_binder.loc_)); - if Type_path_util.is_foreign trait then - add_error local_diagnostics - (Errors.default_method_on_foreign ~trait - ~loc:method_binder.loc_) - else - match - Ext_method_env.find_method ext_method_env ~trait - ~self_type:Type_path.Builtin.default_impl_placeholder - ~method_name - with - | Some mi -> - add_error local_diagnostics - (Errors.default_method_duplicate ~trait ~method_name - ~first_loc:mi.loc ~second_loc:method_binder.loc_) - | None -> - let method_info : Ext_method_env.method_info = - { - id; - prim = None; - typ = ty_func; - pub = is_pub; - loc = loc_; - doc_; - ty_params_ = tvar_env; - arity_ = arity; - param_names_ = - Lst.map params (fun p -> - p.param_binder.binder_name); - } - in - Ext_method_env.add_method ext_method_env ~trait - ~self_type:Type_path.Builtin.default_impl_placeholder - ~method_name method_info)) - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res - | Ptop_impl - { - self_ty = Some self_ty; - trait; - method_name = method_binder; - has_error; - quantifiers; - params; - ret_ty; - body; - is_pub; - local_types; - header_loc_; - loc_; - doc_; - } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let method_name = method_binder.binder_name in - let tvar_env = - Typeutil.typing_func_def_tparam_binders ~allow_private:(not is_pub) - ~types quantifiers - |> Typeutil.take_info_partial ~diagnostics:local_diagnostics - in - let self_typ = - typing_type ~allow_private:(not is_pub) self_ty ~tvar_env ~types - ~diagnostics:local_diagnostics - in - let arity = - Fn_arity.from_params params ~base:loc_ - |> take_info_partial ~diagnostics:local_diagnostics - in - let params_typ = - Lst.map params (fun p -> - match p.param_annot with - | None -> (Stype.new_type_var Tvar_normal, None) - | Some ty -> - let typ = - typing_type ~allow_private:(not is_pub) ty ~tvar_env ~types - ~diagnostics:local_diagnostics + in + let attrs = + Checked_attributes.check ~local_diagnostics ~context:`Impl attrs + in + let add_to_worklist id type_name = + Vec.push worklist + (Wl_top_funcdef + { + fun_binder = method_binder; + decl_params = params; + params_loc = Rloc.no_location; + is_pub; + doc = doc_; + attrs; + decl_body = body; + loc_; + id; + kind = + Fun_kind_impl { self_ty = self_typ; trait = type_name }; + arity; + tvar_env; + constraint_names; + typed_fn_annotation; + }) + [@@inline] + in + let res = + match + typing_trait_name ~types ~allow_private:(not is_pub) trait + ~diagnostics:local_diagnostics + with + | None, type_name -> + add_to_worklist + (Qual_ident.toplevel_value ~name:method_name) + type_name + | ( Some ({ vis_ = Vis_default | Vis_readonly; _ } as trait_decl), + type_name ) + when Type_path_util.is_foreign trait_decl.name -> + let trait_vis = + match trait_decl.vis_ with + | Vis_default -> "abstract" + | Vis_readonly -> "readonly" + | Vis_priv | Vis_fully_pub -> assert false + in + add_error local_diagnostics + (Errors.cannot_implement_sealed_trait + ~trait:(Type_path_util.name trait_decl.name) + ~trait_vis ~loc:trait.loc_); + add_to_worklist + (Qual_ident.toplevel_value ~name:method_name) + type_name + | Some trait_decl, type_name -> + let meth_loc = Rloc.to_loc ~base:loc_ method_binder.loc_ in + let header_loc = + let self_typ = + Rloc.to_loc ~base:loc_ (Typedtree.loc_of_typ self_typ) in - (Typedtree_util.stype_of_typ typ, Some typ)) - in - let ret_sty, err_sty, ret_annotation = - match ret_ty with - | None -> - let has_error_typ = - match - Global_env.All_types.find_trait types trait.name - ~loc:trait.loc_ - with - | Error _ -> false - | Ok trait_decl -> ( - match - Trait_decl.find_method trait_decl method_name - ~loc:method_binder.loc_ - with - | Ok method_decl -> ( - match method_decl.method_typ with - | Tarrow { err_ty = Some _; _ } -> true - | _ -> false) - | Error _ -> false) - in - ( Stype.new_type_var Tvar_normal, - (if has_error_typ then Some (Stype.new_type_var Tvar_normal) - else None), - if has_error_typ then Has_error_type header_loc_ - else No_error_type_annotated ) - | Some (res_ty, err_ty) -> - let typ = - typing_type ~allow_private:(not is_pub) res_ty ~tvar_env ~types - ~diagnostics:local_diagnostics - in - let err_sty, err_typ = - typing_error_type ~allow_private:(not is_pub) ~types ~tvar_env - err_ty ~diagnostics:local_diagnostics ~has_error - ~header_loc:method_binder.loc_ - in - ( Typedtree_util.stype_of_typ typ, - err_sty, - Annotated (typ, err_typ) ) - in - let ty_func : Stype.t = - Tarrow + Loc.of_menhir (Loc.get_start loc_, Loc.get_end self_typ) + in + let prim = prim_of_decl body loc_ ~doc:doc_ ~diagnostics in + let id = + add_ext_method trait_decl ty_func method_binder is_pub + ~self_ty:(Typedtree_util.stype_of_typ self_typ) + ~doc:doc_ ~attrs ~types ~tvar_env ~ext_method_env + ~trait_impls ~arity + ~param_names:(Lst.map params Syntax.binder_name_of_param) + ~prim ~diagnostics:local_diagnostics + ~global_diagnostics:diagnostics ~meth_loc ~header_loc + in + add_to_worklist id type_name + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + res + | Ptop_impl_relation _ -> assert false + : unit) + in + Lst.iter impls ~f:go; + match build_context with + | Exec { is_main_loc } when !main_loc = None -> + add_global_error diagnostics (Errors.missing_main ~loc:is_main_loc) + | _ -> () + : unit) + +let load_trait_object_methods ~global_env = + let method_env = Global_env.get_method_env global_env in + let ext_method_env = Global_env.get_ext_method_env global_env in + let trait_impls = Global_env.get_trait_impls global_env in + Typing_info.iter_traits (Global_env.get_toplevel_types global_env) + (fun (_, trait_decl) -> + let trait = trait_decl.name in + let self_type : Stype.t = T_trait trait in + Lst.iteri trait_decl.closure_methods ~f:(fun index -> + fun (actual_trait, method_decl) -> + let method_name = method_decl.method_name in + let method_info : Method_env.method_info = + { + id = + Qual_ident.ext_meth ~trait:actual_trait ~self_typ:trait + ~name:method_name; + prim = + Some + (Pcall_object_method { method_index = index; method_name }); + typ = + Poly_type.instantiate_method_decl method_decl ~self:self_type; + pub = Typedecl_info.vis_is_pub trait_decl.vis_; + loc = method_decl.method_loc_; + doc_ = Docstring.empty; + attrs = []; + ty_params_ = Tvar_env.empty; + kind_ = Method_explicit_self { self_ty = self_type }; + arity_ = method_decl.method_arity; + param_names_ = []; + } + in + Ext_method_env.add_method ext_method_env ~trait:actual_trait + ~self_type:trait ~method_name method_info; + if Type_path.equal trait actual_trait then + Method_env.add_method method_env ~type_name:trait ~method_name + ~method_info + else + Method_env.add_impl method_env ~type_name:trait ~method_name + ~method_info); + Lst.iter trait_decl.closure ~f:(fun actual_trait -> + let impl : Trait_impl.impl = { - params_ty = List.map fst params_typ; - ret_ty = ret_sty; - err_ty = err_sty; - generic_ = true; + trait = actual_trait; + self_ty = self_type; + ty_params = Tvar_env.empty; + is_pub = Typedecl_info.vis_is_pub trait_decl.vis_; + is_implicit_ = true; + doc_ = Docstring.empty; + loc_ = Loc.no_location; } - in - let typed_fn_annotation = - { - params_ty = params_typ; - ret_ty = ret_sty; - err_ty = err_sty; - ret_annotation; - } - in - let add_to_worklist id type_name = - Vec.push worklist - (Wl_top_funcdef - { - fun_binder = method_binder; - decl_params = params; - params_loc = Rloc.no_location; - is_pub; - doc = doc_; - decl_body = Decl_body { expr = body; local_types }; - loc_; - id; - kind = Fun_kind_impl { self_ty = self_typ; trait = type_name }; - arity; - tvar_env; - typed_fn_annotation; - }) - [@@inline] - in - let res = - match - typing_trait_name ~types ~allow_private:(not is_pub) trait - ~diagnostics:local_diagnostics - with - | None, type_name -> - add_to_worklist - (Qual_ident.toplevel_value ~name:method_name) - type_name - | ( Some ({ vis_ = Vis_default | Vis_readonly; _ } as trait_decl), - type_name ) - when Type_path_util.is_foreign trait_decl.name -> - let trait_vis = - match trait_decl.vis_ with - | Vis_default -> "abstract" - | Vis_readonly -> "readonly" - | Vis_priv | Vis_fully_pub -> assert false - in - add_error local_diagnostics - (Errors.cannot_implement_sealed_trait - ~trait:(Type_path_util.name trait_decl.name) - ~trait_vis ~loc:trait.loc_); - add_to_worklist - (Qual_ident.toplevel_value ~name:method_name) - type_name - | Some trait_decl, type_name -> - let meth_loc = Rloc.to_loc ~base:loc_ method_binder.loc_ in - let header_loc = - Loc.merge loc_ - (Rloc.to_loc ~base:loc_ (Typedtree.loc_of_typ self_typ)) - in - let id = - add_ext_method trait_decl ty_func method_binder is_pub - ~self_ty:(Typedtree_util.stype_of_typ self_typ) - ~doc:doc_ ~types ~tvar_env ~ext_method_env ~trait_impls ~arity - ~param_names: - (Lst.map params (fun p -> p.param_binder.binder_name)) - ~prim:None ~diagnostics:local_diagnostics - ~global_diagnostics:diagnostics ~meth_loc ~header_loc - in - add_to_worklist id type_name - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res - | Ptop_impl_relation _ -> assert false - in - Lst.iter impls go; - match build_context with - | Exec { is_main_loc } when !main_loc = None -> - add_global_error diagnostics (Errors.missing_main ~loc:is_main_loc) - | _ -> () + in + Trait_impl.add_impl trait_impls ~trait:actual_trait ~type_name:trait + impl)) let check_traits_implemented ~global_env ~diagnostics = let check_method ~trait ~(trait_vis : Typedecl_info.visibility) ~self_typ @@ -2008,9 +2363,9 @@ let check_traits_implemented ~global_env ~diagnostics = None | Some { pub = false; _ } when request.is_pub -> Some (`Private_method method_name) - | Some { id = Qext_method _; pub = false; loc; _ } -> + | Some { id = Qext_method _; pub; loc; _ } -> (match trait_vis with - | Vis_fully_pub -> ( + | Vis_fully_pub when not pub -> ( match Global_env.find_regular_method global_env ~type_name:self_typ ~method_name @@ -2027,77 +2382,105 @@ let check_traits_implemented ~global_env ~diagnostics = Poly_type.instantiate_method_decl method_decl ~self:request.self_ty in let cenv = Poly_type.make () in - let actual, _ = Poly_type.instantiate_method ~cenv method_info in + let actual, ty_args = Poly_type.instantiate_method ~cenv method_info in if Ctype.try_unify expected actual then ( - let aux_diagnostics = Local_diagnostics.make ~base:Loc.no_location in - Type_constraint.solve_constraints cenv ~tvar_env:request.ty_params - ~global_env ~diagnostics:aux_diagnostics; - if Local_diagnostics.has_fatal_errors aux_diagnostics then - Some (`Method_constraint_not_satisfied method_name) - else None) + if + Arr.exists ty_args (fun ty -> + match Stype.type_repr ty with Tvar _ -> true | _ -> false) + then Some (`Method_type_params_unsolved method_name) + else + let aux_diagnostics = + Local_diagnostics.make ~base:Loc.no_location + in + Type_constraint.solve_constraints cenv ~tvar_env:request.ty_params + ~global_env ~diagnostics:aux_diagnostics; + if Local_diagnostics.has_fatal_errors aux_diagnostics then + Some (`Method_constraint_not_satisfied method_name) + else ( + Diagnostics.add_warning diagnostics + { + kind = + Implement_trait_with_method + { + trait = Type_path_util.name trait; + typ = Printer.type_to_string request.self_ty; + methods = [ method_name ]; + }; + loc = request.loc_; + }; + None)) else Some (`Type_mismatch - ( method_name, - Printer.type_to_string expected, - Printer.type_to_string method_info.typ )) + ( method_name, + Printer.type_to_string expected, + Printer.type_to_string method_info.typ )) [@@inline] in - Trait_impl.iter (Global_env.get_trait_impls global_env) - (fun ~trait ~type_name request -> - match Global_env.find_trait_by_path global_env trait with - | None -> () - | Some trait_decl -> ( - let failure_reasons = - Lst.fold_right trait_decl.methods [] (fun meth_decl acc -> - match - check_method ~trait ~trait_vis:trait_decl.vis_ - ~self_typ:type_name ~request meth_decl - with - | Some err -> err :: acc - | None -> acc) - in - match failure_reasons with - | [] -> () - | failure_reasons -> - add_global_error diagnostics - (trait_not_implemented ~trait ~type_name ~failure_reasons - ~loc:request.loc_))) - -type output = { - global_env : Global_env.t; - values : value_worklist_item Vec.t; - type_decls : Typedtree.type_decl list; - trait_decls : Typedtree.trait_decl list; -} + Trait_impl.iter (Global_env.get_trait_impls global_env) (fun ~trait -> + fun ~type_name -> + fun request -> + match Global_env.find_trait_by_path global_env trait with + | None -> () + | Some trait_decl -> ( + let failure_reasons = + Lst.fold_right trait_decl.methods [] (fun meth_decl -> + fun acc -> + match + check_method ~trait ~trait_vis:trait_decl.vis_ + ~self_typ:type_name ~request meth_decl + with + | Some err -> err :: acc + | None -> acc) + in + match failure_reasons with + | [] -> () + | failure_reasons -> + add_global_error diagnostics + (trait_not_implemented ~trait ~type_name ~failure_reasons + ~loc:request.loc_))) let check_toplevel ?(pkgs : Pkg.pkg_tbl option) ~diagnostics - ?(build_context : Typeutil.build_context = SingleFile) list_of_impls : - output = - let pkgs = match pkgs with Some pkgs -> pkgs | None -> Pkg.create_tbl () in - let impls = List.concat list_of_impls in - let builtin_types = Builtin.builtin_types in - let toplevel_types = Typing_info.make_types () in - let type_alias = Hash_string.create 17 in - let types = - Global_env.All_types.make ~toplevel:toplevel_types ~builtin:builtin_types - ~type_alias ~pkgs - in - let toplevel_values = Typing_info.make_values () in - Pkg.load_direct_uses pkgs toplevel_values type_alias ~diagnostics; - let worklist = Vec.empty () in - let type_decls, trait_decls = - typing_types_and_traits impls types toplevel_values ~diagnostics - in - let method_env = Method_env.empty () in - let ext_method_env = Ext_method_env.empty () in - let trait_impls = Trait_impl.make () in - check_toplevel_decl impls types ~method_env ~toplevel:toplevel_values - ~ext_method_env ~trait_impls ~worklist ~diagnostics ~build_context; - let builtin_values = Builtin.builtin_values in - let global_env = - Global_env.make ~types ~builtin:builtin_values ~toplevel:toplevel_values - ~method_env ~ext_method_env ~trait_impls - in - check_traits_implemented ~global_env ~diagnostics; - { global_env; values = worklist; type_decls; trait_decls } + ?(build_context : Typeutil.build_context = SingleFile) list_of_impls = + (let pkgs = match pkgs with Some pkgs -> pkgs | None -> Pkg.create_tbl () in + let impls = Lst.concat list_of_impls in + let builtin_types = Builtin.builtin_types in + let toplevel_types = Typing_info.make_types () in + let type_alias = Hash_string.create 17 in + let types = + Global_env.All_types.make ~toplevel:toplevel_types ~builtin:builtin_types + ~type_alias ~pkgs + in + let toplevel_values = Typing_info.make_values () in + Pkg.load_direct_uses pkgs toplevel_values type_alias ~impls ~diagnostics; + let method_env = Method_env.empty () in + let ext_method_env = Ext_method_env.empty () in + let trait_impls = Trait_impl.make () in + let worklist = Vec.empty () in + let constant_worklist = Vec.empty () in + let type_decls, trait_decls, trait_alias = + typing_types_and_traits impls types toplevel_values ~ext_method_env + ~trait_impls ~value_worklist:worklist ~diagnostics + in + check_toplevel_decl impls types ~method_env ~toplevel:toplevel_values + ~ext_method_env ~trait_impls ~worklist ~constant_worklist ~diagnostics + ~build_context; + let builtin_values = Builtin.builtin_values in + let global_env = + Global_env.make ~types ~builtin:builtin_values ~toplevel:toplevel_values + ~method_env ~ext_method_env ~trait_impls + in + let const_decls = + Const_util.typing_const_decls constant_worklist ~global_env ~diagnostics + in + check_traits_implemented ~global_env ~diagnostics; + load_trait_object_methods ~global_env; + { + global_env; + values = worklist; + const_decls; + type_decls; + trait_decls; + trait_alias; + } + : Local_typing_worklist.t) diff --git a/src/topo_sort.ml b/src/topo_sort.ml index c2d0c30..15c8ff1 100644 --- a/src/topo_sort.ml +++ b/src/topo_sort.ml @@ -21,70 +21,76 @@ module Lst = Basic_lst let add_error = Diagnostics.add_error -let vars_of_expr (e : Typedtree.expr) (tbl : _ T.t) : Ident.t list = - let vars = ref [] in - let obj = - object - inherit [_] Typedtree.iter +type 'a cxt = { tbl : 'a T.t; mutable vars : Ident.Set.t } - method! visit_var _ v = - if T.mem tbl v.var_id then vars := v.var_id :: !vars - end - in - obj#visit_expr () e; - !vars +let obj = + object + inherit [_] Typedtree.iter + + method! visit_var (cxt : _ cxt) v = + if T.mem cxt.tbl v.var_id then cxt.vars <- Ident.Set.add cxt.vars v.var_id + end + +let vars_of_impl (e : Typedtree.impl) (tbl : _ T.t) = + (let vars = { tbl; vars = Ident.Set.empty } in + obj#visit_impl vars e; + vars.vars + : Ident.Set.t) type 'a impl_info = { impl : Typedtree.impl; info : 'a } -type binder_vars = { binder : Ident.t; vars : Ident.t list } +type binder_vars = { binder : Ident.t; vars : Ident.Set.t } -let topo_sort ~diagnostics (defs : Typedtree.output) : Typedtree.output = - let (Output { value_defs = impls; type_defs; trait_defs }) = defs in +let topo_sort ~diagnostics (defs : Typedtree.output) = + (let (Output { value_defs = impls; type_defs; trait_defs; trait_alias }) = + defs + in let add_cycle cycle = let idents, locs = List.split cycle in let errors = Errors.cycle_definitions ~cycle:idents ~locs in - Lst.iter errors (add_error diagnostics) + Lst.iter errors ~f:(add_error diagnostics) in let tbl = T.create 17 in - let extract_binder i (impl : Typedtree.impl) : Ident.t impl_info = - match impl with - | Timpl_stub_decl { binder; _ } - | Timpl_fun_decl { fun_decl = { fn_binder = binder; _ }; _ } -> - T.add tbl binder.binder_id i; - { impl; info = binder.binder_id } - | Timpl_letdef { binder; _ } -> - let binder = binder.binder_id in - T.add tbl binder i; - { impl; info = binder } - | Timpl_expr t -> - let binder = Ident.of_qual_ident t.expr_id in - T.add tbl binder i; - { impl; info = binder } + let extract_binder i (impl : Typedtree.impl) = + (match impl with + | Timpl_stub_decl { binder; _ } + | Timpl_fun_decl { fun_decl = { fn_binder = binder; _ }; _ } -> + T.add tbl binder.binder_id i; + { impl; info = binder.binder_id } + | Timpl_letdef { binder; _ } -> + let binder = binder.binder_id in + T.add tbl binder i; + { impl; info = binder } + | Timpl_expr t -> + let binder = Ident.of_qual_ident t.expr_id in + T.add tbl binder i; + { impl; info = binder } + : Ident.t impl_info) in let extract_vars (impl_info : Ident.t impl_info) : binder_vars impl_info = let impl = impl_info.impl in match impl with - | Timpl_fun_decl { fun_decl = { fn; _ }; _ } -> + | Timpl_fun_decl { fun_decl = { fn = _; _ }; _ } -> { impl; - info = { binder = impl_info.info; vars = vars_of_expr fn.body tbl }; + info = { binder = impl_info.info; vars = vars_of_impl impl tbl }; } | Timpl_stub_decl _ -> - { impl; info = { binder = impl_info.info; vars = [] } } - | Timpl_letdef { expr; loc_; _ } -> + { impl; info = { binder = impl_info.info; vars = Ident.Set.empty } } + | Timpl_letdef { expr = _; loc_; _ } -> let binder = impl_info.info in - let vars = vars_of_expr expr tbl in - if Basic_lst.exists vars (fun v -> Ident.equal binder v) then + let vars = vars_of_impl impl tbl in + if Ident.Set.exists vars (fun v -> Ident.equal binder v) then add_cycle [ (binder, loc_) ]; { impl; info = { binder; vars } } - | Timpl_expr { expr; is_main = _; expr_id = _ } -> + | Timpl_expr { expr = _; is_main = _; expr_id = _ } -> { impl; - info = { binder = impl_info.info; vars = vars_of_expr expr tbl }; + info = { binder = impl_info.info; vars = vars_of_impl impl tbl }; } in let impl_array = - impls |> Array.of_list |> Array.mapi extract_binder - |> Array.map extract_vars + let impl_infos = Basic_arr.of_list_mapi impls extract_binder in + Array.map extract_vars impl_infos in let nodes_num = Array.length impl_array in let adjacency_array = Array.init nodes_num (fun _ -> VI.empty ()) in @@ -94,27 +100,31 @@ let topo_sort ~diagnostics (defs : Typedtree.output) : Typedtree.output = VI.push adjacency_array.(src) tgt in Array.iter - (fun impl -> List.iter (add_edge impl.info.binder) impl.info.vars) + (fun impl -> + Ident.Set.iter impl.info.vars (fun var -> add_edge impl.info.binder var)) impl_array; let scc = Basic_scc.graph adjacency_array in - let has_cycle (c : VI.t) : bool = - let is_letdef impl = - match impl with Typedtree.Timpl_letdef _ -> true | _ -> false - in - VI.length c > 1 && VI.exists (fun i -> is_letdef impl_array.(i).impl) c + let has_cycle (c : VI.t) = + (let is_letdef impl = + match impl with Typedtree.Timpl_letdef _ -> true | _ -> false + in + VI.length c > 1 && VI.exists (fun i -> is_letdef impl_array.(i).impl) c + : bool) in - let handle_cycle (c : VI.t) : unit = - let cycle = - VI.map_into_list c (fun i -> - let impl = impl_array.(i) in - (impl.info.binder, Typedtree.loc_of_impl impl.impl)) - in - add_cycle cycle + let handle_cycle (c : VI.t) = + (let cycle = + VI.map_into_list c ~unorder:(fun i -> + let impl = impl_array.(i) in + (impl.info.binder, Typedtree.loc_of_impl impl.impl)) + in + add_cycle cycle + : unit) in Vec.iter (fun c -> if has_cycle c then handle_cycle c) scc; let value_defs = - Vec.map_into_list scc (fun c -> - VI.map_into_list c (fun i -> impl_array.(i).impl)) - |> List.concat + Lst.concat + (Vec.map_into_list scc ~unorder:(fun c -> + VI.map_into_list c ~unorder:(fun i -> impl_array.(i).impl))) in - Output { value_defs; type_defs; trait_defs } + Output { value_defs; type_defs; trait_defs; trait_alias } + : Typedtree.output) diff --git a/src/trait_closure.ml b/src/trait_closure.ml index 7ce5531..88c1539 100644 --- a/src/trait_closure.ml +++ b/src/trait_closure.ml @@ -21,23 +21,26 @@ let compute_closure ~(types : Global_env.All_types.t) (constraints : Tvar_env.type_constraint list) = let visited = H.create (List.length constraints) in let closure = Vec.empty () in - Lst.iter constraints (fun c -> + Lst.iter constraints ~f:(fun c -> H.add visited c.trait; Vec.push closure c); - let rec add_super_traits ~loc_ ~required_by_ trait = - let required_by_ = trait :: required_by_ in + let rec add_super_traits ~loc_ ~supers trait = + let supers = trait :: supers in match Global_env.All_types.find_trait_by_path types trait with | None -> () | Some trait_decl -> - Lst.iter trait_decl.supers (fun new_trait -> + Lst.iter trait_decl.supers ~f:(fun new_trait -> if not (H.mem visited new_trait) then + let src_ : Tvar_env.constraint_src = + match supers with [] -> Direct | _ :: _ -> Super_traits supers + in let new_c : Tvar_env.type_constraint = - { trait = new_trait; loc_; required_by_ } + { trait = new_trait; loc_; src_ } in let () = H.add visited new_trait in let () = Vec.push closure new_c in - add_super_traits ~loc_ ~required_by_ new_trait) + add_super_traits ~loc_ ~supers new_trait) in - Lst.iter constraints (fun c -> - add_super_traits c.trait ~loc_:c.loc_ ~required_by_:[]); + Lst.iter constraints ~f:(fun c -> + add_super_traits c.trait ~loc_:c.loc_ ~supers:[]); Vec.to_list closure diff --git a/src/trait_decl.ml b/src/trait_decl.ml index 8a4efde..418a6c6 100644 --- a/src/trait_decl.ml +++ b/src/trait_decl.ml @@ -76,16 +76,20 @@ let type_not_object_safe ~name ~reasons ~loc = | Bad_method (method_name, First_param_not_self) -> ("The first parameter of method " ^ method_name ^ " is not `Self`" : Stdlib.String.t) + [@merlin.hide] | Bad_method (method_name, Self_in_return) -> ("`Self` occur in the return type of method " ^ method_name : Stdlib.String.t) + [@merlin.hide] | Bad_method (method_name, Multiple_self) -> ("`Self` occur multiple times in the type of method " ^ method_name : Stdlib.String.t) + [@merlin.hide] | Bad_super_trait super -> ("Its super trait " ^ Type_path_util.name super ^ " does not allow objects" - : Stdlib.String.t)) + : Stdlib.String.t) + [@merlin.hide]) in Errors.type_not_object_safe ~name ~reasons ~loc @@ -186,6 +190,7 @@ type t = { loc_ : location; doc_ : docstring; [@default Docstring.empty] [@sexp_drop_if Docstring.is_empty] + attrs : Checked_attributes.t; object_safety_ : object_safety_status; [@sexp_drop_if function [] -> true | _ -> false] } @@ -198,7 +203,7 @@ include struct | [] -> true | _ -> false and (drop_if__043_ : docstring -> Stdlib.Bool.t) = Docstring.is_empty - and (drop_if__048_ : object_safety_status -> Stdlib.Bool.t) = function + and (drop_if__050_ : object_safety_status -> Stdlib.Bool.t) = function | [] -> true | _ -> false in @@ -211,15 +216,20 @@ include struct vis_ = vis___038_; loc_ = loc___040_; doc_ = doc___044_; - object_safety_ = object_safety___049_; + attrs = attrs__047_; + object_safety_ = object_safety___051_; } -> let bnds__020_ = ([] : _ Stdlib.List.t) in let bnds__020_ = - if drop_if__048_ object_safety___049_ then bnds__020_ + if drop_if__050_ object_safety___051_ then bnds__020_ else - let arg__051_ = sexp_of_object_safety_status object_safety___049_ in - let bnd__050_ = S.List [ S.Atom "object_safety_"; arg__051_ ] in - (bnd__050_ :: bnds__020_ : _ Stdlib.List.t) + let arg__053_ = sexp_of_object_safety_status object_safety___051_ in + let bnd__052_ = S.List [ S.Atom "object_safety_"; arg__053_ ] in + (bnd__052_ :: bnds__020_ : _ Stdlib.List.t) + in + let bnds__020_ = + let arg__048_ = Checked_attributes.sexp_of_t attrs__047_ in + (S.List [ S.Atom "attrs"; arg__048_ ] :: bnds__020_ : _ Stdlib.List.t) in let bnds__020_ = if drop_if__043_ doc___044_ then bnds__020_ @@ -283,58 +293,62 @@ end let get_methods_object_safety (decl : Syntax.trait_decl) = Lst.fold_right decl.trait_methods [] - (fun (Trait_method { name; params; return_type; _ }) acc -> - match params with - | { - tmparam_typ = Ptype_name { constr_id = { lid = Lident "Self" }; _ }; - _; - } - :: ps -> ( - let exception Invalid_method of method_not_object_safe_reason in - let rec check_no_self reason (ty : Syntax.typ) = - match ty with - | Ptype_name { constr_id; tys } -> - (match constr_id.lid with - | Lident "Self" -> raise_notrace (Invalid_method reason) - | _ -> ()); - List.iter (check_no_self reason) tys - | Ptype_tuple { tys } -> List.iter (check_no_self reason) tys - | Ptype_arrow { ty_arg; ty_res; ty_err } -> ( - List.iter (check_no_self reason) ty_arg; - check_no_self reason ty_res; - match ty_err with - | No_error_typ | Default_error_typ _ -> () - | Error_typ { ty = ty_err } -> check_no_self reason ty_err) - | Ptype_any _ -> () - | Ptype_option { ty; _ } -> check_no_self reason ty - in - try - Lst.iter ps (fun p -> check_no_self Multiple_self p.tmparam_typ); - (match return_type with - | None -> () - | Some (return_type, err_type) -> ( - check_no_self Self_in_return return_type; - match err_type with - | No_error_typ | Default_error_typ _ -> () - | Error_typ { ty = ty_err } -> - check_no_self Self_in_return ty_err)); - acc - with Invalid_method reason -> - Bad_method (name.binder_name, reason) :: acc) - | _ -> Bad_method (name.binder_name, First_param_not_self) :: acc) + (fun (Trait_method { name; params; return_type; _ }) -> + fun acc -> + match params with + | { + tmparam_typ = Ptype_name { constr_id = { lid = Lident "Self" }; _ }; + _; + } + :: ps -> ( + let exception Invalid_method of method_not_object_safe_reason in + let rec check_no_self reason (ty : Syntax.typ) = + match ty with + | Ptype_name { constr_id; tys } -> + (match constr_id.lid with + | Lident "Self" -> raise_notrace (Invalid_method reason) + | _ -> ()); + Basic_lst.iter tys ~f:(check_no_self reason) + | Ptype_tuple { tys } -> + Basic_lst.iter tys ~f:(check_no_self reason) + | Ptype_arrow { ty_arg; ty_res; ty_err; is_async } -> ( + assert (not is_async); + Basic_lst.iter ty_arg ~f:(check_no_self reason); + check_no_self reason ty_res; + match ty_err with + | No_error_typ | Default_error_typ _ -> () + | Error_typ { ty = ty_err } -> check_no_self reason ty_err) + | Ptype_any _ -> () + | Ptype_option { ty; _ } -> check_no_self reason ty + | Ptype_object _ -> () + in + try + Lst.iter ps ~f:(fun p -> check_no_self Multiple_self p.tmparam_typ); + (match return_type with + | None -> () + | Some (return_type, err_type) -> ( + check_no_self Self_in_return return_type; + match err_type with + | No_error_typ | Default_error_typ _ -> () + | Error_typ { ty = ty_err } -> + check_no_self Self_in_return ty_err)); + acc + with Invalid_method reason -> + Bad_method (name.binder_name, reason) :: acc) + | _ -> Bad_method (name.binder_name, First_param_not_self) :: acc) let check_object_safety ~name ~loc status = match status with | [] -> None | reasons -> Some (type_not_object_safe ~name ~reasons ~loc) -let find_method (decl : t) method_name ~loc : method_decl Local_diagnostics.info - = - match - Lst.find_first decl.methods (fun meth_decl -> - meth_decl.method_name = method_name) - with - | Some decl -> Ok decl - | None -> - Error - (Errors.method_not_found_in_trait ~trait:decl.name ~method_name ~loc) +let find_method (decl : t) method_name ~loc = + (match + Lst.find_first decl.methods (fun meth_decl -> + meth_decl.method_name = method_name) + with + | Some decl -> Ok decl + | None -> + Error + (Errors.method_not_found_in_trait ~trait:decl.name ~method_name ~loc) + : method_decl Local_diagnostics.info) diff --git a/src/trait_impl.ml b/src/trait_impl.ml index 129af54..848d87a 100644 --- a/src/trait_impl.ml +++ b/src/trait_impl.ml @@ -20,6 +20,8 @@ type impl = { self_ty : Stype.t; ty_params : Tvar_env.t; is_pub : bool; + is_implicit_ : bool; [@sexp_drop_if fun x -> not x] + doc_ : Docstring.t; loc_ : Loc.t; } @@ -27,17 +29,31 @@ include struct let _ = fun (_ : impl) -> () let sexp_of_impl = - (fun { + (let (drop_if__011_ : bool -> Stdlib.Bool.t) = fun x -> not x in + fun { trait = trait__002_; self_ty = self_ty__004_; ty_params = ty_params__006_; is_pub = is_pub__008_; - loc_ = loc___010_; + is_implicit_ = is_implicit___012_; + doc_ = doc___015_; + loc_ = loc___017_; } -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = - let arg__011_ = Loc.sexp_of_t loc___010_ in - (S.List [ S.Atom "loc_"; arg__011_ ] :: bnds__001_ : _ Stdlib.List.t) + let arg__018_ = Loc.sexp_of_t loc___017_ in + (S.List [ S.Atom "loc_"; arg__018_ ] :: bnds__001_ : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__016_ = Docstring.sexp_of_t doc___015_ in + (S.List [ S.Atom "doc_"; arg__016_ ] :: bnds__001_ : _ Stdlib.List.t) + in + let bnds__001_ = + if drop_if__011_ is_implicit___012_ then bnds__001_ + else + let arg__014_ = Moon_sexp_conv.sexp_of_bool is_implicit___012_ in + let bnd__013_ = S.List [ S.Atom "is_implicit_"; arg__014_ ] in + (bnd__013_ :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = let arg__009_ = Moon_sexp_conv.sexp_of_bool is_pub__008_ in @@ -68,21 +84,24 @@ module H = Basic_hashf.Make (struct include struct let sexp_of_t = - (fun (arg0__012_, arg1__013_) -> - let res0__014_ = Type_path.sexp_of_t arg0__012_ - and res1__015_ = Type_path.sexp_of_t arg1__013_ in - S.List [ res0__014_; res1__015_ ] + (fun (arg0__019_, arg1__020_) -> + let res0__021_ = Type_path.sexp_of_t arg0__019_ + and res1__022_ = Type_path.sexp_of_t arg1__020_ in + S.List [ res0__021_; res1__022_ ] : t -> S.t) let equal = - (fun a__016_ b__017_ -> - let t__018_, t__019_ = a__016_ in - let t__020_, t__021_ = b__017_ in - Stdlib.( && ) - (Type_path.equal t__018_ t__020_) - (Type_path.equal t__019_ t__021_) + (fun a__023_ -> + fun b__024_ -> + let t__025_, t__026_ = a__023_ in + let t__027_, t__028_ = b__024_ in + Stdlib.( && ) + (Type_path.equal t__025_ t__027_) + (Type_path.equal t__026_ t__028_) : t -> t -> bool) + let _ = equal + let hash_fold_t hsv (e0, e1) = let hsv = Type_path.hash_fold_t hsv e0 in let hsv = Type_path.hash_fold_t hsv e1 in @@ -100,7 +119,7 @@ type t = impl H.t include struct let _ = fun (_ : t) -> () - let sexp_of_t = (fun x__022_ -> H.sexp_of_t sexp_of_impl x__022_ : t -> S.t) + let sexp_of_t = (fun x__029_ -> H.sexp_of_t sexp_of_impl x__029_ : t -> S.t) let _ = sexp_of_t end @@ -114,7 +133,7 @@ let update (impls : t) ~trait ~type_name f = H.update_if_exists impls (trait, type_name) f let iter (impls : t) f = - H.iter2 impls (fun (trait, type_name) impl -> f ~trait ~type_name impl) + H.iter2 impls (fun (trait, type_name) -> fun impl -> f ~trait ~type_name impl) let get_pub_impls (impls : t) = H.to_array_filter_map impls (fun (_, impl) -> diff --git a/src/transl_match.ml b/src/transl_match.ml index e2c024c..e72fd1a 100644 --- a/src/transl_match.ml +++ b/src/transl_match.ml @@ -18,6 +18,25 @@ module Lst = Basic_lst module Arr = Basic_arr module Path = Pat_path module Db = Patmatch_db +module Type_path = Basic_type_path + +type case = { + pat : Typedtree.pat; + pat_binders : Typedtree.pat_binders; + action : Core.expr; + inline_action : bool; + guard : (true_case:Core.expr -> false_case:Core.expr -> Core.expr) option; + guard_binders : Typedtree.pat_binders; +} + +type arm_info = + | Joinpoint of { + arm_id : Ident.t; + pat_params : Core.param list; + guard_params : Core.param list; + action : Core.expr; + } + | Inline of { pat_params : Core.param list; action : Core.expr } let ghost_loc_ = Rloc.no_location @@ -31,109 +50,167 @@ type dotdot_info = } | Dotdot_no_binder -let make_constr_switch tag arg ~head ~ifso ~ifnot : Core.expr = - let new_case = (tag, arg, ifso) in - let cases, default = - match (ifnot : Core.expr option) with - | Some (Cexpr_switch_constr { obj; cases; default; ty = _ }) - when Basic_prelude.phys_equal obj head -> - (new_case :: cases, default) - | _ -> ([ new_case ], ifnot) +let calculate_char_paths (pats : Typedtree.pat list) ~rev = + let normal_field i = + if rev then Path.Last_field i else Path.Field i + [@@inline] + in + let rec go_normal pats i = + match pats with + | [] -> [] + | pat :: rest -> (pat, normal_field i) :: go_normal rest (i + 1) in - Core.switch_constr ~default head cases + let rec go (pats : Typedtree.pat list) cu_idx idx = + match pats with + | [] -> [] + | pat :: rest -> ( + match pat with + | Tpat_constant { c = C_char c; _ } + | Tpat_alias { pat = Tpat_constant { c = C_char c; _ }; _ } -> + if Uchar.to_int c > 0xFFFF then + (pat, normal_field idx) :: go rest (cu_idx + 2) (idx + 1) + else + (pat, Path.Codeunit_field { index = cu_idx; rev }) + :: go rest (cu_idx + 1) (idx + 1) + | Tpat_range + { + lhs = Tpat_constant { c = C_char c1; _ }; + rhs = Tpat_constant { c = C_char c2; _ }; + _; + } + | Tpat_alias + { + pat = + Tpat_range + { + lhs = Tpat_constant { c = C_char c1; _ }; + rhs = Tpat_constant { c = C_char c2; _ }; + _; + }; + _; + } -> + if Uchar.to_int c1 > 0xFFFF || Uchar.to_int c2 > 0xFFFF then + (pat, normal_field idx) :: go_normal rest (idx + 1) + else + (pat, Path.Codeunit_field { index = cu_idx; rev }) + :: go rest (cu_idx + 1) (idx + 1) + | _ -> (pat, normal_field idx) :: go_normal rest idx) + in + if rev then List.rev (go (List.rev pats) 0 0) else go pats 0 0 -let make_constant_switch ~global_env c ~head ~ifso ~ifnot : Core.expr = - match Core.type_of_expr head with - | ty when Type.same_type ty Stype.bigint -> - let constant = - let str = - match c with - | Constant.C_bigint { v; _ } -> - Constant.C_string (Basic_bigint.to_string v) - | _ -> assert false - in - match[@warning "-fragile-match"] - Global_env.find_dot_method global_env - ~type_name:Basic_type_path.Builtin.type_path_bigint - ~method_name:"from_string" - with - | method_info :: [] -> - Core.apply ~loc:Rloc.no_location - ~kind:(Normal { func_ty = method_info.typ }) - ~ty:Stype.bigint - (Basic_core_ident.of_qual_ident method_info.id) - [ Core.const str ] - | _ -> assert false - in - let cond = - match[@warning "-fragile-match"] - Global_env.find_dot_method global_env - ~type_name:Basic_type_path.Builtin.type_path_bigint - ~method_name:"op_equal" - with - | method_info :: [] -> - let id = Basic_core_ident.of_qual_ident method_info.id in - Core.apply ~loc:Rloc.no_location - ~kind:(Normal { func_ty = method_info.typ }) - ~ty:Stype.bool id [ head; constant ] - | _ -> assert false - in - Core.if_ cond ~ifso ~ifnot - | _ -> - let new_case = (c, ifso) in - let cases, default = - match (ifnot : Core.expr) with - | Cexpr_switch_constant { obj; cases; default; ty = _ } - when Basic_prelude.phys_equal obj head -> - (new_case :: cases, default) - | _ -> ([ new_case ], ifnot) - in - Core.switch_constant ~default head cases +let make_constr_switch tag arg ~head ~ifso ~ifnot = + (let new_case = (tag, arg, ifso) in + let cases, default = + match (ifnot : Core.expr option) with + | Some (Cexpr_switch_constr { obj; cases; default; ty = _ }) + when Basic_prelude.phys_equal obj head -> + (new_case :: cases, default) + | _ -> ([ new_case ], ifnot) + in + Core.switch_constr ~default head cases + : Core.expr) + +let is_string (ty : Stype.t) = + match Stype.type_repr ty with T_builtin T_string -> true | _ -> false + +let make_constant_switch ~global_env c ~head ~ifso ~ifnot = + (match Core.type_of_expr head with + | ty when Type.same_type ty Stype.bigint -> + let constant = + let str = + match c with + | Constant.C_bigint { v; _ } -> + Constant.C_string (Basic_bigint.to_string v) + | _ -> assert false + in + match[@warning "-fragile-match"] + Global_env.find_dot_method global_env + ~type_name:Basic_type_path.Builtin.type_path_bigint + ~method_name:"from_string" + with + | method_info :: [] -> + Core.apply ~loc:Rloc.no_location + ~kind:(Normal { func_ty = method_info.typ }) + ~ty:Stype.bigint + (Basic_core_ident.of_qual_ident method_info.id) + [ Core.const str ] + | _ -> assert false + in + let cond = + match[@warning "-fragile-match"] + Global_env.find_dot_method global_env + ~type_name:Basic_type_path.Builtin.type_path_bigint + ~method_name:"op_equal" + with + | method_info :: [] -> + let id = Basic_core_ident.of_qual_ident method_info.id in + Core.apply ~loc:Rloc.no_location + ~kind:(Normal { func_ty = method_info.typ }) + ~ty:Stype.bool id [ head; constant ] + | _ -> assert false + in + Core.if_ cond ~ifso ~ifnot + | _ -> + let new_case = (c, ifso) in + let cases, default = + match (ifnot : Core.expr) with + | Cexpr_switch_constant { obj; cases; default; ty = _ } + when Basic_prelude.phys_equal obj head -> + (new_case :: cases, default) + | _ -> ([ new_case ], ifnot) + in + Core.switch_constant ~default head cases + : Core.expr) let make_range_if obj lo hi ~inclusive ~ifso ~ifnot = - let constant_to_operand_type (c : Constant.t) : Primitive.operand_type = - match c with - | C_int _ | C_char _ -> I32 - | C_uint _ -> U32 - | C_int64 _ -> I64 - | C_uint64 _ -> U64 - | C_float _ -> F32 - | C_double _ -> F64 - | C_bool _ | C_string _ | C_bytes _ | C_bigint _ -> assert false + let constant_to_operand_type (c : Constant.t) = + (match c with + | C_int _ | C_char _ | C_byte _ -> I32 + | C_uint _ -> U32 + | C_int64 _ -> I64 + | C_uint64 _ -> U64 + | C_float _ -> F32 + | C_double _ -> F64 + | C_bytes _ -> assert false + | C_bool _ -> assert false + | C_string _ -> assert false + | C_bigint _ -> assert false + : Primitive.operand_type) in let lo_satisfied = match lo with | None -> None | Some lo -> - Core.prim ~ty:Stype.bool - (Pcomparison - { operand_type = constant_to_operand_type lo; operator = Le }) - [ Core.const lo; obj ] - |> Option.some + Some + (Core.prim ~ty:Stype.bool + (Pcomparison + { operand_type = constant_to_operand_type lo; operator = Le }) + [ Core.const lo; obj ]) in let hi_satisfied = match hi with | None -> None | Some hi -> let operator : Primitive.comparison = if inclusive then Le else Lt in - Core.prim ~ty:Stype.bool - (Pcomparison { operand_type = constant_to_operand_type hi; operator }) - [ obj; Core.const hi ] - |> Option.some + Some + (Core.prim ~ty:Stype.bool + (Pcomparison + { operand_type = constant_to_operand_type hi; operator }) + [ obj; Core.const hi ]) in let predicate = match (lo_satisfied, hi_satisfied) with | None, None -> assert false | Some pred, None | None, Some pred -> pred | Some lo_satisfied, Some hi_satisfied -> - Core.prim ~ty:Stype.bool Psequand [ lo_satisfied; hi_satisfied ] + Core.and_ ~loc:Rloc.no_location lo_satisfied hi_satisfied in Core.if_ predicate ~ifso ~ifnot type bindings = (Ident.t * Path.t) list type transl_context = { db : Db.t; path_cache : path_value Path.Map.t } -and path_value = { expr : Core.expr; mutable used : bool } +and path_value = { expr : Core.expr; mutable used : bool; expr_id : Ident.t } let set_db ctx db = { ctx with db } [@@inline] @@ -143,18 +220,24 @@ let expr_of_path ctx path = value.expr [@@inline] -let add_path ?(name_hint = "*x") ctx path ~ty : - Core.binder * path_value * transl_context = - let id = Ident.fresh name_hint in - let expr : Core.expr = Core.var ~ty id in - let value = { expr; used = false } in - (id, value, { ctx with path_cache = Path.Map.add ctx.path_cache path value }) +let add_path ?(name_hint = "*x") ctx path ~ty = + (let id = Ident.fresh name_hint in + let expr : Core.expr = Core.var ~ty id in + let value = { expr; used = false; expr_id = id } in + (id, value, { ctx with path_cache = Path.Map.add ctx.path_cache path value }) + : Core.binder * path_value * transl_context) -let add_path_and_insert_let_if_necessary ctx path ~ty ~(rhs : unit -> Core.expr) - ~(body : transl_context -> Core.expr) = +let add_path_and_insert_let_if_necessary ?(pat : Typedtree.pat option) ctx path + ~ty ~(rhs : unit -> Core.expr) ~(body : transl_context -> Core.expr) = if Path.Map.mem ctx.path_cache path then body ctx else - let binder, value, ctx = add_path ctx path ~ty in + let name_hint = + match pat with + | Some (Tpat_var { binder; _ }) -> + Some ("*" ^ Basic_ident.base_name binder.binder_id) + | _ -> None + in + let binder, value, ctx = add_path ?name_hint ctx path ~ty in let body = body ctx in if value.used then let rhs = rhs () in @@ -174,7 +257,12 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) | Tpat_alias { pat; alias; _ } -> let target_path : Path.t = match pat with - | Tpat_constr { tag = Constr_tag_regular { index; total = _ }; _ } -> + | Tpat_constr + { + tag = + Constr_tag_regular { index; repr_ = Non_constant; total = _ }; + _; + } -> Casted_constr { tag_index = index } :: path | Tpat_constr { tag = Extensible_tag tag; _ } -> Casted_constr { tag_index = tag.index } :: path @@ -189,10 +277,15 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) process_pat ~global_env ~ctx ~bindings ~path ~pat:pat2 ~ok_cont ~fail_cont) | Tpat_constant { c; _ } -> ( - let r = Db.eval_constant ctx.db path c in + let r = + match c with + | C_string str -> + Db.eval_string_constant ctx.db path str ~check_match:false + | _ -> Db.eval_constant ctx.db path c + in match r with - | For_sure_yes r -> ok_cont (set_db ctx r.ok_db) bindings - | For_sure_no r -> fail_cont (set_db ctx r.fail_db) + | For_sure_yes -> ok_cont ctx bindings + | For_sure_no -> fail_cont ctx | Uncertain r -> let head = expr_of_path ctx path in let ifso = ok_cont (set_db ctx r.ok_db) bindings in @@ -212,8 +305,8 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) | _ -> assert false in match Db.eval_range ctx.db path lo hi ~inclusive with - | For_sure_yes r -> ok_cont (set_db ctx r.ok_db) bindings - | For_sure_no r -> fail_cont (set_db ctx r.fail_db) + | For_sure_yes -> ok_cont ctx bindings + | For_sure_no -> fail_cont ctx | Uncertain r -> let head = expr_of_path ctx path in let ifso = ok_cont (set_db ctx r.ok_db) bindings in @@ -233,10 +326,12 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) in let body ctx = process_pat ~global_env ~ctx ~bindings ~path:this_path ~pat - ~ok_cont:(fun ctx bindings -> go ctx bindings pats (index + 1)) + ~ok_cont:(fun ctx -> + fun bindings -> go ctx bindings pats (index + 1)) ~fail_cont in - add_path_and_insert_let_if_necessary ctx this_path ~ty ~rhs ~body + add_path_and_insert_let_if_necessary ~pat ctx this_path ~ty ~rhs + ~body in go ctx bindings pats 0 | Tpat_record { fields = field_pats; _ } -> @@ -250,13 +345,16 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) let rhs () = Core.field ~pos ~ty head (Label label) in let body ctx = process_pat ~global_env ~ctx ~bindings ~path:this_path ~pat - ~ok_cont:(fun ctx bindings -> go ctx bindings fields) + ~ok_cont:(fun ctx -> fun bindings -> go ctx bindings fields) ~fail_cont in - add_path_and_insert_let_if_necessary ctx this_path ~ty ~rhs ~body + add_path_and_insert_let_if_necessary ~pat ctx this_path ~ty ~rhs + ~body in go ctx bindings field_pats - | Tpat_constr { constr; tag; args; ty; used_error_subtyping } -> ( + | Tpat_constr + { constr; tag; args; ty; used_error_subtyping; all_args_; type_name = _ } + -> ( let tag_index = match tag with | Constr_tag_regular { total = _; index } -> index @@ -296,111 +394,199 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) process_pat ~global_env ~ctx ~bindings ~path:this_path ~pat ~ok_cont ~fail_cont in - add_path_and_insert_let_if_necessary ctx this_path ~ty ~rhs ~body) + add_path_and_insert_let_if_necessary ~pat ctx this_path ~ty ~rhs + ~body) | None -> ( let head = expr_of_path ctx path in let go ctx (args : Typedtree.constr_pat_arg list) ~must_destruct ~ifnot = - match[@warning "-fragile-match"] - Result.get_ok - (Global_env.resolve_constr_or_constant global_env - ~expect_ty:(Some ty) ~constr ~creating_value:false) - with - | `Constr constr_desc -> ( - if constr_desc.cs_args = [] then - let ctx = redirect_casted_path ctx in - let ifso = ok_cont ctx bindings in - if must_destruct then - make_constr_switch tag None ~head ~ifso ~ifnot - else ifso - else - let casted_path : Path.t = - Casted_constr { tag_index } :: path - in - let constr_binder, constr_value, ctx = - match Path.Map.find_opt ctx.path_cache casted_path with - | None -> - let b, v, ctx = - add_path - ~name_hint:("*" ^ constr.constr_name.name) - ctx casted_path - ~ty:(Type.make_constr_type ty ~tag) - in - (Some b, v, ctx) - | Some constr_value -> (None, constr_value, ctx) - in - let rec go ctx bindings (args : Typedtree.constr_pat_arg list) - = - match args with - | [] -> ok_cont ctx bindings - | Constr_pat_arg { pat; pos; _ } :: args -> - let path_item : Path.access = - if used_error_subtyping then - Error_constr_field { tag; arg_index = pos } - else Constr_field { tag_index; arg_index = pos } - in - let path = path_item :: path in - let arg_ty = Typedtree_util.type_of_pat pat in - add_path_and_insert_let_if_necessary ctx path ~ty:arg_ty - ~rhs:(fun () -> - constr_value.used <- true; - Core.prim ~ty:arg_ty - (Penum_field { index = pos; tag }) - [ constr_value.expr ]) - ~body:(fun ctx -> - process_pat ~global_env ~ctx ~bindings ~pat ~path - ~fail_cont ~ok_cont:(fun ctx bindings -> - go ctx bindings args)) - in - let ifso = go ctx bindings args in - match constr_binder with - | Some _ when constr_value.used -> - make_constr_switch tag constr_binder ~head ~ifso ~ifnot - | _ when must_destruct -> - make_constr_switch tag None ~head ~ifso ~ifnot - | _ -> ifso) - | _ -> assert false + if all_args_ = [] then + let ctx = redirect_casted_path ctx in + let ifso = ok_cont ctx bindings in + if must_destruct then + make_constr_switch tag None ~head ~ifso ~ifnot + else ifso + else + let casted_path : Path.t = Casted_constr { tag_index } :: path in + let constr_binder, constr_value, ctx = + match Path.Map.find_opt ctx.path_cache casted_path with + | None -> + let b, v, ctx = + add_path ~name_hint:("*" ^ constr.name) ctx casted_path + ~ty:(Type.make_constr_type ty ~tag) + in + (Some b, v, ctx) + | Some constr_value -> (None, constr_value, ctx) + in + let rec go ctx bindings (args : Typedtree.constr_pat_arg list) = + match args with + | [] -> ok_cont ctx bindings + | Constr_pat_arg { pat; pos; _ } :: args -> + let path_item : Path.access = + if used_error_subtyping then + Error_constr_field { tag; arg_index = pos } + else Constr_field { tag_index; arg_index = pos } + in + let path = path_item :: path in + let arg_ty = Typedtree_util.type_of_pat pat in + add_path_and_insert_let_if_necessary ~pat ctx path + ~ty:arg_ty + ~rhs:(fun () -> + constr_value.used <- true; + Core.prim ~ty:arg_ty + (Penum_field { index = pos; tag }) + [ constr_value.expr ]) + ~body:(fun ctx -> + process_pat ~global_env ~ctx ~bindings ~pat ~path + ~fail_cont ~ok_cont:(fun ctx -> + fun bindings -> go ctx bindings args)) + in + let ifso = go ctx bindings args in + match constr_binder with + | Some _ when constr_value.used -> + make_constr_switch tag constr_binder ~head ~ifso ~ifnot + | _ when must_destruct -> + make_constr_switch tag None ~head ~ifso ~ifnot + | _ -> ifso in let r = Db.eval_constructor ctx.db path tag ~used_error_subtyping in - if Typeutil.is_only_tag_enum ty then - let ok_cont ctx bindings = - ok_cont (redirect_casted_path ctx) bindings + match tag with + | Constr_tag_regular { repr_ = Integer value; _ } -> ( + let ok_cont ctx bindings = + ok_cont (redirect_casted_path ctx) bindings + in + match r with + | For_sure_yes -> ok_cont ctx bindings + | For_sure_no -> fail_cont ctx + | Uncertain r -> + let head = expr_of_path ctx path in + let ifso = ok_cont (set_db ctx r.ok_db) bindings in + let ifnot = fail_cont (set_db ctx r.fail_db) in + let c = + Constant.C_int { v = Int32.of_int value; repr = None } + in + make_constant_switch ~global_env c ~head ~ifso ~ifnot) + | _ -> ( + match r with + | For_sure_yes -> go ctx args ~must_destruct:false ~ifnot:None + | For_sure_no -> fail_cont ctx + | Uncertain r -> + let ifnot = Some (fail_cont (set_db ctx r.fail_db)) in + go (set_db ctx r.ok_db) args ~must_destruct:true ~ifnot))) + | Tpat_array { pats; ty } when is_string ty -> ( + let dotdot_binder, pats_with_path, num_pats = + match pats with + | Closed pats -> + let pat_paths = calculate_char_paths pats ~rev:false in + (No_dotdot, pat_paths, List.length pats) + | Open (pats1, pats2, dotdot_binder) -> + let len1 = List.length pats1 in + let len2 = List.length pats2 in + let pats2 = calculate_char_paths pats2 ~rev:true in + let dotdot_binder = + match dotdot_binder with + | Some (binder, binder_ty) -> + Dotdot_with_binder + { + binder; + len_pats1 = List.length pats1; + len_pats2 = List.length pats2; + binder_ty; + } + | None -> Dotdot_no_binder in - match r with - | For_sure_yes r -> ok_cont (set_db ctx r.ok_db) bindings - | For_sure_no r -> fail_cont (set_db ctx r.fail_db) - | Uncertain r -> - let head = expr_of_path ctx path in - let ifso = ok_cont (set_db ctx r.ok_db) bindings in - let ifnot = fail_cont (set_db ctx r.fail_db) in - let tag = - match tag with - | Constr_tag_regular { index = tag; _ } -> tag - | Extensible_tag _ -> assert false + ( dotdot_binder, + calculate_char_paths pats1 ~rev:false @ pats2, + len1 + len2 ) + in + let head = expr_of_path ctx path in + let rec go ctx bindings pats = + match pats with + | [] -> ( + match dotdot_binder with + | Dotdot_no_binder | No_dotdot -> ok_cont ctx bindings + | Dotdot_with_binder { binder = b; len_pats1; len_pats2; binder_ty } + -> + let rhs () = + Core_util.make_op_as_view global_env head len_pats1 len_pats2 + in + let this_path = Path.Field_slice :: path in + let body ctx = + ok_cont ctx + ((Ident.of_ident b.binder_id, this_path) :: bindings) in - let c = Constant.C_int { v = Int32.of_int tag; repr = None } in - make_constant_switch ~global_env c ~head ~ifso ~ifnot - else - match r with - | For_sure_yes r -> - go (set_db ctx r.ok_db) args ~must_destruct:false ~ifnot:None - | For_sure_no r -> fail_cont (set_db ctx r.fail_db) - | Uncertain r -> - let ifnot = Some (fail_cont (set_db ctx r.fail_db)) in - go (set_db ctx r.ok_db) args ~must_destruct:true ~ifnot)) + add_path_and_insert_let_if_necessary ctx this_path ~ty:binder_ty + ~rhs ~body) + | (pat, field) :: pats -> + let rhs = + match field with + | Path.Field i -> + fun () -> Core_util.make_op_get global_env head i ~rev:false + | Last_field i -> + fun () -> Core_util.make_op_get global_env head i ~rev:true + | Codeunit_field { index; rev } -> + fun () -> Core_util.make_string_codeunit_get head index ~rev + | _ -> assert false + in + let this_path = field :: path in + let ty = Typedtree_util.type_of_pat pat in + let body ctx = + process_pat ~global_env ~ctx ~bindings ~path:this_path ~pat + ~ok_cont:(fun ctx -> fun bindings -> go ctx bindings pats) + ~fail_cont + in + add_path_and_insert_let_if_necessary ~pat ctx this_path ~ty ~rhs + ~body + in + let default () = + let r = + if dotdot_binder = No_dotdot then + Db.eval_eq_array_len_string ctx.db path num_pats + else Db.eval_geq_array_len_string ctx.db path num_pats + in + match r with + | For_sure_yes -> go ctx bindings pats_with_path + | For_sure_no -> fail_cont ctx + | Uncertain r -> + let ifso = go (set_db ctx r.ok_db) bindings pats_with_path in + let ifnot = fail_cont (set_db ctx r.fail_db) in + Core_util.make_length_test global_env head num_pats + ~kind:(if dotdot_binder = No_dotdot then `Eq else `Geq) + ~ifso ~ifnot + [@@local] + in + match Check_match.try_combine_array_pat_to_string pats with + | Some str -> ( + match Db.eval_string_constant ctx.db path str ~check_match:true with + | For_sure_yes -> ok_cont ctx bindings + | For_sure_no -> fail_cont ctx + | Uncertain r -> + let head = expr_of_path ctx path in + let ifso = ok_cont (set_db ctx r.ok_db) bindings in + let ifnot = fail_cont (set_db ctx r.fail_db) in + make_constant_switch ~global_env (Constant.C_string str) ~head + ~ifso ~ifnot) + | None -> ( + let op = if dotdot_binder = No_dotdot then `Eq else `Ge in + match + Db.eval_entire_array_pat_string ctx.db path pats_with_path op + num_pats + with + | For_sure_no -> fail_cont ctx + | Uncertain -> default ())) | Tpat_array { pats; _ } -> ( let dotdot_binder, pats_with_path, num_pats = match pats with | Closed pats -> ( No_dotdot, - Lst.mapi pats (fun i pat -> (pat, Path.Field i)), + Lst.mapi pats (fun i -> fun pat -> (pat, Path.Field i)), List.length pats ) | Open (pats1, pats2, dotdot_binder) -> let len1 = List.length pats1 in let len2 = List.length pats2 in let pats2 = - Lst.mapi pats2 (fun i pat -> - (pat, Path.Last_field (len2 - 1 - i))) + Lst.mapi pats2 (fun i -> + fun pat -> (pat, Path.Last_field (len2 - 1 - i))) in let dotdot_binder = match dotdot_binder with @@ -415,7 +601,9 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) | None -> Dotdot_no_binder in ( dotdot_binder, - Lst.mapi_append pats1 (fun i pat -> (pat, Path.Field i)) pats2, + Lst.mapi_append pats1 + (fun i -> fun pat -> (pat, Path.Field i)) + pats2, len1 + len2 ) in let head = expr_of_path ctx path in @@ -448,168 +636,261 @@ let rec process_pat ~(global_env : Global_env.t) ~(ctx : transl_context) let rhs () = Core_util.make_op_get global_env head index ~rev in let body ctx = process_pat ~global_env ~ctx ~bindings ~path:this_path ~pat - ~ok_cont:(fun ctx bindings -> go ctx bindings pats) + ~ok_cont:(fun ctx -> fun bindings -> go ctx bindings pats) ~fail_cont in - add_path_and_insert_let_if_necessary ctx this_path ~ty ~rhs ~body + add_path_and_insert_let_if_necessary ~pat ctx this_path ~ty ~rhs + ~body in - let r = - if dotdot_binder = No_dotdot then - Db.eval_eq_array_len ctx.db path num_pats - else Db.eval_geq_array_len ctx.db path num_pats + let default () = + let r = + if dotdot_binder = No_dotdot then + Db.eval_eq_array_len ctx.db path num_pats + else Db.eval_geq_array_len ctx.db path num_pats + in + match r with + | For_sure_yes -> go ctx bindings pats_with_path + | For_sure_no -> fail_cont ctx + | Uncertain r -> + let ifso = go (set_db ctx r.ok_db) bindings pats_with_path in + let ifnot = fail_cont (set_db ctx r.fail_db) in + Core_util.make_length_test global_env head num_pats + ~kind:(if dotdot_binder = No_dotdot then `Eq else `Geq) + ~ifso ~ifnot + [@@local] in - match r with - | For_sure_yes r -> go (set_db ctx r.ok_db) bindings pats_with_path - | For_sure_no r -> fail_cont (set_db ctx r.fail_db) - | Uncertain r -> - let ifso = go (set_db ctx r.ok_db) bindings pats_with_path in - let ifnot = fail_cont (set_db ctx r.fail_db) in - let arr_len_expr = Core_util.make_length global_env head in - let num_pats_expr = - Core.const (C_int { v = Int32.of_int num_pats; repr = None }) - in - let test_expr = - let prim = - if dotdot_binder = No_dotdot then Primitive.equal_int - else Primitive.ge_int - in - Core.prim prim [ arr_len_expr; num_pats_expr ] ~ty:Stype.bool - in - Core.if_ test_expr ~ifso ~ifnot) + match Core.type_of_expr head with + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_stringview -> ( + let op = if dotdot_binder = No_dotdot then `Eq else `Ge in + match + Db.eval_entire_array_pat ctx.db path pats_with_path op num_pats + with + | For_sure_no -> fail_cont ctx + | Uncertain -> default ()) + | _ -> default ()) | Tpat_map - { elems; op_get_info_ = op_get_id, op_get_ty, op_get_ty_args; ty = _ } -> - let ty_op_get_result = - match Stype.type_repr op_get_ty with - | Tarrow { params_ty = _; ret_ty; err_ty = _ } -> ret_ty - | _ -> assert false - in - let rec go ctx bindings elems = - match elems with - | [] -> ok_cont ctx bindings - | (key, pat) :: elems -> - let elem_path : Path.t = Map_elem { key } :: path in - let rhs () = - Core.apply ~ty:ty_op_get_result ~ty_args_:op_get_ty_args - ~kind:(Normal { func_ty = op_get_ty }) - (Ident.of_ident op_get_id) - [ expr_of_path ctx path; Core.const key ] - in - add_path_and_insert_let_if_necessary - (set_db ctx - (Db.eval_map_elem ctx.db path key ~elem_ty:ty_op_get_result)) - elem_path ~ty:ty_op_get_result ~rhs - ~body:(fun ctx -> - process_pat ~global_env ~ctx ~bindings ~path:elem_path ~pat - ~ok_cont:(fun ctx bindings -> go ctx bindings elems) - ~fail_cont) - in - go ctx bindings elems + { elems; op_get_info_ = op_get_id, op_get_ty, op_get_ty_args; ty = _ } + -> ( + match[@warning "-fragile-match"] Stype.type_repr op_get_ty with + | Tarrow { ret_ty = ty_op_get_result; _ } -> + let rec go ctx bindings elems = + match elems with + | [] -> ok_cont ctx bindings + | (key, pat) :: elems -> + let elem_path : Path.t = Map_elem { key } :: path in + let rhs () = + Core.apply ~ty:ty_op_get_result ~ty_args_:op_get_ty_args + ~kind:(Normal { func_ty = op_get_ty }) + (Ident.of_ident op_get_id) + [ expr_of_path ctx path; Core.const key ] + in + add_path_and_insert_let_if_necessary + (set_db ctx + (Db.eval_map_elem ctx.db path key ~elem_ty:ty_op_get_result)) + elem_path ~pat ~ty:ty_op_get_result ~rhs + ~body:(fun ctx -> + process_pat ~global_env ~ctx ~bindings ~path:elem_path ~pat + ~ok_cont:(fun ctx -> + fun bindings -> go ctx bindings elems) + ~fail_cont) + in + go ctx bindings elems + | _ -> assert false) let transl_match ~(global_env : Global_env.t) (head : Core.expr) - (cases : (Typedtree.pat * Typedtree.pat_binders * Core.expr) list) - ~(ty : Stype.t) ~(loc : Rloc.t) : Core.expr = - let arm_fns : (Ident.t * Core.param list * Core.expr) array = - Arr.of_list_map cases (fun (_, pat_binders, action) -> - let params = - Lst.map pat_binders (fun { binder; binder_typ } : Core.param -> - { - binder = Ident.of_ident binder.binder_id; - ty = binder_typ; - loc_ = binder.loc_; - }) - in - (Ident.fresh "*arm", params, action)) - in - let rec process_cases ctx - (cases : (Typedtree.pat * Typedtree.pat_binders * Core.expr) list) - (index : int) : Core.expr = - match cases with - | [] -> Core.raise ~ty "match_failure" - | (pat, _, action) :: cases -> - let ok_cont ctx bindings : Core.expr = - let binding_table = Ident.Hash.of_list bindings in - let arm_id, params, _ = arm_fns.(index) in - let args = - Lst.map params (fun { binder; ty = _ } -> - let path = Ident.Hash.find_exn binding_table binder in - expr_of_path ctx path) + (cases : case list) ~(ty : Stype.t) ~(loc : Rloc.t) = + (let arm_fns : arm_info array = + let mk_param ({ binder; binder_typ } : Typedtree.pat_binder) = + ({ + binder = Ident.of_ident binder.binder_id; + ty = binder_typ; + loc_ = binder.loc_; + } + : Core.param) + in + Arr.of_list_map cases + (fun + { + pat = _; + pat_binders; + action; + guard = _; + guard_binders; + inline_action; + } + -> + let pat_params = Lst.map pat_binders mk_param in + if inline_action then Inline { action; pat_params } + else + let guard_params = Lst.map guard_binders mk_param in + Joinpoint + { arm_id = Ident.fresh "*arm"; pat_params; guard_params; action }) + in + let rec process_cases ctx (cases : case list) (index : int) = + (match cases with + | [] -> Core.panic ty + | { + pat; + action; + guard; + pat_binders = _; + guard_binders = _; + inline_action = _; + } + :: cases -> + let ok_cont ctx bindings = + (let binding_table = Ident.Hash.of_list bindings in + match arm_fns.(index) with + | Joinpoint { arm_id; pat_params; guard_params; action = _ } -> ( + let pat_args = + Lst.map pat_params (fun { binder; ty = _ } -> + let path = Ident.Hash.find_exn binding_table binder in + expr_of_path ctx path) + in + let ty = Core.type_of_expr action in + match guard with + | None -> Core.join_apply arm_id pat_args ~ty + | Some guard -> + let guard_args = + Lst.map guard_params (fun { binder; ty } -> + Core.var ~ty binder) + in + let true_case = + Core.join_apply arm_id (pat_args @ guard_args) ~ty + in + let false_case = process_cases ctx cases (index + 1) in + let guard_body = guard ~true_case ~false_case in + let subst = Ident.Hash.create 7 in + Lst.iter pat_params ~f:(fun { binder; ty = _ } -> + let path = Ident.Hash.find_exn binding_table binder in + let id = + (Path.Map.find_exn ctx.path_cache path).expr_id + in + Ident.Hash.add subst binder id); + Core_util.substitute ~subst guard_body) + | Inline { pat_params; action } -> + if pat_params = [] then action + else + let subst = Ident.Hash.create 7 in + Lst.iter pat_params ~f:(fun { binder; ty = _ } -> + let path = Ident.Hash.find_exn binding_table binder in + let value = Path.Map.find_exn ctx.path_cache path in + value.used <- true; + let id = value.expr_id in + Ident.Hash.add subst binder id); + Core_util.substitute ~subst action + : Core.expr) in - let ty = Core.type_of_expr action in - Core.join_apply arm_id args ~ty - in - let fail_cont ctx = process_cases ctx cases (index + 1) in - process_pat ~global_env ~ctx ~bindings:[] ~path:[] ~pat ~ok_cont - ~fail_cont - in - let main_code = - match head with - | Cexpr_tuple { exprs; ty; loc_ } -> - let rec bind_exprs ctx index acc exprs = - match exprs with - | [] -> - add_path_and_insert_let_if_necessary ctx [] ~ty - ~rhs:(fun () -> Core.tuple ~loc:loc_ ~ty (List.rev acc)) - ~body:(fun ctx -> process_cases ctx cases 0) - | expr0 :: exprs -> - let ty0 = Core.type_of_expr expr0 in - Core.bind expr0 (fun expr_id -> - let expr0 = Core.var ~ty:ty0 expr_id in - let ctx = - { - ctx with - path_cache = - Path.Map.add ctx.path_cache [ Field index ] - { expr = expr0; used = false }; - } - in - bind_exprs ctx (index + 1) (expr0 :: acc) exprs) - in - bind_exprs { db = Db.empty; path_cache = Path.Map.empty } 0 [] exprs - | _ -> - let head_ty = Core.type_of_expr head in - Core.bind ~loc head (fun head_id -> - let expr = Core.var ~ty:head_ty head_id in - let ctx = - { - db = Db.empty; - path_cache = Path.Map.singleton [] { expr; used = false }; - } - in - process_cases ctx cases 0) - in - Arr.fold_left arm_fns main_code (fun body (id, params, join_body) -> - Core.joinlet_tail id params join_body body) - |> Core.update_expr_loc ~loc + let fail_cont ctx = process_cases ctx cases (index + 1) in + process_pat ~global_env ~ctx ~bindings:[] ~path:[] ~pat ~ok_cont + ~fail_cont + : Core.expr) + in + let main_code = + match head with + | Cexpr_tuple { exprs; ty; loc_ } -> + let rec bind_exprs ctx index acc exprs = + match exprs with + | [] -> + add_path_and_insert_let_if_necessary ctx [] ~ty + ~rhs:(fun () -> Core.tuple ~loc:loc_ ~ty (List.rev acc)) + ~body:(fun ctx -> process_cases ctx cases 0) + | expr0 :: exprs -> + let ty0 = Core.type_of_expr expr0 in + Core.bind expr0 (fun expr_id -> + let expr0 = Core.var ~ty:ty0 expr_id in + let ctx = + { + ctx with + path_cache = + Path.Map.add ctx.path_cache [ Field index ] + { expr = expr0; used = false; expr_id }; + } + in + bind_exprs ctx (index + 1) (expr0 :: acc) exprs) + in + bind_exprs { db = Db.empty; path_cache = Path.Map.empty } 0 [] exprs + | _ -> + let head_ty = Core.type_of_expr head in + Core.bind ~loc head (fun head_id -> + let expr = Core.var ~ty:head_ty head_id in + let ctx = + { + db = Db.empty; + path_cache = + Path.Map.singleton [] + { expr; used = false; expr_id = head_id }; + } + in + process_cases ctx cases 0) + in + Core.update_expr_loc ~loc + (Arr.fold_left arm_fns main_code (fun body -> + fun arm -> + match arm with + | Joinpoint { arm_id; pat_params; guard_params; action = join_body } + -> + Core.joinlet_tail arm_id + (pat_params @ guard_params) + join_body body + | Inline _ -> body)) + : Core.expr) let rec transl_let ~(global_env : Global_env.t) (pat : Typedtree.pat) ~(pat_binders : Typedtree.pat_binders) (rhs : Core.expr) (body : Core.expr) - ~ty ~loc : Core.expr = - match pat with - | Tpat_var { binder; _ } -> - Core.let_ ~loc (Ident.of_ident binder.binder_id) rhs body - | Tpat_any _ -> Core.sequence ~loc rhs body - | Tpat_constraint { pat; _ } -> - transl_let ~global_env pat ~pat_binders rhs body ~loc ~ty - | Tpat_tuple { pats; _ } -> ( - let exception Cannot_simplify in - let rec pat_to_param (pat : Typedtree.pat) : Core.param = - match pat with - | Tpat_var { binder; ty; loc_ } -> - let binder = Ident.of_ident binder.binder_id in - { binder; ty; loc_ } - | Tpat_constraint { pat; _ } -> pat_to_param pat - | _ -> raise_notrace Cannot_simplify - in - match Lst.map pats pat_to_param with - | exception Cannot_simplify -> - transl_match ~global_env rhs [ (pat, pat_binders, body) ] ~loc ~ty - | params -> - let join = Ident.fresh "*join" in - let ty_body = Core.type_of_expr body in - let join_body = body in - Core.tuple_map rhs - ~ok:(fun body -> Core.joinlet_tail ~loc join params join_body body) - ~err:(fun _ -> - transl_match ~global_env rhs [ (pat, pat_binders, body) ] ~loc ~ty) - ~join ~join_ty:ty_body) - | _ -> transl_match ~global_env rhs [ (pat, pat_binders, body) ] ~loc ~ty + ~ty ~loc = + (match pat with + | Tpat_var { binder; _ } -> + Core.let_ ~loc (Ident.of_ident binder.binder_id) rhs body + | Tpat_any _ -> Core.sequence2 ~loc rhs body + | Tpat_constraint { pat; _ } -> + transl_let ~global_env pat ~pat_binders rhs body ~loc ~ty + | Tpat_tuple { pats; _ } -> ( + let exception Cannot_simplify in + let rec pat_to_param (pat : Typedtree.pat) = + (match pat with + | Tpat_var { binder; ty; loc_ } -> + let binder = Ident.of_ident binder.binder_id in + { binder; ty; loc_ } + | Tpat_constraint { pat; _ } -> pat_to_param pat + | _ -> raise_notrace Cannot_simplify + : Core.param) + in + let cases = + [ + { + pat; + pat_binders; + action = body; + guard = None; + guard_binders = []; + inline_action = false; + }; + ] + in + match Lst.map pats pat_to_param with + | exception Cannot_simplify -> + transl_match ~global_env rhs cases ~loc ~ty + | params -> + let join = Ident.fresh "*join" in + let ty_body = Core.type_of_expr body in + let join_body = body in + Core.tuple_map rhs + ~ok:(fun body -> Core.joinlet_tail ~loc join params join_body body) + ~err:(fun _ -> transl_match ~global_env rhs cases ~loc ~ty) + ~join ~join_ty:ty_body) + | _ -> + transl_match ~global_env rhs + [ + { + pat; + pat_binders; + action = body; + guard = None; + guard_binders = []; + inline_action = false; + }; + ] + ~loc ~ty + : Core.expr) diff --git a/src/transl_mtype.ml b/src/transl_mtype.ml deleted file mode 100644 index f6e9d4f..0000000 --- a/src/transl_mtype.ml +++ /dev/null @@ -1,161 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Lst = Basic_lst -module Tid = Basic_ty_ident -module Hash_tid = Basic_ty_ident.Hash -module Hash_mid = Mtype.Id_hash - -let rec mtype_to_ltype ~(type_defs : Ltype.type_defs_with_context) - ~(mtype_defs : Mtype.defs) (t : Mtype.t) : Ltype.t = - let rec go (t : Mtype.t) : Ltype.t = - match t with - | T_int -> I32_Int - | T_char -> I32_Char - | T_bool -> I32_Bool - | T_unit -> I32_Unit - | T_byte -> I32_Byte - | T_uint -> U32 - | T_optimized_option { elem } -> ( - match elem with - | T_char | T_byte | T_bool | T_unit -> I32_Option_Char - | T_int | T_uint -> I64 - | T_int64 | T_uint64 | T_float | T_double | T_func _ | T_any _ - | T_optimized_option _ | T_maybe_uninit _ | T_error_value_result _ -> - assert false - | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ - | T_constr _ -> ( - match go elem with - | Ref { tid } -> Ref_nullable { tid } - | Ref_lazy_init { tid } -> Ref_nullable { tid } - | Ref_string -> Ref_nullable { tid = Ltype.tid_string } - | Ref_bytes -> Ref_nullable { tid = Ltype.tid_bytes } - | _ -> assert false)) - | T_int64 -> I64 - | T_uint64 -> U64 - | T_float -> F32 - | T_double -> F64 - | T_string -> Ref_string - | T_bytes -> Ref_bytes - | T_fixedarray { elem = T_int } -> Ltype.ref_array_i32 - | T_fixedarray { elem = T_int64 } -> Ltype.ref_array_i64 - | T_fixedarray { elem = T_double } -> Ltype.ref_array_f64 - | T_fixedarray { elem } -> - let name = Name_mangle.make_type_name t in - (if not (Hash_tid.mem type_defs.defs name) then - let ltype = Ltype.Ref_array { elem = go elem } in - Hash_tid.add type_defs.defs name ltype); - Ref { tid = name } - | T_maybe_uninit t -> ( - match go t with - | Ref { tid } when not (Tid.equal tid Ltype.tid_enum) -> - Ref_lazy_init { tid } - | t -> t) - | T_func { params; return } -> ( - let fn_sig : Ltype.fn_sig = - { - params = Lst.map params go; - ret = mtype_to_ltype_return ~mtype_defs ~type_defs return; - } - in - match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl fn_sig with - | Some name -> Ref { tid = name } - | None -> - let name = Name_mangle.make_type_name t in - let ltype = Ltype.Ref_closure_abstract { fn_sig } in - Ltype.FnSigHash.add type_defs.fn_sig_tbl fn_sig name; - assert (not (Hash_tid.mem type_defs.defs name)); - Hash_tid.add type_defs.defs name ltype; - Ref { tid = name }) - | T_tuple { tys } -> - let name = Name_mangle.make_type_name t in - (if not (Hash_tid.mem type_defs.defs name) then - let ltype = - Ltype.Ref_struct { fields = Lst.map tys (fun t -> (go t, false)) } - in - Hash_tid.add type_defs.defs name ltype); - Ref { tid = name } - | T_constr id | T_trait id -> ( - match Hash_mid.find_exn mtype_defs.defs id with - | Placeholder -> assert false - | Externref -> Ref_extern - | Variant _ | Constant_variant_constr -> Ltype.ref_enum - | Record _ | Trait _ | Variant_constr -> - let tid = Mtype.id_to_tid id in - Ref { tid }) - | T_any _ -> Ref_any - | T_error_value_result _ -> assert false - in - go t - -and mtype_to_ltype_return ~(type_defs : Ltype.type_defs_with_context) - ~(mtype_defs : Mtype.defs) (t : Mtype.t) : Ltype.return_type = - match t with - | T_error_value_result { ok; err; id = _ } -> - let ok_ty = mtype_to_ltype ~type_defs ~mtype_defs ok in - let err_ty = mtype_to_ltype ~type_defs ~mtype_defs err in - Ret_error { ok_ty; err_ty } - | T_int | T_char | T_bool | T_unit | T_byte | T_int64 | T_uint | T_uint64 - | T_float | T_double | T_string | T_bytes | T_optimized_option _ | T_func _ - | T_tuple _ | T_fixedarray _ | T_constr _ | T_trait _ | T_any _ - | T_maybe_uninit _ -> - Ret_single (mtype_to_ltype ~type_defs ~mtype_defs t) - -let transl_mtype_defs (mtype_defs : Mtype.defs) : Ltype.type_defs_with_context = - let type_defs = Hash_tid.of_list Ltype.predefs in - let type_defs_with_context : Ltype.type_defs_with_context = - { defs = type_defs; fn_sig_tbl = Ltype.FnSigHash.create 17 } - in - let mtype_to_ltype = - mtype_to_ltype ~type_defs:type_defs_with_context ~mtype_defs - in - let add_type (id, info) = - match info with - | Mtype.Placeholder | Externref -> () - | Variant { constrs } -> - Lst.iter constrs (fun { payload; tag } -> - let constr_name = - Name_mangle.make_constr_name (Mtype.id_to_tid id) tag - in - let args = - Lst.map payload (fun { field_type; mut; _ } -> - (mtype_to_ltype field_type, mut)) - in - Hash_tid.add type_defs constr_name (Ref_constructor { args })) - | Variant_constr | Constant_variant_constr -> () - | Record { fields } -> - let fields = - Lst.map fields (fun { field_type; mut; _ } -> - (mtype_to_ltype field_type, mut)) - in - Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_struct { fields }) - | Trait { methods } -> - let methods = - Lst.map methods (fun { params_ty; return_ty; _ } : Ltype.fn_sig -> - { - params = Lst.map params_ty mtype_to_ltype; - ret = - mtype_to_ltype_return ~type_defs:type_defs_with_context - ~mtype_defs return_ty; - }) - in - Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_object { methods }) - in - Hash_mid.iter mtype_defs.defs add_type; - type_defs_with_context - -let constr_to_ltype ~(tag : Tag.t) (t : Mtype.t) : Tid.t = - let name = Name_mangle.make_type_name t in - Name_mangle.make_constr_name name tag diff --git a/src/transl_mtype_gc.ml b/src/transl_mtype_gc.ml index b2d21ee..b2d84da 100644 --- a/src/transl_mtype_gc.ml +++ b/src/transl_mtype_gc.ml @@ -20,125 +20,136 @@ module Hash_tid = Basic_ty_ident.Hash module Hash_mid = Mtype.Id_hash let mtype_to_ltype ~(type_defs : Ltype.type_defs_with_context) - ~(mtype_defs : Mtype.defs) (t : Mtype.t) : Ltype.t = - let rec go (t : Mtype.t) : Ltype.t = - match t with - | T_int -> I32_Int - | T_char -> I32_Char - | T_bool -> I32_Bool - | T_unit -> I32_Unit - | T_byte -> I32_Byte - | T_uint -> I32_Int - | T_optimized_option { elem } -> ( - match elem with - | T_char | T_byte | T_bool | T_unit -> I32_Option_Char - | T_int | T_uint -> I64 - | T_int64 | T_uint64 | T_float | T_double | T_func _ | T_any _ - | T_optimized_option _ | T_maybe_uninit _ | T_error_value_result _ -> - assert false - | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ - | T_constr _ -> ( - match go elem with - | Ref { tid } -> Ref_nullable { tid } - | Ref_lazy_init { tid } -> Ref_nullable { tid } - | Ref_string -> Ref_nullable { tid = Ltype.tid_string } - | Ref_bytes -> Ref_nullable { tid = Ltype.tid_bytes } - | _ -> assert false)) - | T_int64 -> I64 - | T_uint64 -> I64 - | T_float -> F32 - | T_double -> F64 - | T_string -> Ref_string - | T_bytes -> Ref_bytes - | T_fixedarray { elem = T_int } -> Ltype.ref_array_i32 - | T_fixedarray { elem = T_int64 } -> Ltype.ref_array_i64 - | T_fixedarray { elem = T_double } -> Ltype.ref_array_f64 - | T_fixedarray { elem } -> - let name = Name_mangle.make_type_name t in - (if not (Hash_tid.mem type_defs.defs name) then - let ltype = Ltype.Ref_array { elem = go elem } in - Hash_tid.add type_defs.defs name ltype); - Ref { tid = name } - | T_maybe_uninit t -> ( - match go t with - | Ref { tid } when not (Tid.equal tid Ltype.tid_enum) -> - Ref_lazy_init { tid } - | t -> t) - | T_func { params; return } -> ( - let fn_sig : Ltype.fn_sig = - { params = Lst.map params go; ret = [ go return ] } - in - match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl fn_sig with - | Some name -> Ref { tid = name } - | None -> - let name = Name_mangle.make_type_name t in - let ltype = Ltype.Ref_closure_abstract { fn_sig } in - Ltype.FnSigHash.add type_defs.fn_sig_tbl fn_sig name; - assert (not (Hash_tid.mem type_defs.defs name)); - Hash_tid.add type_defs.defs name ltype; - Ref { tid = name }) - | T_tuple { tys } -> - let name = Name_mangle.make_type_name t in - (if not (Hash_tid.mem type_defs.defs name) then - let ltype = - Ltype.Ref_struct { fields = Lst.map tys (fun t -> (go t, false)) } - in - Hash_tid.add type_defs.defs name ltype); - Ref { tid = name } - | T_constr id | T_trait id -> ( - match Hash_mid.find_exn mtype_defs.defs id with - | Placeholder -> assert false - | Externref -> Ref_extern - | Variant _ | Constant_variant_constr -> Ltype.ref_enum - | Record _ | Trait _ | Variant_constr -> - let tid = Mtype.id_to_tid id in - Ref { tid }) - | T_any _ -> Ref_any - | T_error_value_result _ -> Ltype.ref_enum - in - go t + ~(mtype_defs : Mtype.defs) (t : Mtype.t) = + (let rec go (t : Mtype.t) = + (match t with + | T_int -> Ltype.i32_int + | T_char -> Ltype.i32_char + | T_bool -> Ltype.i32_bool + | T_unit -> Ltype.i32_unit + | T_byte -> Ltype.i32_byte + | T_int16 -> Ltype.i32_int16 + | T_uint16 -> Ltype.i32_uint16 + | T_uint -> Ltype.i32_int + | T_optimized_option { elem } -> ( + match elem with + | T_char | T_byte | T_int16 | T_uint16 | T_bool | T_unit -> + Ltype.i32_option_char + | T_int | T_uint -> I64 + | T_int64 | T_uint64 | T_float | T_double | T_func _ | T_raw_func _ + | T_any _ | T_optimized_option _ | T_maybe_uninit _ + | T_error_value_result _ -> + assert false + | T_string | T_bytes | T_tuple _ | T_fixedarray _ | T_trait _ + | T_constr _ -> ( + match go elem with + | Ref { tid } -> Ref_nullable { tid } + | Ref_lazy_init { tid } -> Ref_nullable { tid } + | Ref_string -> Ref_nullable { tid = Ltype.tid_string } + | Ref_bytes -> Ref_nullable { tid = Ltype.tid_bytes } + | _ -> assert false)) + | T_int64 -> I64 + | T_uint64 -> I64 + | T_float -> F32 + | T_double -> F64 + | T_string -> Ref_string + | T_bytes -> Ref_bytes + | T_fixedarray { elem = T_int } -> Ltype.ref_array_i32 + | T_fixedarray { elem = T_int64 } -> Ltype.ref_array_i64 + | T_fixedarray { elem = T_double } -> Ltype.ref_array_f64 + | T_fixedarray { elem } -> + let name = Name_mangle.make_type_name t in + (if not (Hash_tid.mem type_defs.defs name) then + let ltype = Ltype.Ref_array { elem = go elem } in + Hash_tid.add type_defs.defs name ltype); + Ref { tid = name } + | T_maybe_uninit t -> ( + match go t with + | Ref { tid } when not (Tid.equal tid Ltype.tid_enum) -> + Ref_lazy_init { tid } + | t -> t) + | T_func { params; return } -> ( + let fn_sig : Ltype.fn_sig = + { params = Lst.map params go; ret = [ go return ] } + in + match Ltype.FnSigHash.find_opt type_defs.fn_sig_tbl fn_sig with + | Some name -> Ref { tid = name } + | None -> + let name = Name_mangle.make_type_name t in + let ltype = Ltype.Ref_closure_abstract { fn_sig } in + Ltype.FnSigHash.add type_defs.fn_sig_tbl fn_sig name; + assert (not (Hash_tid.mem type_defs.defs name)); + Hash_tid.add type_defs.defs name ltype; + Ref { tid = name }) + | T_raw_func _ -> Ref_func + | T_tuple { tys } -> + let name = Name_mangle.make_type_name t in + (if not (Hash_tid.mem type_defs.defs name) then + let ltype = + Ltype.Ref_struct + { fields = Lst.map tys (fun t -> (go t, false)) } + in + Hash_tid.add type_defs.defs name ltype); + Ref { tid = name } + | T_constr id | T_trait id -> ( + match Hash_mid.find_exn mtype_defs.defs id with + | Placeholder -> assert false + | Externref -> Ref_extern + | Variant _ | Constant_variant_constr -> Ltype.ref_enum + | Record _ | Trait _ | Variant_constr -> + let tid = Mtype.id_to_tid id in + Ref { tid }) + | T_any _ -> Ref_any + | T_error_value_result _ -> Ltype.ref_enum + : Ltype.t) + in + go t + : Ltype.t) -let transl_mtype_defs (mtype_defs : Mtype.defs) : Ltype.type_defs_with_context = - let type_defs = Hash_tid.of_list Ltype.predefs in - let type_defs_with_context : Ltype.type_defs_with_context = - { defs = type_defs; fn_sig_tbl = Ltype.FnSigHash.create 17 } - in - let mtype_to_ltype = - mtype_to_ltype ~type_defs:type_defs_with_context ~mtype_defs - in - let add_type (id, info) = - match info with - | Mtype.Placeholder | Externref -> () - | Variant { constrs } -> - Lst.iter constrs (fun { payload; tag } -> - let constr_name = - Name_mangle.make_constr_name (Mtype.id_to_tid id) tag - in - let args = - Lst.map payload (fun { field_type; mut; _ } -> - (mtype_to_ltype field_type, mut)) - in - Hash_tid.add type_defs constr_name (Ref_constructor { args })) - | Variant_constr | Constant_variant_constr -> () - | Record { fields } -> - let fields = - Lst.map fields (fun { field_type; mut; _ } -> - (mtype_to_ltype field_type, mut)) - in - Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_struct { fields }) - | Trait { methods } -> - let methods = - Lst.map methods (fun { params_ty; return_ty; _ } : Ltype.fn_sig -> - { - params = Lst.map params_ty mtype_to_ltype; - ret = [ mtype_to_ltype return_ty ]; - }) - in - Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_object { methods }) - in - Hash_mid.iter mtype_defs.defs add_type; - type_defs_with_context +let transl_mtype_defs (mtype_defs : Mtype.defs) = + (let type_defs = Hash_tid.of_list Ltype.predefs in + let type_defs_with_context : Ltype.type_defs_with_context = + { defs = type_defs; fn_sig_tbl = Ltype.FnSigHash.create 17 } + in + let mtype_to_ltype = + mtype_to_ltype ~type_defs:type_defs_with_context ~mtype_defs + in + let add_type (id, info) = + match info with + | Mtype.Placeholder | Externref -> () + | Variant { constrs } -> + Lst.iter constrs ~f:(fun { payload; tag } -> + let constr_name = + Name_mangle.make_constr_name (Mtype.id_to_tid id) tag + in + let args = + Lst.map payload (fun { field_type; mut; _ } -> + (mtype_to_ltype field_type, mut)) + in + Hash_tid.add type_defs constr_name (Ref_constructor { args })) + | Variant_constr | Constant_variant_constr -> () + | Record { fields } -> + let fields = + Lst.map fields (fun { field_type; mut; _ } -> + (mtype_to_ltype field_type, mut)) + in + Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_struct { fields }) + | Trait { methods } -> + let methods = + Lst.map methods (fun { params_ty; return_ty; _ } -> + ({ + params = Lst.map params_ty mtype_to_ltype; + ret = [ mtype_to_ltype return_ty ]; + } + : Ltype.fn_sig)) + in + Hash_tid.add type_defs (Mtype.id_to_tid id) (Ref_object { methods }) + in + Hash_mid.iter mtype_defs.defs add_type; + type_defs_with_context + : Ltype.type_defs_with_context) -let constr_to_ltype ~(tag : Tag.t) (t : Mtype.t) : Tid.t = - let name = Name_mangle.make_type_name t in - Name_mangle.make_constr_name name tag +let constr_to_ltype ~(tag : Tag.t) (t : Mtype.t) = + (let name = Name_mangle.make_type_name t in + Name_mangle.make_constr_name name tag + : Tid.t) diff --git a/src/transl_type.ml b/src/transl_type.ml index b992b7b..5055984 100644 --- a/src/transl_type.ml +++ b/src/transl_type.ml @@ -16,493 +16,151 @@ module Tid = Basic_ty_ident module Ltype = Ltype_gc module Lst = Basic_lst +module Ast = Dwarfsm_ast -let tid_to_wasm_name (tid : Tid.t) = Tid.to_wasm_name tid -let tid_to_string = tid_to_wasm_name +let i32 = Wasmlinear_constr.i32 +and externref = Wasmlinear_constr.externref -let need_late_init_tid_to_sexp (tid : Tid.t) : W.t = - List - (List.cons - (Atom "ref" : W.t) - (List.cons (Atom "null" : W.t) ([ Atom (tid_to_string tid) ] : W.t list))) +let ref_ = Wasmgc_constr.ref_ +and anyref = Wasmgc_constr.anyref +and funcref = Wasmgc_constr.funcref +and null = Wasmgc_constr.null +and comp_array = Wasmgc_constr.comp_array +and comp_struct = Wasmgc_constr.comp_struct +and comp_func = Wasmgc_constr.comp_func +and typedef = Wasmgc_constr.typedef +and field_mut = Wasmgc_constr.field_mut +and field_immut = Wasmgc_constr.field_immut +and final = Wasmgc_constr.final +and sub = Wasmgc_constr.sub +and field = Wasmgc_constr.field +and param = Wasmgc_constr.param +and result = Wasmgc_constr.result +and ltype_to_valtype = Wasmgc_constr.ltype_to_valtype +and param_ = Wasmgc_constr.param_ -let tid_to_sexp (tid : Tid.t) : W.t = - List (List.cons (Atom "ref" : W.t) ([ Atom (tid_to_string tid) ] : W.t list)) +let need_late_init_ltype_to_valtype (t : Ltype.t) = + (match t with + | Ref_extern -> externref + | F32 -> Numtype F32 + | F64 -> Numtype F64 + | I64 -> Numtype I64 + | I32 _ -> Numtype I32 + | Ref_bytes -> ref_ ~null ~id_:"$moonbit.bytes" () + | Ref_string -> + if !Basic_config.use_js_builtin_string then externref + else ref_ ~null ~id_:"$moonbit.string" () + | Ref_nullable { tid } -> + if !Basic_config.use_js_builtin_string && Tid.equal tid Ltype.tid_string + then externref + else ref_ ~null ~id:tid () + | Ref_lazy_init { tid } | Ref { tid } -> ref_ ~null ~id:tid () + | Ref_func -> funcref + | Ref_any -> anyref + : Ast.valtype) -let ltype_to_sexp (t : Ltype.t) : W.t = - match t with - | Ref_extern -> Atom "externref" - | F32 -> Atom "f32" - | F64 -> Atom "f64" - | I64 -> Atom "i64" - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char -> - Atom "i32" - | Ref_bytes -> - (List - (List.cons (Atom "ref" : W.t) ([ Atom "$moonbit.bytes" ] : W.t list)) - : W.t) - | Ref_string -> - if !Basic_config.use_js_builtin_string then - (List (List.cons (Atom "ref" : W.t) ([ Atom "extern" ] : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom "$moonbit.string" ] : W.t list)) - : W.t) - | Ref { tid } -> - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - | Ref_nullable { tid } -> - if !Basic_config.use_js_builtin_string && Tid.equal tid Ltype.tid_string - then Atom "externref" - else - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list))) - : W.t) - | Ref_lazy_init { tid } -> - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list))) - : W.t) - | Ref_func -> Atom "funcref" - | Ref_any -> (Atom "anyref" : W.t) - -let need_late_init_ltype_to_sexp (t : Ltype.t) : W.t = - match t with - | Ref_extern -> Atom "externref" - | F32 -> Atom "f32" - | F64 -> Atom "f64" - | I64 -> Atom "i64" - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char -> - Atom "i32" - | Ref_bytes -> - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list))) - : W.t) - | Ref_string -> - if !Basic_config.use_js_builtin_string then Atom "externref" - else - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom "$moonbit.string" ] : W.t list))) - : W.t) - | Ref_nullable { tid } -> - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list))) - : W.t) - | Ref_lazy_init { tid } | Ref { tid } -> - (List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list))) - : W.t) - | Ref_func -> Atom "funcref" - | Ref_any -> (Atom "anyref" : W.t) - -let compile_typedef ~(type_defs : Ltype.type_defs) (tid : Tid.t) +let compile_typedef ~(type_defs : Ltype.type_defs) (id : Tid.t) (def : Ltype.def) = + let array = comp_array in + let mut = field_mut in + let immut = field_immut in + let struct_ = comp_struct in + let func = comp_func in match def with | Ref_constructor { args = [] } | Ref_struct { fields = [] } -> [] + | Ref_array { elem = I32 { kind = I32_Int16 | I32_UInt16 } } -> + let mut_i16 : Ast.fieldtype = { mut = Var; type_ = Packedtype I16 } in + [ typedef ~id (array mut_i16) ] | Ref_array { elem } -> - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "array" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ ltype_to_sexp elem ] : W.t list)); - ] - : W.t list)); - ] - : W.t list))); - ] - : W.t list) + let elem = ltype_to_valtype elem in + [ typedef ~id (array (mut elem)) ] | Ref_struct { fields } -> let fields = - Lst.map fields (fun (field_ty, mut) -> - if mut then - (List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ ltype_to_sexp field_ty ] : W.t list)); - ] - : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "field" : W.t) - ([ ltype_to_sexp field_ty ] : W.t list)) - : W.t)) + Lst.map fields (fun (field_ty, mutable_) -> + let field_ty = ltype_to_valtype field_ty in + if mutable_ then field (mut field_ty) else field (immut field_ty)) in - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ List (List.cons (Atom "struct" : W.t) (fields : W.t list)) ] - : W.t list))); - ] - : W.t list) + [ typedef ~id (struct_ fields) ] | Ref_late_init_struct { fields } -> let fields = - Lst.map fields (fun p : W.t -> - List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ need_late_init_ltype_to_sexp p ] : W.t list)); - ] - : W.t list))) + Lst.map fields (fun p -> + field (mut (need_late_init_ltype_to_valtype p))) in - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ List (List.cons (Atom "struct" : W.t) (fields : W.t list)) ] - : W.t list))); - ] - : W.t list) + [ typedef ~id (struct_ fields) ] | Ref_constructor { args } -> let tid_enum = Ltype.tid_enum in let fields = - Lst.map args (fun (field_ty, mut) -> - if mut then - (List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ ltype_to_sexp field_ty ] : W.t list)); - ] - : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "field" : W.t) - ([ ltype_to_sexp field_ty ] : W.t list)) - : W.t)) + Lst.map args (fun (field_ty, mutable_) -> + let field_ty = ltype_to_valtype field_ty in + if mutable_ then field (mut field_ty) else field (immut field_ty)) in - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - (List.cons - (Atom "final" : W.t) - (List.cons - (Atom (tid_to_string tid_enum) : W.t) - ([ - List - (List.cons - (Atom "struct" : W.t) - (List.cons - (List - (List.cons - (Atom "field" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - (fields : W.t list))); - ] - : W.t list)))); - ] - : W.t list))); - ] - : W.t list) + [ + typedef ~id + (sub ~final ~super:[ tid_enum ] + (struct_ ([ field (immut i32) ] @ fields))); + ] | Ref_closure_abstract { fn_sig = { params; ret } } -> - let tid_code_ptr = Tid.code_pointer_of_closure tid in - let params = - Lst.map params (fun p : W.t -> - List - (List.cons (Atom "param" : W.t) ([ ltype_to_sexp p ] : W.t list))) - in - let result = - Lst.map ret (fun p : W.t -> - List - (List.cons (Atom "result" : W.t) ([ ltype_to_sexp p ] : W.t list))) - in - ([ - List - (List.cons - (Atom "rec" : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid_code_ptr) : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ tid_to_sexp tid ] : W.t list)) - : W.t) - (List.append - (params : W.t list) - (result : W.t list)))); - ] - : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - ([ - List - (List.cons - (Atom "struct" : W.t) - ([ - List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ - need_late_init_tid_to_sexp - tid_code_ptr; - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list))); - ] - : W.t list))); - ] - : W.t list) + let tid_code_ptr = Tid.code_pointer_of_closure id in + let params = Lst.map params (fun p -> param p) in + let result = Lst.map ret (fun p -> result p) in + [ + typedef ~id:tid_code_ptr + (func ([ param_ (ref_ ~id ()) ] @ params) result); + typedef ~id + (sub (struct_ [ field (mut (ref_ ~null ~id:tid_code_ptr ())) ])); + ] | Ref_object { methods } -> let method_tids = - Lst.mapi methods (fun method_index _ -> - Tid.method_of_object tid method_index) + Lst.mapi methods (fun method_index -> + fun _ -> Tid.method_of_object id method_index) in let method_sigs = - Lst.map2 method_tids methods (fun method_tid { params; ret } -> - let params = - Lst.map params (fun p : W.t -> - List - (List.cons - (Atom "param" : W.t) - ([ ltype_to_sexp p ] : W.t list))) - in - let result = - Lst.map ret (fun p : W.t -> - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp p ] : W.t list))) - in - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string method_tid) : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - (List.cons - (List - (List.cons - (Atom "param" : W.t) - ([ tid_to_sexp tid ] : W.t list)) - : W.t) - (List.append - (params : W.t list) - (result : W.t list)))); - ] - : W.t list))) - : W.t)) + Lst.map2 method_tids methods (fun method_tid -> + fun { params; ret } -> + let params = Lst.map params (fun p -> param p) in + let result = Lst.map ret (fun p -> result p) in + typedef ~id:method_tid + (func ([ param_ (ref_ ~id ()) ] @ params) result)) in let method_fields = - Lst.map method_tids (fun method_tid : W.t -> - List - (List.cons - (Atom "field" : W.t) - ([ tid_to_sexp method_tid ] : W.t list))) + Lst.map method_tids (fun method_tid -> + field (immut (ref_ ~id:method_tid ()))) in - ([ - List - (List.cons - (Atom "rec" : W.t) - (List.cons - (List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - ([ - List - (List.cons - (Atom "struct" : W.t) - (method_fields : W.t list)); - ] - : W.t list)); - ] - : W.t list))) - : W.t) - (method_sigs : W.t list))); - ] - : W.t list) + [ typedef ~id (sub (struct_ method_fields)) ] @ method_sigs + | Ref_concrete_object { abstract_obj_tid; self } -> ( + match[@warning "-fragile-match"] + Tid.Hash.find_exn type_defs abstract_obj_tid + with + | Ref_object { methods } -> + let methods = + Lst.mapi methods (fun method_index -> + fun _ -> + let tid_method = + Tid.method_of_object abstract_obj_tid method_index + in + field (immut (ref_ ~id:tid_method ()))) + in + [ + typedef ~id + (sub ~super:[ abstract_obj_tid ] + (struct_ (methods @ [ field (immut (ltype_to_valtype self)) ]))); + ] + | _ -> assert false) | Ref_closure { fn_sig_tid = _; captures = [] } -> [] - | Ref_closure { fn_sig_tid; captures } -> ( - let tid_capture = tid in + | Ref_closure { fn_sig_tid; captures } -> + let tid_capture = id in let tid_base = fn_sig_tid in - let make_result ~need_late_init code_ptr_fields = - let captures = - Lst.map captures (fun p -> - if need_late_init then - (List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ need_late_init_ltype_to_sexp p ] : W.t list)); - ] - : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "field" : W.t) - ([ ltype_to_sexp p ] : W.t list)) - : W.t)) - in - ([ - List - (List.cons - (Atom "type" : W.t) - (List.cons - (Atom (tid_to_string tid_capture) : W.t) - ([ - List - (List.cons - (Atom "sub" : W.t) - (List.cons - (Atom (tid_to_string tid_base) : W.t) - ([ - List - (List.cons - (Atom "struct" : W.t) - (List.append - (code_ptr_fields : W.t list) - (captures : W.t list))); - ] - : W.t list))); - ] - : W.t list))); - ] - : W.t list) - [@@local] + let tid_code_ptr = Tid.code_pointer_of_closure fn_sig_tid in + let captures = + Lst.map captures (fun p -> + field (mut (need_late_init_ltype_to_valtype p))) in - match Tid.Hash.find_exn type_defs fn_sig_tid with - | Ref_struct _ | Ref_late_init_struct _ | Ref_constructor _ | Ref_array _ - | Ref_closure _ -> - assert false - | Ref_closure_abstract _ -> - let tid_code_ptr = Tid.code_pointer_of_closure fn_sig_tid in - let code_ptr_fields = - ([ - List - (List.cons - (Atom "field" : W.t) - ([ - List - (List.cons - (Atom "mut" : W.t) - ([ need_late_init_tid_to_sexp tid_code_ptr ] - : W.t list)); - ] - : W.t list)); - ] - : W.t list) - in - make_result ~need_late_init:true code_ptr_fields - | Ref_object { methods } -> - let code_ptr_fields = - Lst.mapi methods (fun method_index _ -> - let tid_method = Tid.method_of_object fn_sig_tid method_index in - (List - (List.cons - (Atom "field" : W.t) - ([ tid_to_sexp tid_method ] : W.t list)) - : W.t)) - in - make_result ~need_late_init:false code_ptr_fields) + [ + typedef ~id:tid_capture + (sub ~super:[ tid_base ] + (struct_ + ([ field (mut (ref_ ~null ~id:tid_code_ptr ())) ] @ captures))); + ] let compile_group_type_defs (type_defs : Ltype.type_defs) = let grouped_types = Grouped_typedefs.group_typedefs type_defs in @@ -511,20 +169,14 @@ let compile_group_type_defs (type_defs : Ltype.type_defs) = | Rec defs -> let types = ref [] in let rec_types = ref [] in - Lst.iter defs (fun (tid, def) -> - let instrs = compile_typedef tid def ~type_defs in - Lst.iter instrs (fun instr -> - match instr with - | (List (Atom "rec" :: instrs) : W.t) -> - rec_types := instrs @ !rec_types - | _ -> types := instr :: !types)); + Lst.iter defs ~f:(fun (tid, def) -> + let typedefs = compile_typedef tid def ~type_defs in + match typedefs with + | [] -> () + | norec :: [] -> types := norec :: !types + | _ -> rec_types := typedefs @ !rec_types); let rec_types = !rec_types in let types = List.rev !types in - ([ - List - (List.cons - (Atom "rec" : W.t) - (List.append (rec_types : W.t list) (types : W.t list))); - ] - : W.t list) - | Nonrec (tid, def) -> compile_typedef tid def ~type_defs) + [ Ast.Rectype (rec_types @ types) ] + | Nonrec (tid, def) -> + [ Ast.Rectype (compile_typedef tid def ~type_defs) ]) diff --git a/src/tvar_env.ml b/src/tvar_env.ml index 8872d6c..248f9a2 100644 --- a/src/tvar_env.ml +++ b/src/tvar_env.ml @@ -17,10 +17,15 @@ open Basic_unsafe_external module Type_path = Basic_type_path module Loc = Rloc +type constraint_src = + | Super_traits of Type_path.t list + | Static_assert of string + | Direct + type type_constraint = { trait : Type_path.t; loc_ : Loc.t; - required_by_ : Type_path.t list; + src_ : constraint_src; } let sexp_of_type_constraint { trait } = Type_path.sexp_of_t trait @@ -53,52 +58,56 @@ let tparam_info ~name ~typ ~constraints ~loc = { name; typ; constraints; loc_ = loc } let empty : t = [||] -let find_by_index_exn (env : t) (index : int) : tparam_info = env.(index) +let find_by_index_exn (env : t) (index : int) = (env.(index) : tparam_info) -let find_by_name (env : t) (name : string) : tparam_info option = - Arr.find env (fun tvar_info -> name = tvar_info.name) +let find_by_name (env : t) (name : string) = + (Arr.find env (fun tvar_info -> name = tvar_info.name) : tparam_info option) let is_empty (x : t) = Arr.is_empty x [@@inline] -let make_type_subst (tvar_env : t) : Stype.t array = - let len = Array.length tvar_env in - match len with - | 0 -> [||] - | 1 -> [| Stype.new_type_var Tvar_normal |] - | 2 -> [| Stype.new_type_var Tvar_normal; Stype.new_type_var Tvar_normal |] - | 3 -> - [| - Stype.new_type_var Tvar_normal; - Stype.new_type_var Tvar_normal; - Stype.new_type_var Tvar_normal; - |] - | 4 -> - [| - Stype.new_type_var Tvar_normal; - Stype.new_type_var Tvar_normal; - Stype.new_type_var Tvar_normal; - Stype.new_type_var Tvar_normal; - |] - | _ -> - let res : Stype.t array = - Array.make len (Stype.new_type_var Tvar_normal) - in - for i = 1 to len - 1 do - res.!(i) <- Stype.new_type_var Tvar_normal - done; - res +let make_type_subst (tvar_env : t) = + (let len = Array.length tvar_env in + match len with + | 0 -> [||] + | 1 -> [| Stype.new_type_var Tvar_normal |] + | 2 -> [| Stype.new_type_var Tvar_normal; Stype.new_type_var Tvar_normal |] + | 3 -> + [| + Stype.new_type_var Tvar_normal; + Stype.new_type_var Tvar_normal; + Stype.new_type_var Tvar_normal; + |] + | 4 -> + [| + Stype.new_type_var Tvar_normal; + Stype.new_type_var Tvar_normal; + Stype.new_type_var Tvar_normal; + Stype.new_type_var Tvar_normal; + |] + | _ -> + let res : Stype.t array = + Array.make len (Stype.new_type_var Tvar_normal) + in + for i = 1 to len - 1 do + res.!(i) <- Stype.new_type_var Tvar_normal + done; + res + : Stype.t array) [@@inline] -let to_list_map (env : t) (f : tparam_info -> 'a) : 'a list = - Arr.to_list_f env f +let to_list_map (env : t) (f : tparam_info -> 'a) = + (Arr.to_list_f env f : 'a list) [@@inline] -let get_types (env : t) : Stype.t list = - to_list_map env (fun tvar_info -> tvar_info.typ) +let get_types (env : t) = + (to_list_map env (fun tvar_info -> tvar_info.typ) : Stype.t list) + +let iter (env : t) (f : tparam_info -> unit) = (Arr.iter env f : unit) + +let iteri (env : t) (f : int -> tparam_info -> unit) = + (Array.iteri f env : unit) -let iter (env : t) (f : tparam_info -> unit) : unit = Arr.iter env f -let iteri (env : t) (f : int -> tparam_info -> unit) : unit = Array.iteri f env -let map (env : t) (f : tparam_info -> tparam_info) : t = Arr.map env f +let map (env : t) (f : tparam_info -> tparam_info) = (Arr.map env f : t) let sexp_of_t env = S.List @@ -110,8 +119,8 @@ let sexp_of_t env = in (List (List.cons (Atom name : S.t) (constraints : S.t list)) : S.t))) -let of_list_mapi (type a) (items : a list) (f : int -> a -> tparam_info) : t = - Arr.of_list_mapi items f +let of_list_mapi (type a) (items : a list) (f : int -> a -> tparam_info) = + (Arr.of_list_mapi items f : t) let tvar_env_1 : t = [| @@ -144,5 +153,5 @@ let equal env1 env2 = Lst.exists tv1_constraints (constraint_equal c2)) [@@inline] in - Arr.for_all2_no_exn env1 env2 (fun tv1 tv2 -> - constraints_equal tv1.constraints tv2.constraints) + Arr.for_all2_no_exn env1 env2 (fun tv1 -> + fun tv2 -> constraints_equal tv1.constraints tv2.constraints) diff --git a/src/type.ml b/src/type.ml index ada64ea..1cbb7c1 100644 --- a/src/type.ml +++ b/src/type.ml @@ -30,7 +30,7 @@ let type_var_list arity kind = List.init arity (fun _ -> Stype.new_type_var kind let check_occur (v : typ) (ty : typ) = let rec go (ty : typ) = match ty with - | Tarrow { params_ty = ty1; ret_ty = ty2; err_ty = ty3 } -> ( + | Tarrow { params_ty = ty1; ret_ty = ty2; err_ty = ty3; is_async = _ } -> ( List.exists go ty1 || go ty2 || match ty3 with Some ty3 -> go ty3 | None -> false) | T_constr { tys; _ } -> List.exists go tys @@ -42,165 +42,197 @@ let check_occur (v : typ) (ty : typ) = type filter_blame_target = Filtered_type | Filter_itself -let filter_arrow ~blame ~(has_error : bool) (arity : int) (ty : typ) - (loc : Rloc.t) : - (typ list * typ * typ option) Local_diagnostics.partial_info = - let ty = type_repr ty in - match ty with - | Tarrow { params_ty; ret_ty; err_ty } -> - let len = List.length params_ty in - if arity = len then Ok (params_ty, ret_ty, err_ty) - else - let error = - match blame with - | Filtered_type -> - Errors.func_param_num_mismatch ~expected:len ~actual:arity - ~ty:(Printer.type_to_string ty) - ~loc - | Filter_itself -> - let expected = - ("function with " ^ Int.to_string len ^ " argument(s)" - : Stdlib.String.t) - in - let actual = - ("function with " ^ Int.to_string arity ^ " argument(s)" - : Stdlib.String.t) - in - Errors.type_mismatch ~expected ~actual ~loc - in - let params_ty = - if arity < len then Basic_lst.take arity params_ty - else params_ty @ type_var_list (arity - len) Tvar_error - in - Partial ((params_ty, ret_ty, err_ty), [ error ]) - | Tvar ({ contents = Tnolink tvar_kind } as link) -> - let params_ty = type_var_list arity tvar_kind in - let ret_ty = Stype.new_type_var tvar_kind in - let err_ty = - if has_error then Some (Stype.new_type_var tvar_kind) else None - in - link := Tlink (Tarrow { params_ty; ret_ty; err_ty; generic_ = false }); - Ok (params_ty, ret_ty, err_ty) - | _ -> ( - let ty_params = type_var_list arity Tvar_error in - let ty_res = Stype.new_type_var Tvar_error in - let ty_err = - if has_error then Some (Stype.new_type_var Tvar_error) else None - in - match ty with - | T_blackhole -> Ok (ty_params, ty_res, ty_err) - | _ -> - let expected, actual = - match blame with - | Filtered_type -> ("function type", Printer.type_to_string ty) - | Filter_itself -> (Printer.type_to_string ty, "function type") - in - Partial - ( (ty_params, ty_res, ty_err), - [ Errors.type_mismatch ~expected ~actual ~loc ] )) +let filter_arrow ~blame ~(has_error : bool) ~is_async (arity : int) (ty : typ) + (loc : Rloc.t) = + (let ty = type_repr ty in + match ty with + | Tarrow { params_ty; ret_ty; err_ty; is_async = is_async' } -> + let len = List.length params_ty in + if arity = len && is_async' = is_async then Ok (params_ty, ret_ty, err_ty) + else + let error = + match blame with + | Filtered_type -> + Errors.func_param_num_mismatch ~expected:len ~actual:arity + ~ty:(Printer.type_to_string ty) + ~loc + | Filter_itself -> + let expected = + (("function with " ^ Int.to_string len ^ " argument(s)" + : Stdlib.String.t) + [@merlin.hide]) + in + let actual = + (("function with " ^ Int.to_string arity ^ " argument(s)" + : Stdlib.String.t) + [@merlin.hide]) + in + Errors.type_mismatch ~expected ~actual ~loc + in + let params_ty = + if arity < len then Basic_lst.take params_ty arity + else params_ty @ type_var_list (arity - len) Tvar_error + in + Partial ((params_ty, ret_ty, err_ty), [ error ]) + | Tvar ({ contents = Tnolink tvar_kind } as link) -> + let params_ty = type_var_list arity tvar_kind in + let ret_ty = Stype.new_type_var tvar_kind in + let err_ty = + if has_error then Some (Stype.new_type_var tvar_kind) else None + in + link := + Tlink + (Tarrow { params_ty; ret_ty; err_ty; generic_ = false; is_async }); + Ok (params_ty, ret_ty, err_ty) + | _ -> ( + let ty_params = type_var_list arity Tvar_error in + let ty_res = Stype.new_type_var Tvar_error in + let ty_err = + if has_error then Some (Stype.new_type_var Tvar_error) else None + in + match ty with + | T_blackhole -> Ok (ty_params, ty_res, ty_err) + | _ -> + let expected, actual = + match blame with + | Filtered_type -> ("function type", Printer.type_to_string ty) + | Filter_itself -> (Printer.type_to_string ty, "function type") + in + Partial + ( (ty_params, ty_res, ty_err), + [ Errors.type_mismatch ~expected ~actual ~loc ] )) + : (typ list * typ * typ option) Local_diagnostics.partial_info) -let filter_product ~blame ~(arity : int option) (ty : typ) (loc : Rloc.t) : - typ list Local_diagnostics.partial_info = - match (type_repr ty, arity) with - | Tvar ({ contents = Tnolink tvar_kind } as link), Some n -> - let tys = type_var_list n tvar_kind in - link := Tlink (Builtin.type_product tys); - Ok tys - | T_constr { type_constructor = Tuple len; tys }, Some n -> - if len = n then Ok tys - else - let expected, actual = - match blame with - | Filtered_type -> (n, len) - | Filter_itself -> (len, n) - in - let error = - Errors.type_mismatch - ~expected:(Int.to_string expected ^ "-tuple" : Stdlib.String.t) - ~actual:(Int.to_string actual ^ "-tuple" : Stdlib.String.t) - ~loc - in - let tys = - if n < len then Basic_lst.take n tys - else tys @ type_var_list (n - len) Tvar_error - in - Partial (tys, [ error ]) - | T_constr { type_constructor = Tuple _; tys }, None -> Ok tys - | ty, Some n -> ( - let tys = type_var_list n Tvar_error in - match ty with - | T_blackhole -> Ok tys - | _ -> - let expected, actual = - match blame with - | Filtered_type -> - ( (Int.to_string n ^ "-tuple" : Stdlib.String.t), - (Printer.type_to_string ty : Stdlib.String.t) ) - | Filter_itself -> - ( (Printer.type_to_string ty : Stdlib.String.t), - (Int.to_string n ^ "-tuple" : Stdlib.String.t) ) - in - Partial (tys, [ Errors.type_mismatch ~expected ~actual ~loc ])) - | Tvar { contents = Tnolink Tvar_error }, None -> Partial ([], []) - | T_blackhole, None -> Ok [] - | ty, None -> - let expected, actual = - match blame with - | Filtered_type -> - ("tuple", (Printer.type_to_string ty : Stdlib.String.t)) - | Filter_itself -> - ((Printer.type_to_string ty : Stdlib.String.t), "tuple") - in - Partial ([], [ Errors.type_mismatch ~expected ~actual ~loc ]) +let filter_product ?src_ty ~blame ~(arity : int option) (ty : typ) + (loc : Rloc.t) = + (match (type_repr ty, arity) with + | Tvar ({ contents = Tnolink tvar_kind } as link), Some n -> + let tys = type_var_list n tvar_kind in + link := Tlink (Builtin.type_product tys); + Ok tys + | T_constr { type_constructor = Tuple len; tys }, Some n -> + if len = n then Ok tys + else + let expected, actual = + match blame with + | Filtered_type -> (n, len) + | Filter_itself -> (len, n) + in + let error = + Errors.type_mismatch + ~expected: + ((Int.to_string expected ^ "-tuple" + : Stdlib.String.t) + [@merlin.hide]) + ~actual: + ((Int.to_string actual ^ "-tuple" + : Stdlib.String.t) + [@merlin.hide]) + ~loc + in + let tys = + if n < len then Basic_lst.take tys n + else tys @ type_var_list (n - len) Tvar_error + in + Partial (tys, [ error ]) + | T_constr { type_constructor = Tuple _; tys }, None -> Ok tys + | ty, Some n -> ( + let tys = type_var_list n Tvar_error in + match ty with + | T_blackhole -> Ok tys + | _ -> + let ty = Option.value src_ty ~default:ty in + let expected, actual = + match blame with + | Filtered_type -> + ( ((Int.to_string n ^ "-tuple" + : Stdlib.String.t) + [@merlin.hide]), + ((Printer.type_to_string ty + : Stdlib.String.t) + [@merlin.hide]) ) + | Filter_itself -> + ( ((Printer.type_to_string ty : Stdlib.String.t) [@merlin.hide]), + ((Int.to_string n ^ "-tuple" + : Stdlib.String.t) + [@merlin.hide]) ) + in + Partial (tys, [ Errors.type_mismatch ~expected ~actual ~loc ])) + | Tvar { contents = Tnolink Tvar_error }, None -> Partial ([], []) + | T_blackhole, None -> Ok [] + | ty, None -> + let ty = Option.value src_ty ~default:ty in + let expected, actual = + match blame with + | Filtered_type -> + ( "tuple", + ((Printer.type_to_string ty : Stdlib.String.t) [@merlin.hide]) ) + | Filter_itself -> + ( ((Printer.type_to_string ty : Stdlib.String.t) [@merlin.hide]), + "tuple" ) + in + Partial ([], [ Errors.type_mismatch ~expected ~actual ~loc ]) + : typ list Local_diagnostics.partial_info) -let filter_array_like_pattern (ty : typ) (loc : Rloc.t) : - typ Local_diagnostics.partial_info = - match type_repr ty with - | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> - Ok (Stype.new_type_var Tvar_error) - | T_constr { type_constructor = p; tys = ty_arg :: [] } - when Type_path.can_use_array_pattern p -> - Ok ty_arg - | _ -> - Partial - ( Stype.new_type_var Tvar_error, - [ - Errors.type_mismatch - ~actual:"Array Like(Array, FixedArray, or ArrayView)" - ~expected:(Printer.type_to_string ty) - ~loc; - ] ) +let filter_array_like_pattern (ty : typ) (loc : Rloc.t) = + (match type_repr ty with + | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> + Ok (Stype.new_type_var Tvar_error) + | T_constr { type_constructor = p; tys = ty_arg :: [] } + when Type_path.can_use_array_pattern p -> + Ok ty_arg + | T_builtin T_string -> Ok Stype.char + | T_constr { type_constructor; _ } + when Type_path.is_bytesview type_constructor -> + Ok Stype.byte + | T_constr { type_constructor = p; _ } + when Type_path.equal p Type_path.Builtin.type_path_stringview -> + Ok Stype.char + | _ -> + Partial + ( Stype.new_type_var Tvar_error, + [ + Errors.type_mismatch + ~actual: + "Array Like(Array, FixedArray, @array.View, @bytes.View, \ + String, or @string.View)" + ~expected:(Printer.type_to_string ty) + ~loc; + ] ) + : typ Local_diagnostics.partial_info) -let rec same_type (ty1 : typ) (ty2 : typ) : bool = - let ty1 = type_repr ty1 in - let ty2 = type_repr ty2 in - Basic_prelude.phys_equal ty1 ty2 - || - match ty1 with - | Tvar _ -> false - | Tarrow { params_ty = ps1; ret_ty = r1; err_ty = e1 } -> ( - match ty2 with - | Tarrow { params_ty = ps2; ret_ty = r2; err_ty = e2 } -> ( - Lst.for_all2_no_exn ps1 ps2 same_type - && same_type r1 r2 - && - match (e1, e2) with - | Some e1, Some e2 -> same_type e1 e2 - | None, None -> true - | _ -> false) - | _ -> false) - | T_constr { type_constructor = p1; tys = tys1 } -> ( - match ty2 with - | T_constr { type_constructor = p2; tys = tys2 } -> - Type_path.equal p1 p2 && Lst.for_all2_no_exn tys1 tys2 same_type - | _ -> false) - | Tparam { index = i1 } -> ( - match ty2 with Tparam { index = i2 } -> i1 = i2 | _ -> false) - | T_trait t1 -> ( - match ty2 with T_trait t2 -> Type_path.equal t1 t2 | _ -> false) - | T_builtin x -> ( - match ty2 with T_builtin y -> Stype.equal_builtin x y | _ -> false) - | T_blackhole -> ( match ty2 with T_blackhole -> true | _ -> false) +let rec same_type (ty1 : typ) (ty2 : typ) = + (let ty1 = type_repr ty1 in + let ty2 = type_repr ty2 in + Basic_prelude.phys_equal ty1 ty2 + || + match ty1 with + | Tvar _ -> false + | Tarrow { params_ty = ps1; ret_ty = r1; err_ty = e1; is_async = a1 } -> ( + match ty2 with + | Tarrow { params_ty = ps2; ret_ty = r2; err_ty = e2; is_async = a2 } + -> ( + Lst.for_all2_no_exn ps1 ps2 same_type + && same_type r1 r2 && a1 = a2 + && + match (e1, e2) with + | Some e1, Some e2 -> same_type e1 e2 + | None, None -> true + | _ -> false) + | _ -> false) + | T_constr { type_constructor = p1; tys = tys1 } -> ( + match ty2 with + | T_constr { type_constructor = p2; tys = tys2 } -> + Type_path.equal p1 p2 && Lst.for_all2_no_exn tys1 tys2 same_type + | _ -> false) + | Tparam { index = i1 } -> ( + match ty2 with Tparam { index = i2 } -> i1 = i2 | _ -> false) + | T_trait t1 -> ( + match ty2 with T_trait t2 -> Type_path.equal t1 t2 | _ -> false) + | T_builtin x -> ( + match ty2 with T_builtin y -> Stype.equal_builtin x y | _ -> false) + | T_blackhole -> ( match ty2 with T_blackhole -> true | _ -> false) + : bool) let classify_as_builtin (t : Stype.t) = match type_repr t with @@ -214,77 +246,66 @@ let classify_as_builtin (t : Stype.t) = | T_double -> `Double | T_char -> `Char | T_byte -> `Byte + | T_int16 -> `Int16 + | T_uint16 -> `UInt16 | T_string | T_unit | T_bool | T_bytes -> `Other) | _ -> `Other -let deref_constr_type (t : Stype.t) : - Stype.t * Basic_constr_info.constr_tag option = - match type_repr t with - | T_constr - { - type_constructor = Constr { ty; tag }; - tys; - generic_; - only_tag_enum_; - is_suberror_; - } -> - ( T_constr - { type_constructor = ty; tys; generic_; only_tag_enum_; is_suberror_ }, - Some tag ) - | ty -> (ty, None) +let deref_constr_type (t : Stype.t) = + (match type_repr t with + | T_constr + { type_constructor = Constr { ty; tag }; tys; generic_; is_suberror_ } -> + ( T_constr { type_constructor = ty; tys; generic_; is_suberror_ }, + Some tag ) + | ty -> (ty, None) + : Stype.t * Basic_constr_info.constr_tag option) -let deref_constr_type_to_local_value (t : Stype.t) : - Stype.t * Typedtree.value_kind = - match type_repr t with - | T_constr - { - type_constructor = Constr { ty; tag }; - tys; - generic_; - only_tag_enum_; - is_suberror_; - } -> - ( T_constr - { type_constructor = ty; tys; generic_; only_tag_enum_; is_suberror_ }, - Value_constr tag ) - | ty -> (ty, Normal) +let deref_constr_type_to_local_value (t : Stype.t) = + (match type_repr t with + | T_constr + { type_constructor = Constr { ty; tag }; tys; generic_; is_suberror_ } -> + ( T_constr { type_constructor = ty; tys; generic_; is_suberror_ }, + Value_constr tag ) + | ty -> (ty, Normal) + : Stype.t * Typedtree.value_kind) -let make_constr_type (t : Stype.t) ~(tag : Basic_constr_info.constr_tag) : - Stype.t = - match type_repr t with - | T_constr { type_constructor; tys; generic_; only_tag_enum_; is_suberror_ } - -> - T_constr - { - type_constructor = Type_path.constr ~ty:type_constructor ~tag; - tys; - generic_; - only_tag_enum_; - is_suberror_; - } - | ty -> ty +let make_constr_type (t : Stype.t) ~(tag : Basic_constr_info.constr_tag) = + (match type_repr t with + | T_constr { type_constructor; tys; generic_; is_suberror_ } -> + T_constr + { + type_constructor = Type_path.constr ~ty:type_constructor ~tag; + tys; + generic_; + is_suberror_; + } + | ty -> ty + : Stype.t) -let is_super_error (ty : Stype.t) : bool = - match type_repr ty with - | T_constr { type_constructor = Basic_type_path.T_error; _ } -> true - | _ -> false +let is_super_error (ty : Stype.t) = + (match type_repr ty with + | T_constr { type_constructor = Basic_type_path.T_error; _ } -> true + | _ -> false + : bool) -let is_suberror (ty : Stype.t) : bool = - match type_repr ty with - | T_constr { is_suberror_; _ } -> is_suberror_ - | _ -> false +let is_suberror (ty : Stype.t) = + (match type_repr ty with + | T_constr { is_suberror_; _ } -> is_suberror_ + | _ -> false + : bool) -let is_error_type ~tvar_env (ty : Stype.t) : bool = - match type_repr ty with - | T_constr { type_constructor = T_error; _ } -> true - | T_constr { is_suberror_; _ } -> is_suberror_ - | Tparam { index } -> - let tparam_info = Tvar_env.find_by_index_exn tvar_env index in - Lst.exists tparam_info.constraints (fun c -> - Type_path.equal c.trait Type_path.Builtin.type_path_error) - | Tvar _ -> true - | T_blackhole -> true - | T_builtin _ | Tarrow _ | T_trait _ -> false +let is_error_type ~tvar_env (ty : Stype.t) = + (match type_repr ty with + | T_constr { type_constructor = T_error; _ } -> true + | T_constr { is_suberror_; _ } -> is_suberror_ + | Tparam { index } -> + let tparam_info = Tvar_env.find_by_index_exn tvar_env index in + Lst.exists tparam_info.constraints (fun c -> + Type_path.equal c.trait Type_path.Builtin.type_path_error) + | Tvar _ -> true + | T_blackhole -> true + | T_builtin _ | Tarrow _ | T_trait _ -> false + : bool) let is_array_like ty = match type_repr ty with @@ -304,5 +325,7 @@ let is_array_like ty = | T_builtin T_double | T_builtin T_unit | T_builtin T_bool + | T_builtin T_int16 + | T_builtin T_uint16 | Tparam _ | Tvar _ | T_blackhole | Tarrow _ | T_trait _ -> false diff --git a/src/type_alias.ml b/src/type_alias.ml new file mode 100644 index 0000000..1dd166b --- /dev/null +++ b/src/type_alias.ml @@ -0,0 +1,106 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Type_path = Basic_type_path + +type alias_target = + | Type_alias of Stype.t + | Trait_alias of { trait : Type_path.t } + +include struct + let _ = fun (_ : alias_target) -> () + + let sexp_of_alias_target = + (function + | Type_alias arg0__001_ -> + let res0__002_ = Stype.sexp_of_t arg0__001_ in + S.List [ S.Atom "Type_alias"; res0__002_ ] + | Trait_alias { trait = trait__004_ } -> + let bnds__003_ = ([] : _ Stdlib.List.t) in + let bnds__003_ = + let arg__005_ = Type_path.sexp_of_t trait__004_ in + (S.List [ S.Atom "trait"; arg__005_ ] :: bnds__003_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Trait_alias" :: bnds__003_) + : alias_target -> S.t) + + let _ = sexp_of_alias_target +end + +type t = { + name : string; + arity : int; + ty_params : Tvar_env.t; + target : alias_target; + is_pub : bool; + doc_ : Docstring.t; + loc_ : Loc.t; [@sexp_drop_if fun _ -> not !Basic_config.show_loc] +} + +include struct + let _ = fun (_ : t) -> () + + let sexp_of_t = + (let (drop_if__020_ : Loc.t -> Stdlib.Bool.t) = + fun _ -> not !Basic_config.show_loc + in + fun { + name = name__007_; + arity = arity__009_; + ty_params = ty_params__011_; + target = target__013_; + is_pub = is_pub__015_; + doc_ = doc___017_; + loc_ = loc___021_; + } -> + let bnds__006_ = ([] : _ Stdlib.List.t) in + let bnds__006_ = + if drop_if__020_ loc___021_ then bnds__006_ + else + let arg__023_ = Loc.sexp_of_t loc___021_ in + let bnd__022_ = S.List [ S.Atom "loc_"; arg__023_ ] in + (bnd__022_ :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__018_ = Docstring.sexp_of_t doc___017_ in + (S.List [ S.Atom "doc_"; arg__018_ ] :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__016_ = Moon_sexp_conv.sexp_of_bool is_pub__015_ in + (S.List [ S.Atom "is_pub"; arg__016_ ] :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__014_ = sexp_of_alias_target target__013_ in + (S.List [ S.Atom "target"; arg__014_ ] :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__012_ = Tvar_env.sexp_of_t ty_params__011_ in + (S.List [ S.Atom "ty_params"; arg__012_ ] :: bnds__006_ + : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__010_ = Moon_sexp_conv.sexp_of_int arity__009_ in + (S.List [ S.Atom "arity"; arg__010_ ] :: bnds__006_ : _ Stdlib.List.t) + in + let bnds__006_ = + let arg__008_ = Moon_sexp_conv.sexp_of_string name__007_ in + (S.List [ S.Atom "name"; arg__008_ ] :: bnds__006_ : _ Stdlib.List.t) + in + S.List bnds__006_ + : t -> S.t) + + let _ = sexp_of_t +end diff --git a/src/type_args.ml b/src/type_args.ml index 4620d59..ebd0237 100644 --- a/src/type_args.ml +++ b/src/type_args.ml @@ -32,10 +32,11 @@ let rec equal_typ (x : Stype.t) (y : Stype.t) = let x = Stype.type_repr x in let y = Stype.type_repr y in match x with - | Tarrow { params_ty = ts1; ret_ty = t1; err_ty = _ } -> ( + | Tarrow { params_ty = ts1; ret_ty = t1; err_ty = e1; is_async = a1 } -> ( match y with - | Tarrow { params_ty = ts2; ret_ty = t2; err_ty = _ } -> - equal_typs ts1 ts2 && equal_typ t1 t2 + | Tarrow { params_ty = ts2; ret_ty = t2; err_ty = e2; is_async = a2 } -> + equal_typs ts1 ts2 && equal_typ t1 t2 && equal_typ_option e1 e2 + && a1 = a2 | T_trait _ | T_constr _ | T_builtin _ -> false | Tvar _ | Tparam _ | T_blackhole -> assert false) | T_constr { type_constructor = c1; tys = ts1 } -> ( @@ -51,7 +52,9 @@ let rec equal_typ (x : Stype.t) (y : Stype.t) = | Tvar _ | Tparam _ | T_blackhole -> assert false) | T_builtin a -> ( match y with T_builtin b -> Stype.equal_builtin a b | _ -> false) - | Tvar _ | Tparam _ | T_blackhole -> assert false + | Tparam _ -> assert false + | Tvar _ -> assert false + | T_blackhole -> assert false and equal_typs (xs : Stype.t list) (ys : Stype.t list) = match xs with @@ -61,6 +64,11 @@ and equal_typs (xs : Stype.t list) (ys : Stype.t list) = | y :: rest2 -> equal_typ x y && equal_typs rest1 rest2 | _ -> false) +and equal_typ_option (x : Stype.t option) (y : Stype.t option) = + match x with + | None -> y = None + | Some x -> ( match y with Some y -> equal_typ x y | None -> false) + let equal (xs : t) (ys : t) = Arr.for_all2_no_exn xs ys equal_typ let ( +> ) = Buffer.add_char let ( +>> ) = Buffer.add_string @@ -69,7 +77,7 @@ let append_typ_to_buffer (buf : Buffer.t) (ty : Stype.t) = let rec go (ty : Stype.t) = let ty = Stype.type_repr ty in match ty with - | Tarrow { params_ty; ret_ty; err_ty } -> ( + | Tarrow { params_ty; ret_ty; err_ty; is_async = _ } -> ( buf +> '<'; (match params_ty with | [] -> () @@ -102,6 +110,8 @@ let append_typ_to_buffer (buf : Buffer.t) (ty : Stype.t) = | T_builtin T_unit -> buf +>> "Unit" | T_builtin T_bool -> buf +>> "Bool" | T_builtin T_byte -> buf +>> "Byte" + | T_builtin T_int16 -> buf +>> "Int16" + | T_builtin T_uint16 -> buf +>> "UInt16" | T_builtin T_char -> buf +>> "Char" | T_builtin T_int -> buf +>> "Int" | T_builtin T_int64 -> buf +>> "Int64" @@ -111,7 +121,9 @@ let append_typ_to_buffer (buf : Buffer.t) (ty : Stype.t) = | T_builtin T_double -> buf +>> "Double" | T_builtin T_string -> buf +>> "String" | T_builtin T_bytes -> buf +>> "Bytes" - | Tparam _ | Tvar _ | T_blackhole -> assert false + | Tvar _ -> assert false + | Tparam _ -> assert false + | T_blackhole -> assert false and gos (sep : char) = function | [] -> () | ty :: [] -> go ty @@ -122,13 +134,16 @@ let append_typ_to_buffer (buf : Buffer.t) (ty : Stype.t) = in go ty -let mangle (tys : t) : string = - let buf = Buffer.create 16 in - tys - |> Array.iteri (fun i ty -> - if i > 0 then Buffer.add_string buf "+"; - append_typ_to_buffer buf ty); - Buffer.contents buf +let mangle (tys : t) = + (let buf = Buffer.create 16 in + Array.iteri + (fun i -> + fun ty -> + if i > 0 then Buffer.add_string buf "+"; + append_typ_to_buffer buf ty) + tys; + Buffer.contents buf + : string) let mangle_ty (ty : Stype.t) = let buf = Buffer.create 16 in diff --git a/src/type_constraint.ml b/src/type_constraint.ml index 6f0e7d1..acd3561 100644 --- a/src/type_constraint.ml +++ b/src/type_constraint.ml @@ -41,6 +41,7 @@ type indirect_trait_source = | Poly_method of (string * Stype.t * Loc.t) | Impl of { type_name : Type_path.t; trait : Type_path.t; loc : Loc.t } | Super_trait of Type_path.t + | Static_assert of string type trait_resolution_error = { self_ty : Stype.t; @@ -62,8 +63,10 @@ let ambiguous_method ~ty ~method_name ~src ~first ~second ~loc = let second = Type_path_util.name second in let label = match src with - | Dot_src_infix op -> ("Operator \"" ^ op.op_name ^ "\"" : Stdlib.String.t) - | Dot_src_direct -> ("Method " ^ method_name : Stdlib.String.t) + | Dot_src_infix op -> + ("Operator \"" ^ op.op_name ^ "\"" : Stdlib.String.t) [@merlin.hide] + | Dot_src_direct -> + ("Method " ^ method_name : Stdlib.String.t) [@merlin.hide] in Errors.ambiguous_trait_method ~label ~ty ~first ~second ~loc @@ -88,6 +91,7 @@ let cannot_resolve_trait (err : trait_resolution_error) ~loc = (Loc.to_string loc) | Super_trait trait -> Printf.bprintf buf "required by trait %s" (Type_path_util.name trait) + | Static_assert msg -> Printf.bprintf buf "required by %s" msg [@@inline] in match List.rev reqs with @@ -95,7 +99,7 @@ let cannot_resolve_trait (err : trait_resolution_error) ~loc = | first :: rest -> Printf.bprintf buf "\n note: this constraint is "; print_requirement buf first; - Lst.iter rest (fun req -> + Lst.iter rest ~f:(fun req -> Printf.bprintf buf "\n - which is "; print_requirement buf req) in @@ -152,7 +156,7 @@ let cannot_resolve_trait (err : trait_resolution_error) ~loc = print_reason buf only_reason | _ -> Printf.bprintf buf ":"; - Lst.iter reasons (fun reason -> + Lst.iter reasons ~f:(fun reason -> Printf.bprintf buf "\n - "; print_reason buf reason)); print_require_list buf required_by); @@ -169,28 +173,33 @@ type method_info = } let find_method_from_constraints ~global_env - (cs : Tvar_env.type_constraint list) method_name : - (Type_path.t * Trait_decl.method_decl) list = - Lst.fold_right cs [] (fun { trait } acc -> - match Global_env.find_trait_by_path global_env trait with - | None -> acc - | Some { vis_ = Vis_default; _ } when Type_path_util.is_foreign trait -> - acc - | Some trait_decl -> ( - match - Lst.find_opt trait_decl.methods (fun meth_decl -> - if meth_decl.method_name = method_name then - Some (trait, meth_decl) - else None) - with - | Some x -> x :: acc - | None -> acc)) + (cs : Tvar_env.type_constraint list) method_name = + (Lst.fold_right cs [] (fun { trait } -> + fun acc -> + match Global_env.find_trait_by_path global_env trait with + | None -> acc + | Some { vis_ = Vis_default; _ } when Type_path_util.is_foreign trait -> + acc + | Some trait_decl -> ( + match + Lst.find_opt trait_decl.methods (fun meth_decl -> + if meth_decl.method_name = method_name then + Some (trait, meth_decl) + else None) + with + | Some x -> x :: acc + | None -> acc)) + : (Type_path.t * Trait_decl.method_decl) list) let resolve_method_by_type_name (type_name : Typedtree.type_name) - (method_name : string) ~is_trait ~loc ~tvar_env ~global_env = + (method_name : string) ~loc ~tvar_env ~global_env = let type_name_to_string type_name = match (type_name : Typedtree.type_name) with | Tname_tvar { index = _; name_ } -> name_ + | Tname_path { name = p; kind = Trait } -> + "&" + ^ Type_path.short_name + ~cur_pkg_name:(Some !Basic_config.current_package) p | Tname_path { name = p; kind = _ } | Tname_alias { name = p; kind = _ } -> Type_path.short_name ~cur_pkg_name:(Some !Basic_config.current_package) p @@ -199,9 +208,7 @@ let resolve_method_by_type_name (type_name : Typedtree.type_name) Error (cannot_resolve_method ~ty:(type_name_to_string type_name) - ~name:method_name ~src:Dot_src_direct - ~hint:(if is_trait then `Trait else `No_hint) - ~loc) + ~name:method_name ~src:Dot_src_direct ~hint:`No_hint ~loc) in match type_name with | Tname_tvar { index; name_ } -> ( @@ -271,26 +278,35 @@ let resolve_method_by_type (ty : Stype.t) (method_name : string) ~loc ~src let pkg = Type_path.get_pkg p in if pkg = !Basic_config.current_package - || Option.is_some - (Pkg.find_pkg_opt (Global_env.get_pkg_tbl global_env) ~pkg) + || + match Pkg.find_pkg_opt (Global_env.get_pkg_tbl global_env) ~pkg with + | Some _ -> true + | _ -> false then - let hint = - if is_trait then `Trait - else - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = Record_type { fields }; _ } - when Lst.exists fields (fun { field_name; _ } -> - field_name = method_name) -> - `Record - | _ -> `No_hint - in - error ~hint + if is_trait then + match Global_env.find_trait_by_path global_env p with + | Some { vis_ = Vis_default; _ } when Type_path_util.is_foreign p -> + Error + (Errors.cannot_use_method_of_abstract_trait ~trait:p + ~method_name ~loc) + | _ -> error ~hint:`Trait + else + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = Record_type { fields }; _ } + when Lst.exists fields (fun { field_name; _ } -> + field_name = method_name) -> + error ~hint:`Record + | _ -> error ~hint:`No_hint else + let type_name = + (if is_trait then "&" else "") ^ Type_path_util.name p + in Error (Errors.pkg_not_imported ~name:pkg ~action: - ("call method of type " ^ Type_path_util.name p + (("call method of type " ^ type_name : Stdlib.String.t) + [@merlin.hide]) ~loc) in let ty = Stype.type_repr ty in @@ -319,47 +335,7 @@ let resolve_method_by_type (ty : Stype.t) (method_name : string) ~loc ~src (ambiguous_method ~ty:ty_name ~method_name ~src:Dot_src_direct ~first:trait1 ~second:trait2 ~loc) | _ -> error ~hint:`No_hint) - | T_trait trait -> ( - match[@warning "-fragile-match"] - Global_env.find_trait_by_path global_env trait - with - | Some trait_decl -> ( - match trait_decl.vis_ with - | Vis_default when Type_path_util.is_foreign trait -> - Error - (Errors.cannot_use_method_of_abstract_trait ~trait ~method_name - ~loc) - | _ -> ( - let candidates = ref [] in - trait_decl.closure_methods - |> List.iteri - (fun - index (trait', (method_decl : Trait_decl.method_decl)) -> - if method_decl.method_name = method_name then - candidates := (index, trait', method_decl) :: !candidates); - match !candidates with - | [] -> resolve_by_type_path ~is_trait:true trait - | (method_index, _, meth_decl) :: [] -> - Ok - (Promised_method - { - method_id = - Ident.of_object_method ~trait ~method_name - ~method_index; - method_ty = - Poly_type.instantiate_method_decl meth_decl ~self:ty; - method_arity = meth_decl.method_arity; - prim = - Some - (Pcall_object_method { method_index; method_name }); - }) - | (_, trait2, _) :: (_, trait1, _) :: _ -> - Error - (ambiguous_method - ~ty:(Type_path_util.name trait) - ~method_name ~src:Dot_src_direct ~first:trait1 - ~second:trait2 ~loc))) - | _ -> assert false) + | T_trait trait -> resolve_by_type_path ~is_trait:true trait | T_constr { type_constructor = p; _ } -> resolve_by_type_path ~is_trait:false p | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> @@ -372,7 +348,7 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = let hty_cache = Hashed_type.make_cache () in let cache : trait_resolution_error Cache.t = Cache.create 17 in let exception Resolve_failure of trait_resolution_error in - let solve_with_regular_methods ~self_ty ~type_name ~trait ~is_trait_object = + let solve_with_regular_methods ~self_ty ~type_name ~trait ~root_loc = match Global_env.find_trait_by_path global_env trait with | None -> ([ Trait_not_imported ], []) | Some { vis_ = (Vis_default | Vis_readonly) as trait_vis; _ } @@ -381,8 +357,9 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = | Some trait_decl -> ( let new_constraints = ref [] in let failures = Vec.empty () in + let regular_impls = Vec.empty () in let () = - Lst.iter trait_decl.methods (fun method_decl -> + Lst.iter trait_decl.methods ~f:(fun method_decl -> let method_name = method_decl.method_name in let check_method_type actual_arity actual = let exception Arity_mismatch in @@ -423,47 +400,51 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = match err_opt with | Some err -> Vec.push failures err | None -> - Poly_type.iter aux_cenv ~f:(fun a b -> - let new_constraint_source = - Poly_method (method_name, self_ty, method_info.loc) - in - new_constraints := - (new_constraint_source, a, b) :: !new_constraints)) - | None when is_trait_object -> ( - match[@warning "-fragile-match"] - Global_env.find_trait_by_path global_env type_name - with - | Some obj_trait_def -> ( - match - Lst.find_first obj_trait_def.methods (fun meth_decl -> - meth_decl.method_name = method_name) - with - | None -> Vec.push failures (Method_missing method_name) - | Some meth_decl -> - check_method_type meth_decl.method_arity - (Poly_type.instantiate_method_decl meth_decl - ~self:self_ty) - |> Option.iter (Vec.push failures)) - | _ -> assert false) + (match method_info.id with + | Qmethod _ -> Vec.push regular_impls method_name + | Qregular _ | Qregular_implicit_pkg _ | Qext_method _ -> + ()); + Poly_type.iter aux_cenv ~f:(fun a -> + fun b -> + let new_constraint_source = + Poly_method (method_name, self_ty, method_info.loc) + in + new_constraints := + (new_constraint_source, a, b) :: !new_constraints)) | None -> Vec.push failures (Method_missing method_name)) in + if not (Vec.is_empty regular_impls) then + Local_diagnostics.add_warning diagnostics + { + kind = + Implement_trait_with_method + { + trait = Type_path_util.name trait; + typ = Printer.type_to_string self_ty; + methods = Vec.to_list regular_impls; + }; + loc = root_loc; + }; let failures = Vec.to_list failures in let pkg = Type_path.get_pkg type_name in match failures with | _ :: _ when pkg <> !Basic_config.current_package - && Option.is_none - (Pkg.find_pkg_opt (Global_env.get_pkg_tbl global_env) ~pkg) - -> + && + match + Pkg.find_pkg_opt (Global_env.get_pkg_tbl global_env) ~pkg + with + | None -> true + | _ -> false -> ([ Pkg_not_imported { pkg } ], !new_constraints) | _ -> (failures, !new_constraints)) in - let do_solve (self_ty : Stype.t) ({ trait } : Tvar_env.type_constraint) = + let do_solve (self_ty : Stype.t) ({ trait } : Tvar_env.type_constraint) + ~root_loc = let self_ty = Stype.type_repr self_ty in - let solve_type_path type_name ~is_trait_object = + let solve_type_path type_name = match Global_env.find_trait_impl global_env ~trait ~type_name with - | None -> - solve_with_regular_methods ~self_ty ~type_name ~trait ~is_trait_object + | None -> solve_with_regular_methods ~self_ty ~type_name ~trait ~root_loc | Some impl -> let aux_cenv = Poly_type.make () in let actual_self_ty = @@ -472,12 +453,13 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = in if Ctype.try_unify self_ty actual_self_ty then ( let new_constraints = ref [] in - Poly_type.iter aux_cenv ~f:(fun a b -> - let new_constraint_source = - Impl { trait; type_name; loc = impl.loc_ } - in - new_constraints := - (new_constraint_source, a, b) :: !new_constraints); + Poly_type.iter aux_cenv ~f:(fun a -> + fun b -> + let new_constraint_source = + Impl { trait; type_name; loc = impl.loc_ } + in + new_constraints := + (new_constraint_source, a, b) :: !new_constraints); ([], !new_constraints)) else let err = @@ -506,16 +488,9 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = | None | Some { methods = []; _ } -> ([], []) | Some _ -> ([ No_trait_bound ], [])) | T_trait obj_trait when Type_path.equal obj_trait trait -> ([], []) - | T_trait obj_trait -> - let obj_trait_def = - Global_env.find_trait_by_path global_env obj_trait |> Option.get - in - if Lst.exists obj_trait_def.closure (Type_path.equal trait) then ([], []) - else solve_type_path obj_trait ~is_trait_object:true - | T_constr { type_constructor = p; tys = _ } -> - solve_type_path p ~is_trait_object:false - | T_builtin b -> - solve_type_path (Stype.tpath_of_builtin b) ~is_trait_object:false + | T_trait obj_trait -> solve_type_path obj_trait + | T_constr { type_constructor = p; tys = _ } -> solve_type_path p + | T_builtin b -> solve_type_path (Stype.tpath_of_builtin b) | _ -> ( match Global_env.find_trait_by_path global_env trait with | None -> ([], []) @@ -524,22 +499,27 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = Method_missing method_name), [] )) in - let rec solve self_ty - ({ trait; required_by_ = supers } as c : Tvar_env.type_constraint) = + let rec solve self_ty ({ trait; src_ } as c : Tvar_env.type_constraint) + ~root_loc = let hty = Hashed_type.of_stype hty_cache self_ty in match Cache.find_opt cache (hty, trait) with | Some Success -> () | Some (Failure err) -> raise_notrace (Resolve_failure err) | None -> ( Cache.add cache (hty, trait) Success; - match do_solve self_ty c with + match do_solve self_ty c ~root_loc with | (_ :: _ as reasons), _ -> let err = { self_ty; trait; reasons; - required_by = List.rev_map (fun t -> Super_trait t) supers; + required_by = + (match src_ with + | Super_traits supers -> + List.rev_map (fun t -> Super_trait t) supers + | Static_assert msg -> [ Static_assert msg ] + | Direct -> []); } in Cache.add cache (hty, trait) (Failure err); @@ -547,10 +527,10 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = | [], new_constraints -> let parent_self_ty = self_ty in let parent_trait = trait in - Lst.iter new_constraints (fun (src, self_ty, c) -> - try solve self_ty c with + Lst.iter new_constraints ~f:(fun (new_src, self_ty, c) -> + try solve self_ty c ~root_loc with | Hashed_type.Unresolved_type_variable -> ( - match[@warning "-fragile-match"] src with + match[@warning "-fragile-match"] new_src with | Poly_method (_, _, loc) | Impl { loc; _ } -> raise_notrace (Resolve_failure @@ -564,11 +544,13 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = | Resolve_failure err -> let err = let required_by = - match supers with - | [] -> src :: err.required_by - | supers -> + match src_ with + | Direct -> new_src :: err.required_by + | Static_assert msg -> + Static_assert msg :: new_src :: err.required_by + | Super_traits supers -> Lst.rev_map_append supers - (Super_trait trait :: src :: err.required_by) + (Super_trait trait :: new_src :: err.required_by) (fun t -> Super_trait t) in { err with required_by } @@ -577,8 +559,9 @@ let solve_constraints (cenv : Poly_type.t) ~tvar_env ~global_env ~diagnostics = raise_notrace (Resolve_failure err)); Cache.add cache (hty, trait) Success) in - Poly_type.iter cenv ~f:(fun self_ty c -> - try solve self_ty c - with Resolve_failure err -> - Local_diagnostics.add_error diagnostics - (cannot_resolve_trait err ~loc:c.loc_)) + Poly_type.iter cenv ~f:(fun self_ty -> + fun c -> + try solve self_ty c ~root_loc:c.loc_ + with Resolve_failure err -> + Local_diagnostics.add_error diagnostics + (cannot_resolve_trait err ~loc:c.loc_)) diff --git a/src/type_lint.ml b/src/type_lint.ml index c842442..46e20ad 100644 --- a/src/type_lint.ml +++ b/src/type_lint.ml @@ -28,11 +28,11 @@ let lint_typ loc outmost_typ ~diagnostics = in Local_diagnostics.add_warning diagnostics { kind = warn; loc }); link := Tlink type_unit - | Tarrow { params_ty; ret_ty; err_ty } -> ( - Lst.iter params_ty go; + | Tarrow { params_ty; ret_ty; err_ty; is_async = _ } -> ( + Lst.iter params_ty ~f:go; go ret_ty; match err_ty with None -> () | Some ty -> go ty) - | T_constr { tys; type_constructor = _ } -> Lst.iter tys go + | T_constr { tys; type_constructor = _ } -> Lst.iter tys ~f:go | Tparam _ | T_trait _ | T_builtin _ | T_blackhole -> () in go outmost_typ @@ -80,7 +80,7 @@ let lint_obj = | Texpr_unresolved_method { self_type; loc_; _ } -> lint_typ ~diagnostics loc_ self_type | _ -> self#visit_expr diagnostics func); - Lst.iter args (self#visit_argument diagnostics) + Lst.iter args ~f:(self#visit_argument diagnostics) method! visit_Pipe_partial_apply diagnostics func args _loc = (match func with @@ -91,16 +91,17 @@ let lint_obj = | Texpr_unresolved_method { self_type; loc_; _ } -> lint_typ ~diagnostics loc_ self_type | _ -> self#visit_expr diagnostics func); - Lst.iter args (self#visit_argument diagnostics) + Lst.iter args ~f:(self#visit_argument diagnostics) method! visit_Texpr_try diagnostics body catch _catch_all try_else ty err_ty _catch_loc _else_loc loc = self#visit_expr diagnostics body; - Lst.iter catch (fun case -> self#visit_match_case diagnostics case); + Lst.iter catch ~f:(fun case -> self#visit_match_case diagnostics case); (match try_else with | None -> () | Some try_else -> - Lst.iter try_else (fun case -> self#visit_match_case diagnostics case)); + Lst.iter try_else ~f:(fun case -> + self#visit_match_case diagnostics case)); lint_typ ~diagnostics loc ty; lint_typ ~diagnostics loc err_ty @@ -116,7 +117,7 @@ let type_lint (expr : Typedtree.expr) ~diagnostics = let type_lint_fn (fn : Typedtree.fn) ~diagnostics = type_lint fn.body ~diagnostics; - Lst.iter fn.params (fun (Param { kind; _ }) -> - match kind with - | Optional default -> type_lint default ~diagnostics + Lst.iter fn.params ~f:(fun p -> + match p with + | Param { kind = Optional default; _ } -> type_lint default ~diagnostics | _ -> ()) diff --git a/src/type_subst.ml b/src/type_subst.ml index 3111885..a6871f3 100644 --- a/src/type_subst.ml +++ b/src/type_subst.ml @@ -22,37 +22,38 @@ type t = Stype.t array let make typ_instances = typ_instances let empty () = [||] -let monofy_param (env : t) ~(index : int) : Type_path.t = - match Stype.type_repr env.!(index) with - | T_constr { type_constructor = p; tys = _ } -> p - | T_trait t -> t - | T_builtin b -> Stype.tpath_of_builtin b - | Tarrow _ | Tvar _ | Tparam _ | T_blackhole -> assert false +let monofy_param (env : t) ~(index : int) = + (match Stype.type_repr env.!(index) with + | T_constr { type_constructor = p; tys = _ } -> p + | T_trait t -> t + | T_builtin b -> Stype.tpath_of_builtin b + | Tparam _ -> assert false + | Tarrow _ -> assert false + | Tvar _ -> assert false + | T_blackhole -> assert false + : Type_path.t) -let monofy_typ (env : t) (t : Stype.t) : Stype.t = - let rec go (t : Stype.t) : Stype.t = - match Stype.type_repr t with - | Tarrow { params_ty; ret_ty; err_ty } -> - Tarrow - { - params_ty = gos params_ty; - ret_ty = go ret_ty; - generic_ = false; - err_ty = Option.map go err_ty; - } - | Tvar _ | T_blackhole -> assert false - | T_constr { type_constructor; tys; only_tag_enum_; is_suberror_ } -> - let tys = gos tys in - T_constr - { - type_constructor; - tys; - generic_ = false; - only_tag_enum_; - is_suberror_; - } - | T_trait _ as t -> t - | Tparam { index } -> env.!(index) - | T_builtin _ as t -> t - and gos (ts : Stype.t list) = Lst.map ts go in - go t +let monofy_typ (env : t) (t : Stype.t) = + (let rec go (t : Stype.t) = + (match Stype.type_repr t with + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> + Tarrow + { + params_ty = gos params_ty; + ret_ty = go ret_ty; + generic_ = false; + err_ty = Option.map go err_ty; + is_async; + } + | Tvar _ -> assert false + | T_blackhole -> assert false + | T_constr { type_constructor; tys; is_suberror_ } -> + let tys = gos tys in + T_constr { type_constructor; tys; generic_ = false; is_suberror_ } + | T_trait _ as t -> t + | Tparam { index } -> env.!(index) + | T_builtin _ as t -> t + : Stype.t) + and gos (ts : Stype.t list) = Lst.map ts go in + go t + : Stype.t) diff --git a/src/typecheck_driver_util.ml b/src/typecheck_driver_util.ml new file mode 100644 index 0000000..f89fd95 --- /dev/null +++ b/src/typecheck_driver_util.ml @@ -0,0 +1,42 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +let ( |-> ) obj callback = + callback obj; + obj + +type mi_input = Import_Path of string | Import_Path_Content of string * string +type std_input = Std_Path of string | Std_Content of (string * string) list + +let tast_of_ast ~diagnostics ~(build_context : Typeutil.build_context) + ~(quiet : bool) ~(genv_callback : Global_env.t -> unit) + ~(tast_callback : Typedtree.output -> unit) + ~(import_items : Pkg_config_util.import_items) ~(pkgs : Pkg.pkg_tbl) + ~(import_kind : Pkg_config_util.import_kind) + (asts : Parsing_parse.output list) = + (let asts = Basic_lst.map asts (fun a -> a.ast) in + let top_output = + Toplevel_typer.check_toplevel ~pkgs ~build_context asts ~diagnostics + in + let genv = top_output.global_env |-> genv_callback in + let tast = Typer.type_check top_output ~diagnostics in + if (not quiet) && not (Diagnostics.has_fatal_errors diagnostics) then + Check_match.analyze ~diagnostics (genv, tast); + let tast = Topo_sort.topo_sort tast ~diagnostics |-> tast_callback in + Global_env.report_unused_pkg ~diagnostics genv; + Dead_code.analyze_unused ~diagnostics ~import_items ~build_context + ~import_kind tast; + (tast, genv) + : Typedtree.output * Global_env.t) diff --git a/src/typedecl_info.ml b/src/typedecl_info.ml index 4662e4a..8c873f7 100644 --- a/src/typedecl_info.ml +++ b/src/typedecl_info.ml @@ -73,6 +73,14 @@ include struct let _ = sexp_of_docstring end +type attributes = Checked_attributes.t + +include struct + let _ = fun (_ : attributes) -> () + let sexp_of_attributes = (Checked_attributes.sexp_of_t : attributes -> S.t) + let _ = sexp_of_attributes +end + type visibility = Vis_priv | Vis_default | Vis_readonly | Vis_fully_pub include struct @@ -98,20 +106,21 @@ let hide_loc _ = not !Basic_config.show_loc class ['a] iterbase = object (self) - method visit_typ : 'a -> typ -> unit = fun _ _ -> () + method visit_typ : 'a -> typ -> unit = fun _ -> fun _ -> () - method private visit_type_constraint - : 'a -> Tvar_env.type_constraint -> unit = - fun _ _ -> () + method private visit_type_constraint : + 'a -> Tvar_env.type_constraint -> unit = + fun _ -> fun _ -> () method private visit_constr_tag : 'a -> Constr_info.constr_tag -> unit = - fun _ _ -> () + fun _ -> fun _ -> () method private visit_tvar_env : 'a -> tvar_env -> unit = - fun ctx env -> - Tvar_env.iter env (fun tvar_info -> - self#visit_typ ctx tvar_info.typ; - Lst.iter tvar_info.constraints (self#visit_type_constraint ctx)) + fun ctx -> + fun env -> + Tvar_env.iter env (fun tvar_info -> + self#visit_typ ctx tvar_info.typ; + Lst.iter tvar_info.constraints ~f:(self#visit_type_constraint ctx)) end type t = { @@ -122,6 +131,7 @@ type t = { ty_params_ : tvar_env; ty_loc_ : location; ty_doc_ : docstring; [@sexp_drop_if Docstring.is_empty] + ty_attrs : attributes; ty_is_only_tag_enum_ : bool; [@sexp_drop_if fun x -> x = false] ty_is_suberror_ : bool; [@sexp_drop_if fun x -> x = false] } @@ -180,181 +190,202 @@ include struct inherit [_] iterbase method visit_t : _ -> t -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.ty_constr - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.ty_arity - in - let _visitors_r2 = - self#visit_type_components env _visitors_this.ty_desc - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_this.ty_vis in - let _visitors_r4 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r5 = - (fun _visitors_this -> ()) _visitors_this.ty_loc_ - in - let _visitors_r6 = - (fun _visitors_this -> ()) _visitors_this.ty_doc_ - in - let _visitors_r7 = - (fun _visitors_this -> ()) _visitors_this.ty_is_only_tag_enum_ - in - let _visitors_r8 = - (fun _visitors_this -> ()) _visitors_this.ty_is_suberror_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.ty_constr + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.ty_arity + in + let _visitors_r2 = + self#visit_type_components env _visitors_this.ty_desc + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_this.ty_vis + in + let _visitors_r4 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_this.ty_loc_ + in + let _visitors_r6 = + (fun _visitors_this -> ()) _visitors_this.ty_doc_ + in + let _visitors_r7 = + (fun _visitors_this -> ()) _visitors_this.ty_attrs + in + let _visitors_r8 = + (fun _visitors_this -> ()) _visitors_this.ty_is_only_tag_enum_ + in + let _visitors_r9 = + (fun _visitors_this -> ()) _visitors_this.ty_is_suberror_ + in + () method private visit_constructors : _ -> constructors -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constructor env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constructor env) method private visit_fields : _ -> fields -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field env) method private visit_newtype_info : _ -> newtype_info -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_constructor env _visitors_this.newtype_constr - in - let _visitors_r1 = self#visit_typ env _visitors_this.underlying_typ in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.recursive - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_constructor env _visitors_this.newtype_constr + in + let _visitors_r1 = + self#visit_typ env _visitors_this.underlying_typ + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.recursive + in + () method private visit_Extern_type : _ -> unit = fun env -> () method private visit_Abstract_type : _ -> unit = fun env -> () method private visit_Error_type : _ -> constructor -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_constructor env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_constructor env _visitors_c0 in + () method private visit_ErrorEnum_type : _ -> constructor list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constructor env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constructor env)) + _visitors_c0 + in + () method private visit_New_type : _ -> newtype_info -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_newtype_info env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_newtype_info env _visitors_c0 in + () method private visit_Variant_type : _ -> constructor list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constructor env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constructor env)) + _visitors_c0 + in + () method private visit_Record_type : _ -> field list -> bool -> unit = - fun env _visitors_ffields _visitors_fhas_private_field_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field env)) - _visitors_ffields - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fhas_private_field_ - in - () + fun env -> + fun _visitors_ffields -> + fun _visitors_fhas_private_field_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field env)) + _visitors_ffields + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fhas_private_field_ + in + () method private visit_type_components : _ -> type_components -> unit = - fun env _visitors_this -> - match _visitors_this with - | Extern_type -> self#visit_Extern_type env - | Abstract_type -> self#visit_Abstract_type env - | Error_type _visitors_c0 -> self#visit_Error_type env _visitors_c0 - | ErrorEnum_type _visitors_c0 -> - self#visit_ErrorEnum_type env _visitors_c0 - | New_type _visitors_c0 -> self#visit_New_type env _visitors_c0 - | Variant_type _visitors_c0 -> - self#visit_Variant_type env _visitors_c0 - | Record_type - { - fields = _visitors_ffields; - has_private_field_ = _visitors_fhas_private_field_; - } -> - self#visit_Record_type env _visitors_ffields - _visitors_fhas_private_field_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Extern_type -> self#visit_Extern_type env + | Abstract_type -> self#visit_Abstract_type env + | Error_type _visitors_c0 -> self#visit_Error_type env _visitors_c0 + | ErrorEnum_type _visitors_c0 -> + self#visit_ErrorEnum_type env _visitors_c0 + | New_type _visitors_c0 -> self#visit_New_type env _visitors_c0 + | Variant_type _visitors_c0 -> + self#visit_Variant_type env _visitors_c0 + | Record_type + { + fields = _visitors_ffields; + has_private_field_ = _visitors_fhas_private_field_; + } -> + self#visit_Record_type env _visitors_ffields + _visitors_fhas_private_field_ method private visit_Invisible : _ -> unit = fun env -> () method private visit_Readable : _ -> unit = fun env -> () method private visit_Read_write : _ -> unit = fun env -> () - method private visit_type_component_visibility - : _ -> type_component_visibility -> unit = - fun env _visitors_this -> - match _visitors_this with - | Invisible -> self#visit_Invisible env - | Readable -> self#visit_Readable env - | Read_write -> self#visit_Read_write env + method private visit_type_component_visibility : + _ -> type_component_visibility -> unit = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Invisible -> self#visit_Invisible env + | Readable -> self#visit_Readable env + | Read_write -> self#visit_Read_write env method private visit_constructor : _ -> constructor -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.constr_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_this.cs_args - in - let _visitors_r2 = self#visit_typ env _visitors_this.cs_res in - let _visitors_r3 = self#visit_constr_tag env _visitors_this.cs_tag in - let _visitors_r4 = - self#visit_type_component_visibility env _visitors_this.cs_vis - in - let _visitors_r5 = - self#visit_tvar_env env _visitors_this.cs_ty_params_ - in - let _visitors_r6 = - (fun _visitors_this -> ()) _visitors_this.cs_arity_ - in - let _visitors_r7 = - (fun _visitors_this -> ()) _visitors_this.cs_constr_loc_ - in - let _visitors_r8 = - (fun _visitors_this -> ()) _visitors_this.cs_loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.constr_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_this.cs_args + in + let _visitors_r2 = self#visit_typ env _visitors_this.cs_res in + let _visitors_r3 = self#visit_constr_tag env _visitors_this.cs_tag in + let _visitors_r4 = + self#visit_type_component_visibility env _visitors_this.cs_vis + in + let _visitors_r5 = + self#visit_tvar_env env _visitors_this.cs_ty_params_ + in + let _visitors_r6 = + (fun _visitors_this -> ()) _visitors_this.cs_arity_ + in + let _visitors_r7 = + (fun _visitors_this -> ()) _visitors_this.cs_constr_loc_ + in + let _visitors_r8 = + (fun _visitors_this -> ()) _visitors_this.cs_loc_ + in + () method private visit_field : _ -> field -> unit = - fun env _visitors_this -> - let _visitors_r0 = - (fun _visitors_this -> ()) _visitors_this.field_name - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in - let _visitors_r2 = self#visit_typ env _visitors_this.ty_field in - let _visitors_r3 = self#visit_typ env _visitors_this.ty_record in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_this.mut in - let _visitors_r5 = - self#visit_type_component_visibility env _visitors_this.vis - in - let _visitors_r6 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun _visitors_this -> ())) - _visitors_this.all_labels - in - let _visitors_r7 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r8 = - (fun _visitors_this -> ()) _visitors_this.label_loc_ - in - let _visitors_r9 = (fun _visitors_this -> ()) _visitors_this.loc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_this.field_name + in + let _visitors_r1 = (fun _visitors_this -> ()) _visitors_this.pos in + let _visitors_r2 = self#visit_typ env _visitors_this.ty_field in + let _visitors_r3 = self#visit_typ env _visitors_this.ty_record in + let _visitors_r4 = (fun _visitors_this -> ()) _visitors_this.mut in + let _visitors_r5 = + self#visit_type_component_visibility env _visitors_this.vis + in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(fun _visitors_this -> ())) + _visitors_this.all_labels + in + let _visitors_r7 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r8 = + (fun _visitors_this -> ()) _visitors_this.label_loc_ + in + let _visitors_r9 = (fun _visitors_this -> ()) _visitors_this.loc_ in + () end [@@@VISITORS.END] @@ -374,8 +405,8 @@ include struct (let (drop_if__009_ : visibility -> Stdlib.Bool.t) = fun vis -> vis = Vis_default and (drop_if__018_ : docstring -> Stdlib.Bool.t) = Docstring.is_empty - and (drop_if__023_ : bool -> Stdlib.Bool.t) = fun x -> x = false - and (drop_if__028_ : bool -> Stdlib.Bool.t) = fun x -> x = false in + and (drop_if__025_ : bool -> Stdlib.Bool.t) = fun x -> x = false + and (drop_if__030_ : bool -> Stdlib.Bool.t) = fun x -> x = false in fun { ty_constr = ty_constr__002_; ty_arity = ty_arity__004_; @@ -384,27 +415,33 @@ include struct ty_params_ = ty_params___013_; ty_loc_ = ty_loc___015_; ty_doc_ = ty_doc___019_; - ty_is_only_tag_enum_ = ty_is_only_tag_enum___024_; - ty_is_suberror_ = ty_is_suberror___029_; + ty_attrs = ty_attrs__022_; + ty_is_only_tag_enum_ = ty_is_only_tag_enum___026_; + ty_is_suberror_ = ty_is_suberror___031_; } -> let bnds__001_ = ([] : _ Stdlib.List.t) in let bnds__001_ = - if drop_if__028_ ty_is_suberror___029_ then bnds__001_ + if drop_if__030_ ty_is_suberror___031_ then bnds__001_ else - let arg__031_ = Moon_sexp_conv.sexp_of_bool ty_is_suberror___029_ in - let bnd__030_ = S.List [ S.Atom "ty_is_suberror_"; arg__031_ ] in - (bnd__030_ :: bnds__001_ : _ Stdlib.List.t) + let arg__033_ = Moon_sexp_conv.sexp_of_bool ty_is_suberror___031_ in + let bnd__032_ = S.List [ S.Atom "ty_is_suberror_"; arg__033_ ] in + (bnd__032_ :: bnds__001_ : _ Stdlib.List.t) in let bnds__001_ = - if drop_if__023_ ty_is_only_tag_enum___024_ then bnds__001_ + if drop_if__025_ ty_is_only_tag_enum___026_ then bnds__001_ else - let arg__026_ = - Moon_sexp_conv.sexp_of_bool ty_is_only_tag_enum___024_ + let arg__028_ = + Moon_sexp_conv.sexp_of_bool ty_is_only_tag_enum___026_ in - let bnd__025_ = - S.List [ S.Atom "ty_is_only_tag_enum_"; arg__026_ ] + let bnd__027_ = + S.List [ S.Atom "ty_is_only_tag_enum_"; arg__028_ ] in - (bnd__025_ :: bnds__001_ : _ Stdlib.List.t) + (bnd__027_ :: bnds__001_ : _ Stdlib.List.t) + in + let bnds__001_ = + let arg__023_ = sexp_of_attributes ty_attrs__022_ in + (S.List [ S.Atom "ty_attrs"; arg__023_ ] :: bnds__001_ + : _ Stdlib.List.t) in let bnds__001_ = if drop_if__018_ ty_doc___019_ then bnds__001_ @@ -449,82 +486,82 @@ include struct : t -> S.t) and sexp_of_constructors = - (fun x__032_ -> Moon_sexp_conv.sexp_of_list sexp_of_constructor x__032_ + (fun x__034_ -> Moon_sexp_conv.sexp_of_list sexp_of_constructor x__034_ : constructors -> S.t) and sexp_of_fields = - (fun x__033_ -> Moon_sexp_conv.sexp_of_list sexp_of_field x__033_ + (fun x__035_ -> Moon_sexp_conv.sexp_of_list sexp_of_field x__035_ : fields -> S.t) and sexp_of_newtype_info = - (let (drop_if__040_ : bool -> Stdlib.Bool.t) = fun recur -> not recur in + (let (drop_if__042_ : bool -> Stdlib.Bool.t) = fun recur -> not recur in fun { - newtype_constr = newtype_constr__035_; - underlying_typ = underlying_typ__037_; - recursive = recursive__041_; + newtype_constr = newtype_constr__037_; + underlying_typ = underlying_typ__039_; + recursive = recursive__043_; } -> - let bnds__034_ = ([] : _ Stdlib.List.t) in - let bnds__034_ = - if drop_if__040_ recursive__041_ then bnds__034_ + let bnds__036_ = ([] : _ Stdlib.List.t) in + let bnds__036_ = + if drop_if__042_ recursive__043_ then bnds__036_ else - let arg__043_ = Moon_sexp_conv.sexp_of_bool recursive__041_ in - let bnd__042_ = S.List [ S.Atom "recursive"; arg__043_ ] in - (bnd__042_ :: bnds__034_ : _ Stdlib.List.t) + let arg__045_ = Moon_sexp_conv.sexp_of_bool recursive__043_ in + let bnd__044_ = S.List [ S.Atom "recursive"; arg__045_ ] in + (bnd__044_ :: bnds__036_ : _ Stdlib.List.t) in - let bnds__034_ = - let arg__038_ = sexp_of_typ underlying_typ__037_ in - (S.List [ S.Atom "underlying_typ"; arg__038_ ] :: bnds__034_ + let bnds__036_ = + let arg__040_ = sexp_of_typ underlying_typ__039_ in + (S.List [ S.Atom "underlying_typ"; arg__040_ ] :: bnds__036_ : _ Stdlib.List.t) in - let bnds__034_ = - let arg__036_ = sexp_of_constructor newtype_constr__035_ in - (S.List [ S.Atom "newtype_constr"; arg__036_ ] :: bnds__034_ + let bnds__036_ = + let arg__038_ = sexp_of_constructor newtype_constr__037_ in + (S.List [ S.Atom "newtype_constr"; arg__038_ ] :: bnds__036_ : _ Stdlib.List.t) in - S.List bnds__034_ + S.List bnds__036_ : newtype_info -> S.t) and sexp_of_type_components = (function | Extern_type -> S.Atom "Extern_type" | Abstract_type -> S.Atom "Abstract_type" - | Error_type arg0__044_ -> - let res0__045_ = sexp_of_constructor arg0__044_ in - S.List [ S.Atom "Error_type"; res0__045_ ] - | ErrorEnum_type arg0__046_ -> - let res0__047_ = - Moon_sexp_conv.sexp_of_list sexp_of_constructor arg0__046_ + | Error_type arg0__046_ -> + let res0__047_ = sexp_of_constructor arg0__046_ in + S.List [ S.Atom "Error_type"; res0__047_ ] + | ErrorEnum_type arg0__048_ -> + let res0__049_ = + Moon_sexp_conv.sexp_of_list sexp_of_constructor arg0__048_ in - S.List [ S.Atom "ErrorEnum_type"; res0__047_ ] - | New_type arg0__048_ -> - let res0__049_ = sexp_of_newtype_info arg0__048_ in - S.List [ S.Atom "New_type"; res0__049_ ] - | Variant_type arg0__050_ -> - let res0__051_ = - Moon_sexp_conv.sexp_of_list sexp_of_constructor arg0__050_ + S.List [ S.Atom "ErrorEnum_type"; res0__049_ ] + | New_type arg0__050_ -> + let res0__051_ = sexp_of_newtype_info arg0__050_ in + S.List [ S.Atom "New_type"; res0__051_ ] + | Variant_type arg0__052_ -> + let res0__053_ = + Moon_sexp_conv.sexp_of_list sexp_of_constructor arg0__052_ in - S.List [ S.Atom "Variant_type"; res0__051_ ] + S.List [ S.Atom "Variant_type"; res0__053_ ] | Record_type { - fields = fields__053_; - has_private_field_ = has_private_field___055_; + fields = fields__055_; + has_private_field_ = has_private_field___057_; } -> - let bnds__052_ = ([] : _ Stdlib.List.t) in - let bnds__052_ = - let arg__056_ = - Moon_sexp_conv.sexp_of_bool has_private_field___055_ + let bnds__054_ = ([] : _ Stdlib.List.t) in + let bnds__054_ = + let arg__058_ = + Moon_sexp_conv.sexp_of_bool has_private_field___057_ in - (S.List [ S.Atom "has_private_field_"; arg__056_ ] :: bnds__052_ + (S.List [ S.Atom "has_private_field_"; arg__058_ ] :: bnds__054_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__054_ = - Moon_sexp_conv.sexp_of_list sexp_of_field fields__053_ + let bnds__054_ = + let arg__056_ = + Moon_sexp_conv.sexp_of_list sexp_of_field fields__055_ in - (S.List [ S.Atom "fields"; arg__054_ ] :: bnds__052_ + (S.List [ S.Atom "fields"; arg__056_ ] :: bnds__054_ : _ Stdlib.List.t) in - S.List (S.Atom "Record_type" :: bnds__052_) + S.List (S.Atom "Record_type" :: bnds__054_) : type_components -> S.t) and sexp_of_type_component_visibility = @@ -535,155 +572,155 @@ include struct : type_component_visibility -> S.t) and sexp_of_constructor = - (let (drop_if__067_ : type_component_visibility -> Stdlib.Bool.t) = + (let (drop_if__069_ : type_component_visibility -> Stdlib.Bool.t) = fun vis -> vis = Invisible - and (drop_if__074_ : fn_arity -> Stdlib.Bool.t) = Fn_arity.is_simple - and (drop_if__079_ : location -> Stdlib.Bool.t) = hide_loc - and (drop_if__084_ : location -> Stdlib.Bool.t) = hide_loc in + and (drop_if__076_ : fn_arity -> Stdlib.Bool.t) = Fn_arity.is_simple + and (drop_if__081_ : location -> Stdlib.Bool.t) = hide_loc + and (drop_if__086_ : location -> Stdlib.Bool.t) = hide_loc in fun { - constr_name = constr_name__058_; - cs_args = cs_args__060_; - cs_res = cs_res__062_; - cs_tag = cs_tag__064_; - cs_vis = cs_vis__068_; - cs_ty_params_ = cs_ty_params___071_; - cs_arity_ = cs_arity___075_; - cs_constr_loc_ = cs_constr_loc___080_; - cs_loc_ = cs_loc___085_; + constr_name = constr_name__060_; + cs_args = cs_args__062_; + cs_res = cs_res__064_; + cs_tag = cs_tag__066_; + cs_vis = cs_vis__070_; + cs_ty_params_ = cs_ty_params___073_; + cs_arity_ = cs_arity___077_; + cs_constr_loc_ = cs_constr_loc___082_; + cs_loc_ = cs_loc___087_; } -> - let bnds__057_ = ([] : _ Stdlib.List.t) in - let bnds__057_ = - if drop_if__084_ cs_loc___085_ then bnds__057_ + let bnds__059_ = ([] : _ Stdlib.List.t) in + let bnds__059_ = + if drop_if__086_ cs_loc___087_ then bnds__059_ else - let arg__087_ = sexp_of_location cs_loc___085_ in - let bnd__086_ = S.List [ S.Atom "cs_loc_"; arg__087_ ] in - (bnd__086_ :: bnds__057_ : _ Stdlib.List.t) + let arg__089_ = sexp_of_location cs_loc___087_ in + let bnd__088_ = S.List [ S.Atom "cs_loc_"; arg__089_ ] in + (bnd__088_ :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - if drop_if__079_ cs_constr_loc___080_ then bnds__057_ + let bnds__059_ = + if drop_if__081_ cs_constr_loc___082_ then bnds__059_ else - let arg__082_ = sexp_of_location cs_constr_loc___080_ in - let bnd__081_ = S.List [ S.Atom "cs_constr_loc_"; arg__082_ ] in - (bnd__081_ :: bnds__057_ : _ Stdlib.List.t) + let arg__084_ = sexp_of_location cs_constr_loc___082_ in + let bnd__083_ = S.List [ S.Atom "cs_constr_loc_"; arg__084_ ] in + (bnd__083_ :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - if drop_if__074_ cs_arity___075_ then bnds__057_ + let bnds__059_ = + if drop_if__076_ cs_arity___077_ then bnds__059_ else - let arg__077_ = sexp_of_fn_arity cs_arity___075_ in - let bnd__076_ = S.List [ S.Atom "cs_arity_"; arg__077_ ] in - (bnd__076_ :: bnds__057_ : _ Stdlib.List.t) + let arg__079_ = sexp_of_fn_arity cs_arity___077_ in + let bnd__078_ = S.List [ S.Atom "cs_arity_"; arg__079_ ] in + (bnd__078_ :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__072_ = sexp_of_tvar_env cs_ty_params___071_ in - (S.List [ S.Atom "cs_ty_params_"; arg__072_ ] :: bnds__057_ + let bnds__059_ = + let arg__074_ = sexp_of_tvar_env cs_ty_params___073_ in + (S.List [ S.Atom "cs_ty_params_"; arg__074_ ] :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - if drop_if__067_ cs_vis__068_ then bnds__057_ + let bnds__059_ = + if drop_if__069_ cs_vis__070_ then bnds__059_ else - let arg__070_ = sexp_of_type_component_visibility cs_vis__068_ in - let bnd__069_ = S.List [ S.Atom "cs_vis"; arg__070_ ] in - (bnd__069_ :: bnds__057_ : _ Stdlib.List.t) + let arg__072_ = sexp_of_type_component_visibility cs_vis__070_ in + let bnd__071_ = S.List [ S.Atom "cs_vis"; arg__072_ ] in + (bnd__071_ :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__065_ = sexp_of_constr_tag cs_tag__064_ in - (S.List [ S.Atom "cs_tag"; arg__065_ ] :: bnds__057_ : _ Stdlib.List.t) + let bnds__059_ = + let arg__067_ = sexp_of_constr_tag cs_tag__066_ in + (S.List [ S.Atom "cs_tag"; arg__067_ ] :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__063_ = sexp_of_typ cs_res__062_ in - (S.List [ S.Atom "cs_res"; arg__063_ ] :: bnds__057_ : _ Stdlib.List.t) + let bnds__059_ = + let arg__065_ = sexp_of_typ cs_res__064_ in + (S.List [ S.Atom "cs_res"; arg__065_ ] :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__061_ = - Moon_sexp_conv.sexp_of_list sexp_of_typ cs_args__060_ + let bnds__059_ = + let arg__063_ = + Moon_sexp_conv.sexp_of_list sexp_of_typ cs_args__062_ in - (S.List [ S.Atom "cs_args"; arg__061_ ] :: bnds__057_ + (S.List [ S.Atom "cs_args"; arg__063_ ] :: bnds__059_ : _ Stdlib.List.t) in - let bnds__057_ = - let arg__059_ = Moon_sexp_conv.sexp_of_string constr_name__058_ in - (S.List [ S.Atom "constr_name"; arg__059_ ] :: bnds__057_ + let bnds__059_ = + let arg__061_ = Moon_sexp_conv.sexp_of_string constr_name__060_ in + (S.List [ S.Atom "constr_name"; arg__061_ ] :: bnds__059_ : _ Stdlib.List.t) in - S.List bnds__057_ + S.List bnds__059_ : constructor -> S.t) and sexp_of_field = - (let (drop_if__100_ : type_component_visibility -> Stdlib.Bool.t) = + (let (drop_if__102_ : type_component_visibility -> Stdlib.Bool.t) = fun vis -> vis = Invisible - and (drop_if__109_ : location -> Stdlib.Bool.t) = hide_loc - and (drop_if__114_ : location -> Stdlib.Bool.t) = hide_loc in + and (drop_if__111_ : location -> Stdlib.Bool.t) = hide_loc + and (drop_if__116_ : location -> Stdlib.Bool.t) = hide_loc in fun { - field_name = field_name__089_; - pos = pos__091_; - ty_field = ty_field__093_; - ty_record = ty_record__095_; - mut = mut__097_; - vis = vis__101_; - all_labels = all_labels__104_; - ty_params_ = ty_params___106_; - label_loc_ = label_loc___110_; - loc_ = loc___115_; + field_name = field_name__091_; + pos = pos__093_; + ty_field = ty_field__095_; + ty_record = ty_record__097_; + mut = mut__099_; + vis = vis__103_; + all_labels = all_labels__106_; + ty_params_ = ty_params___108_; + label_loc_ = label_loc___112_; + loc_ = loc___117_; } -> - let bnds__088_ = ([] : _ Stdlib.List.t) in - let bnds__088_ = - if drop_if__114_ loc___115_ then bnds__088_ + let bnds__090_ = ([] : _ Stdlib.List.t) in + let bnds__090_ = + if drop_if__116_ loc___117_ then bnds__090_ else - let arg__117_ = sexp_of_location loc___115_ in - let bnd__116_ = S.List [ S.Atom "loc_"; arg__117_ ] in - (bnd__116_ :: bnds__088_ : _ Stdlib.List.t) + let arg__119_ = sexp_of_location loc___117_ in + let bnd__118_ = S.List [ S.Atom "loc_"; arg__119_ ] in + (bnd__118_ :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - if drop_if__109_ label_loc___110_ then bnds__088_ + let bnds__090_ = + if drop_if__111_ label_loc___112_ then bnds__090_ else - let arg__112_ = sexp_of_location label_loc___110_ in - let bnd__111_ = S.List [ S.Atom "label_loc_"; arg__112_ ] in - (bnd__111_ :: bnds__088_ : _ Stdlib.List.t) + let arg__114_ = sexp_of_location label_loc___112_ in + let bnd__113_ = S.List [ S.Atom "label_loc_"; arg__114_ ] in + (bnd__113_ :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__107_ = sexp_of_tvar_env ty_params___106_ in - (S.List [ S.Atom "ty_params_"; arg__107_ ] :: bnds__088_ + let bnds__090_ = + let arg__109_ = sexp_of_tvar_env ty_params___108_ in + (S.List [ S.Atom "ty_params_"; arg__109_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__105_ = + let bnds__090_ = + let arg__107_ = Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string - all_labels__104_ + all_labels__106_ in - (S.List [ S.Atom "all_labels"; arg__105_ ] :: bnds__088_ + (S.List [ S.Atom "all_labels"; arg__107_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - if drop_if__100_ vis__101_ then bnds__088_ + let bnds__090_ = + if drop_if__102_ vis__103_ then bnds__090_ else - let arg__103_ = sexp_of_type_component_visibility vis__101_ in - let bnd__102_ = S.List [ S.Atom "vis"; arg__103_ ] in - (bnd__102_ :: bnds__088_ : _ Stdlib.List.t) + let arg__105_ = sexp_of_type_component_visibility vis__103_ in + let bnd__104_ = S.List [ S.Atom "vis"; arg__105_ ] in + (bnd__104_ :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__098_ = Moon_sexp_conv.sexp_of_bool mut__097_ in - (S.List [ S.Atom "mut"; arg__098_ ] :: bnds__088_ : _ Stdlib.List.t) + let bnds__090_ = + let arg__100_ = Moon_sexp_conv.sexp_of_bool mut__099_ in + (S.List [ S.Atom "mut"; arg__100_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__096_ = sexp_of_typ ty_record__095_ in - (S.List [ S.Atom "ty_record"; arg__096_ ] :: bnds__088_ + let bnds__090_ = + let arg__098_ = sexp_of_typ ty_record__097_ in + (S.List [ S.Atom "ty_record"; arg__098_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__094_ = sexp_of_typ ty_field__093_ in - (S.List [ S.Atom "ty_field"; arg__094_ ] :: bnds__088_ + let bnds__090_ = + let arg__096_ = sexp_of_typ ty_field__095_ in + (S.List [ S.Atom "ty_field"; arg__096_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__092_ = Moon_sexp_conv.sexp_of_int pos__091_ in - (S.List [ S.Atom "pos"; arg__092_ ] :: bnds__088_ : _ Stdlib.List.t) + let bnds__090_ = + let arg__094_ = Moon_sexp_conv.sexp_of_int pos__093_ in + (S.List [ S.Atom "pos"; arg__094_ ] :: bnds__090_ : _ Stdlib.List.t) in - let bnds__088_ = - let arg__090_ = Moon_sexp_conv.sexp_of_string field_name__089_ in - (S.List [ S.Atom "field_name"; arg__090_ ] :: bnds__088_ + let bnds__090_ = + let arg__092_ = Moon_sexp_conv.sexp_of_string field_name__091_ in + (S.List [ S.Atom "field_name"; arg__092_ ] :: bnds__090_ : _ Stdlib.List.t) in - S.List bnds__088_ + S.List bnds__090_ : field -> S.t) let _ = sexp_of_t @@ -695,66 +732,3 @@ include struct and _ = sexp_of_constructor and _ = sexp_of_field end - -type alias = { - name : string; - arity : int; - ty_params : tvar_env; - alias : Stype.t; - is_pub : bool; - doc_ : docstring; - loc_ : location; [@sexp_drop_if hide_loc] -} - -include struct - let _ = fun (_ : alias) -> () - - let sexp_of_alias = - (let (drop_if__132_ : location -> Stdlib.Bool.t) = hide_loc in - fun { - name = name__119_; - arity = arity__121_; - ty_params = ty_params__123_; - alias = alias__125_; - is_pub = is_pub__127_; - doc_ = doc___129_; - loc_ = loc___133_; - } -> - let bnds__118_ = ([] : _ Stdlib.List.t) in - let bnds__118_ = - if drop_if__132_ loc___133_ then bnds__118_ - else - let arg__135_ = sexp_of_location loc___133_ in - let bnd__134_ = S.List [ S.Atom "loc_"; arg__135_ ] in - (bnd__134_ :: bnds__118_ : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__130_ = sexp_of_docstring doc___129_ in - (S.List [ S.Atom "doc_"; arg__130_ ] :: bnds__118_ : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__128_ = Moon_sexp_conv.sexp_of_bool is_pub__127_ in - (S.List [ S.Atom "is_pub"; arg__128_ ] :: bnds__118_ : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__126_ = Stype.sexp_of_t alias__125_ in - (S.List [ S.Atom "alias"; arg__126_ ] :: bnds__118_ : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__124_ = sexp_of_tvar_env ty_params__123_ in - (S.List [ S.Atom "ty_params"; arg__124_ ] :: bnds__118_ - : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__122_ = Moon_sexp_conv.sexp_of_int arity__121_ in - (S.List [ S.Atom "arity"; arg__122_ ] :: bnds__118_ : _ Stdlib.List.t) - in - let bnds__118_ = - let arg__120_ = Moon_sexp_conv.sexp_of_string name__119_ in - (S.List [ S.Atom "name"; arg__120_ ] :: bnds__118_ : _ Stdlib.List.t) - in - S.List bnds__118_ - : alias -> S.t) - - let _ = sexp_of_alias -end diff --git a/src/typedtree.ml b/src/typedtree.ml index 439dd38..f7665a2 100644 --- a/src/typedtree.ml +++ b/src/typedtree.ml @@ -87,6 +87,14 @@ include struct let _ = sexp_of_docstring end +type attributes = Checked_attributes.t + +include struct + let _ = fun (_ : attributes) -> () + let sexp_of_attributes = (Checked_attributes.sexp_of_t : attributes -> S.t) + let _ = sexp_of_attributes +end + type ident = Ident.t include struct @@ -166,6 +174,50 @@ let sexp_of_binder (x : binder) = let loc = Rloc.sexp_of_t x.loc_ in (List (List.cons (s : S.t) ([ loc ] : S.t list)) : S.t) +type loop_label = { label : Label.t; loc_ : location } + +include struct + let _ = fun (_ : loop_label) -> () + + let sexp_of_loop_label = + (fun { label = label__003_; loc_ = loc___005_ } -> + let bnds__002_ = ([] : _ Stdlib.List.t) in + let bnds__002_ = + let arg__006_ = sexp_of_location loc___005_ in + (S.List [ S.Atom "loc_"; arg__006_ ] :: bnds__002_ : _ Stdlib.List.t) + in + let bnds__002_ = + let arg__004_ = Label.sexp_of_t label__003_ in + (S.List [ S.Atom "label"; arg__004_ ] :: bnds__002_ : _ Stdlib.List.t) + in + S.List bnds__002_ + : loop_label -> S.t) + + let _ = sexp_of_loop_label +end + +type loop_label_binder = { label : Label.t; loc_ : location } + +include struct + let _ = fun (_ : loop_label_binder) -> () + + let sexp_of_loop_label_binder = + (fun { label = label__008_; loc_ = loc___010_ } -> + let bnds__007_ = ([] : _ Stdlib.List.t) in + let bnds__007_ = + let arg__011_ = sexp_of_location loc___010_ in + (S.List [ S.Atom "loc_"; arg__011_ ] :: bnds__007_ : _ Stdlib.List.t) + in + let bnds__007_ = + let arg__009_ = Label.sexp_of_t label__008_ in + (S.List [ S.Atom "label"; arg__009_ ] :: bnds__007_ : _ Stdlib.List.t) + in + S.List bnds__007_ + : loop_label_binder -> S.t) + + let _ = sexp_of_loop_label_binder +end + type func_stubs = Stub_type.t include struct @@ -204,18 +256,18 @@ include struct let _ = fun (_ : pat_binder) -> () let sexp_of_pat_binder = - (fun { binder = binder__003_; binder_typ = binder_typ__005_ } -> - let bnds__002_ = ([] : _ Stdlib.List.t) in - let bnds__002_ = - let arg__006_ = sexp_of_stype binder_typ__005_ in - (S.List [ S.Atom "binder_typ"; arg__006_ ] :: bnds__002_ + (fun { binder = binder__013_; binder_typ = binder_typ__015_ } -> + let bnds__012_ = ([] : _ Stdlib.List.t) in + let bnds__012_ = + let arg__016_ = sexp_of_stype binder_typ__015_ in + (S.List [ S.Atom "binder_typ"; arg__016_ ] :: bnds__012_ : _ Stdlib.List.t) in - let bnds__002_ = - let arg__004_ = sexp_of_binder binder__003_ in - (S.List [ S.Atom "binder"; arg__004_ ] :: bnds__002_ : _ Stdlib.List.t) + let bnds__012_ = + let arg__014_ = sexp_of_binder binder__013_ in + (S.List [ S.Atom "binder"; arg__014_ ] :: bnds__012_ : _ Stdlib.List.t) in - S.List bnds__002_ + S.List bnds__012_ : pat_binder -> S.t) let _ = sexp_of_pat_binder @@ -227,7 +279,7 @@ include struct let _ = fun (_ : pat_binders) -> () let sexp_of_pat_binders = - (fun x__007_ -> Moon_sexp_conv.sexp_of_list sexp_of_pat_binder x__007_ + (fun x__017_ -> Moon_sexp_conv.sexp_of_list sexp_of_pat_binder x__017_ : pat_binders -> S.t) let _ = sexp_of_pat_binders @@ -244,14 +296,14 @@ include struct let sexp_of_value_kind = (function - | Prim arg0__008_ -> - let res0__009_ = Primitive.sexp_of_prim arg0__008_ in - S.List [ S.Atom "Prim"; res0__009_ ] + | Prim arg0__018_ -> + let res0__019_ = Primitive.sexp_of_prim arg0__018_ in + S.List [ S.Atom "Prim"; res0__019_ ] | Mutable -> S.Atom "Mutable" | Normal -> S.Atom "Normal" - | Value_constr arg0__010_ -> - let res0__011_ = sexp_of_constr_tag arg0__010_ in - S.List [ S.Atom "Value_constr"; res0__011_ ] + | Value_constr arg0__020_ -> + let res0__021_ = sexp_of_constr_tag arg0__020_ in + S.List [ S.Atom "Value_constr"; res0__021_ ] : value_kind -> S.t) let _ = sexp_of_value_kind @@ -279,25 +331,25 @@ include struct let _ = fun (_ : type_constr_loc) -> () let sexp_of_type_constr_loc = - (let (drop_if__018_ : location -> Stdlib.Bool.t) = hide_loc in - fun { name = name__013_; kind = kind__015_; loc_ = loc___019_ } -> - let bnds__012_ = ([] : _ Stdlib.List.t) in - let bnds__012_ = - if drop_if__018_ loc___019_ then bnds__012_ + (let (drop_if__028_ : location -> Stdlib.Bool.t) = hide_loc in + fun { name = name__023_; kind = kind__025_; loc_ = loc___029_ } -> + let bnds__022_ = ([] : _ Stdlib.List.t) in + let bnds__022_ = + if drop_if__028_ loc___029_ then bnds__022_ else - let arg__021_ = sexp_of_location loc___019_ in - let bnd__020_ = S.List [ S.Atom "loc_"; arg__021_ ] in - (bnd__020_ :: bnds__012_ : _ Stdlib.List.t) + let arg__031_ = sexp_of_location loc___029_ in + let bnd__030_ = S.List [ S.Atom "loc_"; arg__031_ ] in + (bnd__030_ :: bnds__022_ : _ Stdlib.List.t) in - let bnds__012_ = - let arg__016_ = sexp_of_type_name_kind kind__015_ in - (S.List [ S.Atom "kind"; arg__016_ ] :: bnds__012_ : _ Stdlib.List.t) + let bnds__022_ = + let arg__026_ = sexp_of_type_name_kind kind__025_ in + (S.List [ S.Atom "kind"; arg__026_ ] :: bnds__022_ : _ Stdlib.List.t) in - let bnds__012_ = - let arg__014_ = Type_path.sexp_of_t name__013_ in - (S.List [ S.Atom "name"; arg__014_ ] :: bnds__012_ : _ Stdlib.List.t) + let bnds__022_ = + let arg__024_ = Type_path.sexp_of_t name__023_ in + (S.List [ S.Atom "name"; arg__024_ ] :: bnds__022_ : _ Stdlib.List.t) in - S.List bnds__012_ + S.List bnds__022_ : type_constr_loc -> S.t) let _ = sexp_of_type_constr_loc @@ -312,21 +364,21 @@ include struct let _ = fun (_ : type_path_loc) -> () let sexp_of_type_path_loc = - (let (drop_if__026_ : location -> Stdlib.Bool.t) = hide_loc in - fun { name = name__023_; loc_ = loc___027_ } -> - let bnds__022_ = ([] : _ Stdlib.List.t) in - let bnds__022_ = - if drop_if__026_ loc___027_ then bnds__022_ + (let (drop_if__036_ : location -> Stdlib.Bool.t) = hide_loc in + fun { name = name__033_; loc_ = loc___037_ } -> + let bnds__032_ = ([] : _ Stdlib.List.t) in + let bnds__032_ = + if drop_if__036_ loc___037_ then bnds__032_ else - let arg__029_ = sexp_of_location loc___027_ in - let bnd__028_ = S.List [ S.Atom "loc_"; arg__029_ ] in - (bnd__028_ :: bnds__022_ : _ Stdlib.List.t) + let arg__039_ = sexp_of_location loc___037_ in + let bnd__038_ = S.List [ S.Atom "loc_"; arg__039_ ] in + (bnd__038_ :: bnds__032_ : _ Stdlib.List.t) in - let bnds__022_ = - let arg__024_ = Type_path.sexp_of_t name__023_ in - (S.List [ S.Atom "name"; arg__024_ ] :: bnds__022_ : _ Stdlib.List.t) + let bnds__032_ = + let arg__034_ = Type_path.sexp_of_t name__033_ in + (S.List [ S.Atom "name"; arg__034_ ] :: bnds__032_ : _ Stdlib.List.t) in - S.List bnds__022_ + S.List bnds__032_ : type_path_loc -> S.t) let _ = sexp_of_type_path_loc @@ -441,213 +493,297 @@ let sexp_of_type_name (x : type_name) = class ['a] iterbase = object (self) - method private visit_ident : 'a -> ident -> unit = fun _ _ -> () - method visit_var : 'a -> var -> unit = fun _ _ -> () - method visit_binder : 'a -> binder -> unit = fun _ _ -> () + method private visit_attributes : 'a -> attributes -> unit = + fun _ -> fun _ -> () + + method private visit_ident : 'a -> ident -> unit = fun _ -> fun _ -> () + method visit_var : 'a -> var -> unit = fun _ -> fun _ -> () + method visit_binder : 'a -> binder -> unit = fun _ -> fun _ -> () method visit_type_constraint : 'a -> Tvar_env.type_constraint -> unit = - fun _ _ -> () + fun _ -> fun _ -> () method visit_visibility : 'a -> Typedecl_info.visibility -> unit = - fun _ _ -> () + fun _ -> fun _ -> () + + method private visit_type_component_visibility : + 'a -> Typedecl_info.type_component_visibility -> unit = + fun _ -> fun _ -> () method visit_constraints : 'a -> constraints -> unit = - fun ctx cs -> Lst.iter cs (fun c -> self#visit_type_constraint ctx c) + fun ctx -> + fun cs -> Lst.iter cs ~f:(fun c -> self#visit_type_constraint ctx c) method visit_argument_kind : 'a -> Syntax.argument_kind -> unit = - fun _ _ -> () - - method visit_fn_arity : 'a -> fn_arity -> unit = fun _ _ -> () - method visit_fn_kind : 'a -> fn_kind -> unit = fun _ _ -> () - method visit_prim : 'a -> Primitive.prim -> unit = fun _ _ -> () - method visit_location : 'a -> location -> unit = fun _ _ -> () - method visit_absolute_loc : 'a -> absolute_loc -> unit = fun _ _ -> () - method visit_label : 'a -> Syntax.label -> unit = fun _ _ -> () - method visit_accessor : 'a -> Syntax.accessor -> unit = fun _ _ -> () - method visit_constructor : 'a -> Syntax.constructor -> unit = fun _ _ -> () - method visit_constr_tag : 'a -> constr_tag -> unit = fun _ _ -> () - method visit_func_stubs : 'a -> func_stubs -> unit = fun _ _ -> () - method visit_pat_binders : 'a -> pat_binders -> unit = fun _ _ -> () - method visit_stype : 'a -> stype -> unit = fun _ _ -> () - method visit_constrid_loc : 'a -> constrid_loc -> unit = fun _ _ -> () - method visit_syntax_binder : 'a -> syntax_binder -> unit = fun _ _ -> () - method visit_hole : 'a -> Parsing_syntax.hole -> unit = fun _ _ -> () - method visit_apply_kind : 'a -> apply_kind -> unit = fun _ _ -> () - method visit_type_constr_loc : 'a -> type_constr_loc -> unit = fun _ _ -> () - method visit_type_name : 'a -> type_name -> unit = fun _ _ -> () - method visit_type_path_loc : 'a -> type_path_loc -> unit = fun _ _ -> () - method visit_docstring : 'a -> docstring -> unit = fun _ _ -> () + fun _ -> fun _ -> () + + method visit_fn_arity : 'a -> fn_arity -> unit = fun _ -> fun _ -> () + method visit_fn_kind : 'a -> fn_kind -> unit = fun _ -> fun _ -> () + method visit_prim : 'a -> Primitive.prim -> unit = fun _ -> fun _ -> () + method visit_location : 'a -> location -> unit = fun _ -> fun _ -> () + + method visit_absolute_loc : 'a -> absolute_loc -> unit = + fun _ -> fun _ -> () + + method visit_label : 'a -> Syntax.label -> unit = fun _ -> fun _ -> () + method visit_accessor : 'a -> Syntax.accessor -> unit = fun _ -> fun _ -> () + + method visit_constr_name : 'a -> Syntax.constr_name -> unit = + fun _ -> fun _ -> () + + method visit_constr_tag : 'a -> constr_tag -> unit = fun _ -> fun _ -> () + method visit_func_stubs : 'a -> func_stubs -> unit = fun _ -> fun _ -> () + method visit_pat_binders : 'a -> pat_binders -> unit = fun _ -> fun _ -> () + method visit_stype : 'a -> stype -> unit = fun _ -> fun _ -> () + + method visit_constrid_loc : 'a -> constrid_loc -> unit = + fun _ -> fun _ -> () + + method visit_syntax_binder : 'a -> syntax_binder -> unit = + fun _ -> fun _ -> () + + method visit_hole : 'a -> Parsing_syntax.hole -> unit = fun _ -> fun _ -> () + method visit_apply_kind : 'a -> apply_kind -> unit = fun _ -> fun _ -> () + + method visit_type_constr_loc : 'a -> type_constr_loc -> unit = + fun _ -> fun _ -> () + + method visit_type_name : 'a -> type_name -> unit = fun _ -> fun _ -> () + + method visit_type_path_loc : 'a -> type_path_loc -> unit = + fun _ -> fun _ -> () + + method visit_docstring : 'a -> docstring -> unit = fun _ -> fun _ -> () method visit_tvar_env : 'a -> tvar_env -> unit = - fun ctx env -> - Tvar_env.iter env (fun { name = _; typ; constraints } -> - self#visit_stype ctx typ; - self#visit_constraints ctx constraints) + fun ctx -> + fun env -> + Tvar_env.iter env (fun { name = _; typ; constraints } -> + self#visit_stype ctx typ; + self#visit_constraints ctx constraints) + + method visit_field_info : 'a -> field_info -> unit = fun _ -> fun _ -> () - method visit_field_info : 'a -> field_info -> unit = fun _ _ -> () - method private visit_syntax_hole : 'a -> Syntax.hole -> unit = fun _ _ -> () + method private visit_syntax_hole : 'a -> Syntax.hole -> unit = + fun _ -> fun _ -> () + + method visit_loop_label : 'a -> loop_label -> unit = fun _ -> fun _ -> () + + method visit_loop_label_binder : 'a -> loop_label_binder -> unit = + fun _ -> fun _ -> () end class ['a] mapbase = object (self) - method private visit_ident : 'a -> ident -> ident = fun _ e -> e - method visit_var : 'a -> var -> var = fun _ e -> e - method visit_binder : 'a -> binder -> binder = fun _ e -> e + method private visit_attributes : 'a -> attributes -> attributes = + fun _ -> fun x -> x + + method private visit_ident : 'a -> ident -> ident = fun _ -> fun e -> e + method visit_var : 'a -> var -> var = fun _ -> fun e -> e + method visit_binder : 'a -> binder -> binder = fun _ -> fun e -> e + + method visit_type_constraint : + 'a -> Tvar_env.type_constraint -> Tvar_env.type_constraint = + fun _ -> fun e -> e - method visit_type_constraint - : 'a -> Tvar_env.type_constraint -> Tvar_env.type_constraint = - fun _ e -> e + method visit_visibility : + 'a -> Typedecl_info.visibility -> Typedecl_info.visibility = + fun _ -> fun e -> e - method visit_visibility - : 'a -> Typedecl_info.visibility -> Typedecl_info.visibility = - fun _ e -> e + method private visit_type_component_visibility : + 'a -> + Typedecl_info.type_component_visibility -> + Typedecl_info.type_component_visibility = + fun _ -> fun e -> e method visit_constraints : 'a -> constraints -> constraints = - fun ctx cs -> Lst.map cs (fun c -> self#visit_type_constraint ctx c) + fun ctx -> + fun cs -> Lst.map cs (fun c -> self#visit_type_constraint ctx c) - method visit_argument_kind - : 'a -> Syntax.argument_kind -> Syntax.argument_kind = - fun _ e -> e + method visit_argument_kind : + 'a -> Syntax.argument_kind -> Syntax.argument_kind = + fun _ -> fun e -> e - method visit_fn_arity : 'a -> fn_arity -> fn_arity = fun _ e -> e - method visit_fn_kind : 'a -> fn_kind -> fn_kind = fun _ e -> e - method visit_prim : 'a -> Primitive.prim -> Primitive.prim = fun _ e -> e - method visit_location : 'a -> location -> location = fun _ e -> e + method visit_fn_arity : 'a -> fn_arity -> fn_arity = fun _ -> fun e -> e + method visit_fn_kind : 'a -> fn_kind -> fn_kind = fun _ -> fun e -> e + + method visit_prim : 'a -> Primitive.prim -> Primitive.prim = + fun _ -> fun e -> e + + method visit_location : 'a -> location -> location = fun _ -> fun e -> e method visit_absolute_loc : 'a -> absolute_loc -> absolute_loc = - fun _ e -> e + fun _ -> fun e -> e - method visit_label : 'a -> Syntax.label -> Syntax.label = fun _ e -> e + method visit_label : 'a -> Syntax.label -> Syntax.label = + fun _ -> fun e -> e method visit_accessor : 'a -> Syntax.accessor -> Syntax.accessor = - fun _ e -> e + fun _ -> fun e -> e + + method visit_constr_name : 'a -> Syntax.constr_name -> Syntax.constr_name = + fun _ -> fun e -> e + + method visit_constr_tag : 'a -> constr_tag -> constr_tag = + fun _ -> fun e -> e - method visit_constructor : 'a -> Syntax.constructor -> Syntax.constructor = - fun _ e -> e + method visit_func_stubs : 'a -> func_stubs -> func_stubs = + fun _ -> fun e -> e - method visit_constr_tag : 'a -> constr_tag -> constr_tag = fun _ e -> e - method visit_func_stubs : 'a -> func_stubs -> func_stubs = fun _ e -> e - method visit_pat_binders : 'a -> pat_binders -> pat_binders = fun _ e -> e - method visit_stype : 'a -> stype -> stype = fun _ e -> e + method visit_pat_binders : 'a -> pat_binders -> pat_binders = + fun _ -> fun e -> e + + method visit_stype : 'a -> stype -> stype = fun _ -> fun e -> e method visit_constrid_loc : 'a -> constrid_loc -> constrid_loc = - fun _ e -> e + fun _ -> fun e -> e method visit_syntax_binder : 'a -> syntax_binder -> syntax_binder = - fun _ e -> e + fun _ -> fun e -> e + + method visit_hole : 'a -> syntax_hole -> syntax_hole = fun _ -> fun e -> e - method visit_hole : 'a -> syntax_hole -> syntax_hole = fun _ e -> e - method visit_apply_kind : 'a -> apply_kind -> apply_kind = fun _ e -> e - method visit_type_name : 'a -> type_name -> type_name = fun _ e -> e + method visit_apply_kind : 'a -> apply_kind -> apply_kind = + fun _ -> fun e -> e + + method visit_type_name : 'a -> type_name -> type_name = fun _ -> fun e -> e method visit_type_path_loc : 'a -> type_path_loc -> type_path_loc = - fun _ e -> e + fun _ -> fun e -> e method visit_type_constr_loc : 'a -> type_constr_loc -> type_constr_loc = - fun _ e -> e + fun _ -> fun e -> e + + method visit_tvar_env : 'a -> tvar_env -> tvar_env = fun _ -> fun e -> e + method visit_docstring : 'a -> docstring -> docstring = fun _ -> fun e -> e - method visit_tvar_env : 'a -> tvar_env -> tvar_env = fun _ e -> e - method visit_docstring : 'a -> docstring -> docstring = fun _ e -> e - method visit_field_info : 'a -> field_info -> field_info = fun _ e -> e + method visit_field_info : 'a -> field_info -> field_info = + fun _ -> fun e -> e method private visit_syntax_hole : 'a -> Syntax.hole -> Syntax.hole = - fun _ e -> e + fun _ -> fun e -> e + + method visit_loop_label : 'a -> loop_label -> loop_label = + fun _ -> fun e -> e + + method visit_loop_label_binder : + 'a -> loop_label_binder -> loop_label_binder = + fun _ -> fun e -> e end class virtual ['a] sexpbase = object inherit [_] Sexp_visitors.sexp - method private visit_ident : 'a -> ident -> S.t = fun _ x -> sexp_of_ident x - method visit_var : 'a -> var -> S.t = fun _ x -> sexp_of_var x + + method private visit_attributes : 'a -> attributes -> S.t = + fun _ -> fun x -> sexp_of_attributes x + + method private visit_ident : 'a -> ident -> S.t = + fun _ -> fun x -> sexp_of_ident x + + method visit_var : 'a -> var -> S.t = fun _ -> fun x -> sexp_of_var x method visit_value_kind : 'a -> value_kind -> S.t = - fun _ x -> sexp_of_value_kind x + fun _ -> fun x -> sexp_of_value_kind x method visit_visibility : 'a -> Typedecl_info.visibility -> S.t = - fun _ x -> Typedecl_info.sexp_of_visibility x + fun _ -> fun x -> Typedecl_info.sexp_of_visibility x + + method visit_type_component_visibility : + 'a -> Typedecl_info.type_component_visibility -> S.t = + fun _ -> fun x -> Typedecl_info.sexp_of_type_component_visibility x - method visit_stype : 'a -> stype -> S.t = fun _ x -> sexp_of_stype x + method visit_stype : 'a -> stype -> S.t = fun _ -> fun x -> sexp_of_stype x method visit_prim : 'a -> Primitive.prim -> S.t = - fun _ x -> Primitive.sexp_of_prim x + fun _ -> fun x -> Primitive.sexp_of_prim x method visit_pat_binders : 'a -> pat_binders -> S.t = - fun _ x -> sexp_of_pat_binders x + fun _ -> fun x -> sexp_of_pat_binders x method visit_location : 'a -> location -> S.t = - fun _ x -> sexp_of_location x + fun _ -> fun x -> sexp_of_location x method visit_absolute_loc : 'a -> absolute_loc -> S.t = - fun _ x -> sexp_of_absolute_loc x + fun _ -> fun x -> sexp_of_absolute_loc x method visit_label : 'a -> Syntax.label -> S.t = - fun _ x -> Syntax.sexp_of_label x + fun _ -> fun x -> Syntax.sexp_of_label x method visit_func_stubs : 'a -> func_stubs -> S.t = - fun _ x -> sexp_of_func_stubs x + fun _ -> fun x -> sexp_of_func_stubs x - method visit_constructor : 'a -> Syntax.constructor -> S.t = - fun _ x -> Syntax.sexp_of_constructor x + method visit_constr_name : 'a -> Syntax.constr_name -> S.t = + fun _ -> fun x -> Syntax.sexp_of_constr_name x method visit_constrid_loc : 'a -> constrid_loc -> S.t = - fun _ x -> sexp_of_constrid_loc x + fun _ -> fun x -> sexp_of_constrid_loc x method visit_type_constraint : 'a -> Tvar_env.type_constraint -> S.t = - fun _ x -> Tvar_env.sexp_of_type_constraint x + fun _ -> fun x -> Tvar_env.sexp_of_type_constraint x method visit_argument_kind : 'a -> Syntax.argument_kind -> S.t = - fun _ x -> Syntax.sexp_of_argument_kind x + fun _ -> fun x -> Syntax.sexp_of_argument_kind x method visit_fn_arity : 'a -> fn_arity -> S.t = - fun _ x -> sexp_of_fn_arity x + fun _ -> fun x -> sexp_of_fn_arity x - method visit_fn_kind : 'a -> fn_kind -> S.t = fun _ x -> sexp_of_fn_kind x + method visit_fn_kind : 'a -> fn_kind -> S.t = + fun _ -> fun x -> sexp_of_fn_kind x method visit_syntax_binder : 'a -> syntax_binder -> S.t = - fun _ x -> sexp_of_syntax_binder x + fun _ -> fun x -> sexp_of_syntax_binder x method visit_hole : 'a -> syntax_hole -> S.t = - fun _ x -> sexp_of_syntax_hole x + fun _ -> fun x -> sexp_of_syntax_hole x method visit_constraints : 'a -> constraints -> S.t = - fun _ x -> sexp_of_constraints x + fun _ -> fun x -> sexp_of_constraints x method visit_constr_tag : 'a -> constr_tag -> S.t = - fun _ x -> sexp_of_constr_tag x + fun _ -> fun x -> sexp_of_constr_tag x method visit_constant : 'a -> constant -> S.t = - fun _ x -> sexp_of_constant x + fun _ -> fun x -> sexp_of_constant x - method visit_binder : 'a -> binder -> S.t = fun _ x -> sexp_of_binder x + method visit_binder : 'a -> binder -> S.t = + fun _ -> fun x -> sexp_of_binder x method visit_apply_kind : 'a -> apply_kind -> S.t = - fun _ x -> sexp_of_apply_kind x + fun _ -> fun x -> sexp_of_apply_kind x method visit_accessor : 'a -> Syntax.accessor -> S.t = - fun _ x -> Syntax.sexp_of_accessor x + fun _ -> fun x -> Syntax.sexp_of_accessor x method visit_type_constr_loc : 'a -> type_constr_loc -> S.t = - fun _ x -> sexp_of_type_constr_loc x + fun _ -> fun x -> sexp_of_type_constr_loc x method visit_type_name : 'a -> type_name -> S.t = - fun _ x -> sexp_of_type_name x + fun _ -> fun x -> sexp_of_type_name x method visit_type_path_loc : 'a -> type_path_loc -> S.t = - fun _ x -> sexp_of_type_path_loc x + fun _ -> fun x -> sexp_of_type_path_loc x method visit_tvar_env : 'a -> tvar_env -> S.t = - fun _ x -> sexp_of_tvar_env x + fun _ -> fun x -> sexp_of_tvar_env x method visit_docstring : 'a -> docstring -> S.t = - fun _ x -> sexp_of_docstring x + fun _ -> fun x -> sexp_of_docstring x method visit_field_info : 'a -> field_info -> S.t = - fun _ x -> sexp_of_field_info x + fun _ -> fun x -> sexp_of_field_info x method private visit_syntax_hole : 'a -> Syntax.hole -> S.t = - fun _ x -> sexp_of_syntax_hole x + fun _ -> fun x -> sexp_of_syntax_hole x + + method visit_expr_id : 'a -> expr_id -> S.t = + fun _ -> fun x -> sexp_of_expr_id x + + method visit_loop_label : 'a -> loop_label -> S.t = + fun _ -> fun x -> sexp_of_loop_label x - method visit_expr_id : 'a -> expr_id -> S.t = fun _ x -> sexp_of_expr_id x + method visit_loop_label_binder : 'a -> loop_label_binder -> S.t = + fun _ -> fun x -> sexp_of_loop_label_binder x end type stub_decl = { @@ -682,7 +818,7 @@ and expr = loc_ : location; } | Texpr_unresolved_method of { - trait_name : type_path_loc; + trait_name : type_name; method_name : string; self_type : stype; arity_ : fn_arity option; @@ -717,7 +853,8 @@ and expr = loc_ : location; } | Texpr_constr of { - constr : Syntax.constructor; + type_name : type_name option; + constr : Syntax.constr_name; tag : constr_tag; ty : stype; arity_ : fn_arity; @@ -728,9 +865,10 @@ and expr = loop_body : expr; while_else : expr option; ty : stype; + label : loop_label_binder option; loc_ : location; } - | Texpr_function of { func : fn; ty : stype; loc_ : location } + | Texpr_function of { func : fn; ty : stype; is_raw_ : bool; loc_ : location } | Texpr_if of { cond : expr; ifso : expr; @@ -761,8 +899,8 @@ and expr = loc_ : location; } | Texpr_sequence of { - expr1 : expr; - expr2 : expr; + exprs : expr list; + last_expr : expr; ty : stype; loc_ : location; } @@ -821,13 +959,24 @@ and expr = } | Texpr_hole of { ty : stype; loc_ : location; kind : syntax_hole } | Texpr_unit of { loc_ : location } - | Texpr_break of { arg : expr option; ty : stype; loc_ : location } - | Texpr_continue of { args : expr list; ty : stype; loc_ : location } + | Texpr_break of { + arg : expr option; + ty : stype; + label : loop_label option; + loc_ : location; + } + | Texpr_continue of { + args : expr list; + ty : stype; + label : loop_label option; + loc_ : location; + } | Texpr_loop of { params : param list; body : expr; args : expr list; ty : stype; + label : loop_label_binder option; loc_ : location; } | Texpr_for of { @@ -837,6 +986,7 @@ and expr = body : expr; for_else : expr option; ty : stype; + label : loop_label_binder option; loc_ : location; } | Texpr_foreach of { @@ -846,6 +996,7 @@ and expr = body : expr; else_block : expr option; ty : stype; + label : loop_label_binder option; loc_ : location; } | Texpr_return of { return_value : expr option; ty : stype; loc_ : location } @@ -891,6 +1042,15 @@ and expr = ty : stype; loc_ : location; } + | Texpr_is of { + expr : expr; + pat : pat; + pat_binders : pat_binders; + loc_ : location; + } + | Texpr_array_as_view of { array : expr; ty : stype; loc_ : location } + | Texpr_and of { lhs : expr; rhs : expr; loc_ : location } + | Texpr_or of { lhs : expr; rhs : expr; loc_ : location } and argument = { arg_value : expr; arg_kind : Syntax.argument_kind } @@ -926,6 +1086,11 @@ and param = ty : stype; kind : param_kind; } + | Discard_positional_param of { + ty : stype; + konstraint : typ option; + loc_ : location; + } and param_kind = | Positional @@ -945,7 +1110,12 @@ and fn = { kind_ : fn_kind; } -and match_case = { pat : pat; action : expr; pat_binders : pat_binders } +and match_case = { + pat : pat; + action : expr; + guard : expr option; + pat_binders : pat_binders; +} and error_typ = | Error_typ of { ty : typ } @@ -969,6 +1139,12 @@ and typ = is_alias_ : bool; loc_ : location; } + | Tobject of { + constr : constrid_loc; + ty : stype; + is_alias_ : bool; + loc_ : location; + } and pat = | Tpat_alias of { pat : pat; alias : binder; ty : stype; loc_ : location } @@ -981,11 +1157,14 @@ and pat = loc_ : location; } | Tpat_constr of { - constr : Syntax.constructor; + type_name : type_name option; + constr : Syntax.constr_name; args : constr_pat_args; tag : constr_tag; ty : stype; used_error_subtyping : bool; + arity_ : fn_arity; + all_args_ : stype list; loc_ : location; } | Tpat_or of { pat1 : pat; pat2 : pat; ty : stype; loc_ : location } @@ -1027,7 +1206,9 @@ and fun_decl = { fn : fn; is_pub : bool; ty_params_ : tvar_env; + constraint_names : type_name list; mutable doc_ : docstring; [@dead "fun_decl.doc_"] + attrs : attributes; } and fun_decl_kind = @@ -1057,6 +1238,7 @@ and impl = is_pub : bool; loc_ : absolute_loc; mutable doc_ : docstring; + attrs : attributes; is_generated_ : bool; } | Timpl_stub_decl of stub_decl @@ -1070,7 +1252,7 @@ and type_decl = { td_vis : Typedecl_info.visibility; td_loc_ : absolute_loc; td_doc_ : docstring; [@dead "type_decl.td_doc_"] - td_deriving_ : constrid_loc list; + td_deriving_ : type_name list; } and exception_decl = @@ -1104,16 +1286,26 @@ and field_decl = { field_label : Syntax.label; field_typ : typ; field_mut : bool; - field_vis : Typedecl_info.visibility; + field_vis : Typedecl_info.type_component_visibility; field_loc_ : location; [@dead "field_decl.field_loc_"] } and trait_decl = { trait_name : type_constr_loc; + trait_supers : type_name list; [@dead "trait_decl.trait_supers"] trait_methods : method_decl list; trait_vis : Typedecl_info.visibility; trait_loc_ : absolute_loc; trait_doc_ : docstring; [@dead "trait_decl.trait_doc_"] + trait_attrs : attributes; [@dead "trait_decl.trait_attrs"] +} + +and trait_alias_decl = { + trait_alias_name : type_constr_loc; + trait_alias_target : type_name; + trait_alias_is_pub : bool; + trait_alias_loc_ : absolute_loc; + trait_alias_doc_ : docstring; [@dead "trait_alias_decl.trait_alias_doc_"] } and method_decl = { @@ -1129,6 +1321,7 @@ and output = value_defs : impls; type_defs : type_decl list; trait_defs : trait_decl list; + trait_alias : trait_alias_decl list; } include struct @@ -1140,2439 +1333,3104 @@ include struct inherit [_] sexpbase method visit_stub_decl : _ -> stub_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_params env _visitors_this.params in - let _visitors_r2 = - self#visit_option self#visit_typ env _visitors_this.ret - in - let _visitors_r3 = - self#visit_stub_body env _visitors_this.func_stubs - in - let _visitors_r4 = self#visit_bool env _visitors_this.is_pub in - let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in - let _visitors_r6 = - self#visit_fun_decl_kind env _visitors_this.kind_ - in - let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - self#visit_record env - [ - ("binder", _visitors_r0); - ("params", _visitors_r1); - ("ret", _visitors_r2); - ("func_stubs", _visitors_r3); - ("is_pub", _visitors_r4); - ("arity_", _visitors_r5); - ("kind_", _visitors_r6); - ("loc_", _visitors_r7); - ("doc_", _visitors_r8); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_params env _visitors_this.params in + let _visitors_r2 = + self#visit_option self#visit_typ env _visitors_this.ret + in + let _visitors_r3 = + self#visit_stub_body env _visitors_this.func_stubs + in + let _visitors_r4 = self#visit_bool env _visitors_this.is_pub in + let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in + let _visitors_r6 = + self#visit_fun_decl_kind env _visitors_this.kind_ + in + let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in + let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in + self#visit_record env + [ + ("binder", _visitors_r0); + ("params", _visitors_r1); + ("ret", _visitors_r2); + ("func_stubs", _visitors_r3); + ("is_pub", _visitors_r4); + ("arity_", _visitors_r5); + ("kind_", _visitors_r6); + ("loc_", _visitors_r7); + ("doc_", _visitors_r8); + ] method visit_Intrinsic : _ -> S.t = fun env -> self#visit_inline_tuple env "Intrinsic" [] method visit_Func_stub : _ -> func_stubs -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - self#visit_inline_tuple env "Func_stub" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + self#visit_inline_tuple env "Func_stub" [ _visitors_r0 ] method visit_stub_body : _ -> stub_body -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Intrinsic -> self#visit_Intrinsic env - | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 - - method visit_Texpr_apply - : _ -> expr -> argument list -> stype -> apply_kind -> location -> S.t + fun env -> + fun _visitors_this -> + match _visitors_this with + | Intrinsic -> self#visit_Intrinsic env + | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 + + method visit_Texpr_apply : + _ -> expr -> argument list -> stype -> apply_kind -> location -> S.t = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_fkind_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + self#visit_list self#visit_argument env _visitors_fargs + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_apply" + [ + ("func", _visitors_r0); + ("args", _visitors_r1); + ("ty", _visitors_r2); + ("kind_", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_method : + _ -> + var -> + stype array -> + fn_arity option -> + type_name -> + Primitive.prim option -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_fmeth -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_ftype_name -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fmeth in + let _visitors_r1 = + self#visit_array self#visit_stype env _visitors_fty_args_ + in + let _visitors_r2 = + self#visit_option self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r3 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r4 = + self#visit_option self#visit_prim env _visitors_fprim + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_method" + [ + ("meth", _visitors_r0); + ("ty_args_", _visitors_r1); + ("arity_", _visitors_r2); + ("type_name", _visitors_r3); + ("prim", _visitors_r4); + ("ty", _visitors_r5); + ("loc_", _visitors_r6); + ] + + method visit_Texpr_unresolved_method : + _ -> + type_name -> + string -> + stype -> + fn_arity option -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_ftrait_name -> + fun _visitors_fmethod_name -> + fun _visitors_fself_type -> + fun _visitors_farity_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftrait_name + in + let _visitors_r1 = + self#visit_string env _visitors_fmethod_name + in + let _visitors_r2 = self#visit_stype env _visitors_fself_type in + let _visitors_r3 = + self#visit_option self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_unresolved_method" + [ + ("trait_name", _visitors_r0); + ("method_name", _visitors_r1); + ("self_type", _visitors_r2); + ("arity_", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_ident : + _ -> + var -> + stype array -> + fn_arity option -> + value_kind -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_fid -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + self#visit_array self#visit_stype env _visitors_fty_args_ + in + let _visitors_r2 = + self#visit_option self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r3 = self#visit_value_kind env _visitors_fkind in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_ident" + [ + ("id", _visitors_r0); + ("ty_args_", _visitors_r1); + ("arity_", _visitors_r2); + ("kind", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_as : + _ -> expr -> type_name -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fty -> + fun _visitors_fis_implicit -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_bool env _visitors_fis_implicit in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_as" + [ + ("expr", _visitors_r0); + ("trait", _visitors_r1); + ("ty", _visitors_r2); + ("is_implicit", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_array : + _ -> expr list -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_fis_fixed_array -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_bool env _visitors_fis_fixed_array + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_array" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("is_fixed_array", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_constant : + _ -> constant -> stype -> var option -> location -> S.t = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_option self#visit_var env _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_constant" + [ + ("c", _visitors_r0); + ("ty", _visitors_r1); + ("name_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_tag -> + stype -> + fn_arity -> + location -> + S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_constr" + [ + ("type_name", _visitors_r0); + ("constr", _visitors_r1); + ("tag", _visitors_r2); + ("ty", _visitors_r3); + ("arity_", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_while : + _ -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + S.t = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fwhile_else + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + self#visit_option self#visit_loop_label_binder env + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_while" + [ + ("loop_cond", _visitors_r0); + ("loop_body", _visitors_r1); + ("while_else", _visitors_r2); + ("ty", _visitors_r3); + ("label", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_function : _ -> fn -> stype -> bool -> location -> S.t = - fun env _visitors_ffunc _visitors_fargs _visitors_fty _visitors_fkind_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - self#visit_list self#visit_argument env _visitors_fargs - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_apply" - [ - ("func", _visitors_r0); - ("args", _visitors_r1); - ("ty", _visitors_r2); - ("kind_", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_bool env _visitors_fis_raw_ in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_function" + [ + ("func", _visitors_r0); + ("ty", _visitors_r1); + ("is_raw_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_if : + _ -> expr -> expr -> expr option -> stype -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_fifnot + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_if" + [ + ("cond", _visitors_r0); + ("ifso", _visitors_r1); + ("ifnot", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_letfn : + _ -> binder -> fn -> expr -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fis_rec -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_bool env _visitors_fis_rec in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_letfn" + [ + ("binder", _visitors_r0); + ("fn", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("is_rec", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_letrec : + _ -> (binder * fn) list -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_letrec" + [ + ("bindings", _visitors_r0); + ("body", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_let : + _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_let" + [ + ("pat", _visitors_r0); + ("rhs", _visitors_r1); + ("pat_binders", _visitors_r2); + ("body", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_sequence : + _ -> expr list -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_sequence" + [ + ("exprs", _visitors_r0); + ("last_expr", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] - method visit_Texpr_method - : _ -> - var -> - stype array -> - fn_arity option -> - type_name -> - Primitive.prim option -> - stype -> - location -> - S.t = - fun env _visitors_fmeth _visitors_fty_args_ _visitors_farity_ - _visitors_ftype_name _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fmeth in - let _visitors_r1 = - self#visit_array self#visit_stype env _visitors_fty_args_ - in - let _visitors_r2 = - self#visit_option self#visit_fn_arity env _visitors_farity_ - in - let _visitors_r3 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r4 = - self#visit_option self#visit_prim env _visitors_fprim - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_method" - [ - ("meth", _visitors_r0); - ("ty_args_", _visitors_r1); - ("arity_", _visitors_r2); - ("type_name", _visitors_r3); - ("prim", _visitors_r4); - ("ty", _visitors_r5); - ("loc_", _visitors_r6); - ] + method visit_Texpr_tuple : _ -> expr list -> stype -> location -> S.t = + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_tuple" + [ + ("exprs", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Texpr_record : + _ -> type_name option -> field_def list -> stype -> location -> S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env _visitors_ftype_name + in + let _visitors_r1 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_record" + [ + ("type_name", _visitors_r0); + ("fields", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_record_update : + _ -> + type_name option -> + expr -> + field_info list -> + field_def list -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_fall_fields -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + self#visit_list self#visit_field_info env + _visitors_fall_fields + in + let _visitors_r3 = + self#visit_list self#visit_field_def env _visitors_ffields + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_record_update" + [ + ("type_name", _visitors_r0); + ("record", _visitors_r1); + ("all_fields", _visitors_r2); + ("fields", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_field : + _ -> expr -> Syntax.accessor -> int -> stype -> location -> S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = self#visit_int env _visitors_fpos in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_field" + [ + ("record", _visitors_r0); + ("accessor", _visitors_r1); + ("pos", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_mutate : + _ -> + expr -> + Syntax.label -> + expr -> + int -> + expr option -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = self#visit_int env _visitors_fpos in + let _visitors_r4 = + self#visit_option self#visit_expr env _visitors_faugmented_by + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_mutate" + [ + ("record", _visitors_r0); + ("label", _visitors_r1); + ("field", _visitors_r2); + ("pos", _visitors_r3); + ("augmented_by", _visitors_r4); + ("ty", _visitors_r5); + ("loc_", _visitors_r6); + ] + + method visit_Texpr_match : + _ -> expr -> match_case list -> stype -> location -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fty -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + self#visit_list self#visit_match_case env _visitors_fcases + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + self#visit_location env _visitors_fmatch_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_match" + [ + ("expr", _visitors_r0); + ("cases", _visitors_r1); + ("ty", _visitors_r2); + ("match_loc_", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_letmut : + _ -> binder -> typ option -> expr -> expr -> stype -> location -> S.t + = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_letmut" + [ + ("binder", _visitors_r0); + ("konstraint", _visitors_r1); + ("expr", _visitors_r2); + ("body", _visitors_r3); + ("ty", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_assign : + _ -> var -> expr -> expr option -> stype -> location -> S.t = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_faugmented_by + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_assign" + [ + ("var", _visitors_r0); + ("expr", _visitors_r1); + ("augmented_by", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] - method visit_Texpr_unresolved_method - : _ -> - type_path_loc -> - string -> - stype -> - fn_arity option -> - stype -> - location -> - S.t = - fun env _visitors_ftrait_name _visitors_fmethod_name - _visitors_fself_type _visitors_farity_ _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_type_path_loc env _visitors_ftrait_name - in - let _visitors_r1 = self#visit_string env _visitors_fmethod_name in - let _visitors_r2 = self#visit_stype env _visitors_fself_type in - let _visitors_r3 = - self#visit_option self#visit_fn_arity env _visitors_farity_ - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_unresolved_method" - [ - ("trait_name", _visitors_r0); - ("method_name", _visitors_r1); - ("self_type", _visitors_r2); - ("arity_", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_Texpr_hole : _ -> stype -> location -> syntax_hole -> S.t = + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in + self#visit_inline_record env "Texpr_hole" + [ + ("ty", _visitors_r0); + ("loc_", _visitors_r1); + ("kind", _visitors_r2); + ] - method visit_Texpr_ident - : _ -> - var -> - stype array -> - fn_arity option -> - value_kind -> - stype -> - location -> - S.t = - fun env _visitors_fid _visitors_fty_args_ _visitors_farity_ - _visitors_fkind _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - self#visit_array self#visit_stype env _visitors_fty_args_ - in - let _visitors_r2 = - self#visit_option self#visit_fn_arity env _visitors_farity_ - in - let _visitors_r3 = self#visit_value_kind env _visitors_fkind in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_ident" - [ - ("id", _visitors_r0); - ("ty_args_", _visitors_r1); - ("arity_", _visitors_r2); - ("kind", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_Texpr_unit : _ -> location -> S.t = + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_unit" [ ("loc_", _visitors_r0) ] + + method visit_Texpr_break : + _ -> expr option -> stype -> loop_label option -> location -> S.t = + fun env -> + fun _visitors_farg -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_farg + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_option self#visit_loop_label env _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_break" + [ + ("arg", _visitors_r0); + ("ty", _visitors_r1); + ("label", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_continue : + _ -> expr list -> stype -> loop_label option -> location -> S.t = + fun env -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_option self#visit_loop_label env _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_continue" + [ + ("args", _visitors_r0); + ("ty", _visitors_r1); + ("label", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_loop : + _ -> + param list -> + expr -> + expr list -> + stype -> + loop_label_binder option -> + location -> + S.t = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_param env _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + self#visit_list self#visit_expr env _visitors_fargs + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + self#visit_option self#visit_loop_label_binder env + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_loop" + [ + ("params", _visitors_r0); + ("body", _visitors_r1); + ("args", _visitors_r2); + ("ty", _visitors_r3); + ("label", _visitors_r4); + ("loc_", _visitors_r5); + ] + + method visit_Texpr_for : + _ -> + (binder * expr) list -> + expr option -> + (var * expr) list -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + S.t = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fsteps -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fbinders + in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_fcondition + in + let _visitors_r2 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_fsteps + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + self#visit_option self#visit_expr env _visitors_ffor_else + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + self#visit_option self#visit_loop_label_binder env + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_for" + [ + ("binders", _visitors_r0); + ("condition", _visitors_r1); + ("steps", _visitors_r2); + ("body", _visitors_r3); + ("for_else", _visitors_r4); + ("ty", _visitors_r5); + ("label", _visitors_r6); + ("loc_", _visitors_r7); + ] + + method visit_Texpr_foreach : + _ -> + binder option list -> + stype list -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + S.t = + fun env -> + fun _visitors_fbinders -> + fun _visitors_felem_tys -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (self#visit_option self#visit_binder) + env _visitors_fbinders + in + let _visitors_r1 = + self#visit_list self#visit_stype env _visitors_felem_tys + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + self#visit_option self#visit_expr env _visitors_felse_block + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + self#visit_option self#visit_loop_label_binder env + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_foreach" + [ + ("binders", _visitors_r0); + ("elem_tys", _visitors_r1); + ("expr", _visitors_r2); + ("body", _visitors_r3); + ("else_block", _visitors_r4); + ("ty", _visitors_r5); + ("label", _visitors_r6); + ("loc_", _visitors_r7); + ] - method visit_Texpr_as - : _ -> expr -> type_name -> stype -> bool -> location -> S.t = - fun env _visitors_fexpr _visitors_ftrait _visitors_fty - _visitors_fis_implicit _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_bool env _visitors_fis_implicit in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_as" - [ - ("expr", _visitors_r0); - ("trait", _visitors_r1); - ("ty", _visitors_r2); - ("is_implicit", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_Texpr_return : _ -> expr option -> stype -> location -> S.t = + fun env -> + fun _visitors_freturn_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_expr env _visitors_freturn_value + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_return" + [ + ("return_value", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_array - : _ -> expr list -> stype -> bool -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_fis_fixed_array - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_bool env _visitors_fis_fixed_array in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_array" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("is_fixed_array", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_Texpr_raise : _ -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_ferror_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferror_value in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_raise" + [ + ("error_value", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Texpr_try : + _ -> + expr -> + match_case list -> + bool -> + match_case list option -> + stype -> + stype -> + location -> + location -> + location -> + S.t = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_fty -> + fun _visitors_ferr_ty -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = + self#visit_list self#visit_match_case env _visitors_fcatch + in + let _visitors_r2 = + self#visit_bool env _visitors_fcatch_all + in + let _visitors_r3 = + self#visit_option + (self#visit_list self#visit_match_case) + env _visitors_ftry_else + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in + let _visitors_r6 = + self#visit_location env _visitors_fcatch_loc_ + in + let _visitors_r7 = + self#visit_location env _visitors_felse_loc_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_try" + [ + ("body", _visitors_r0); + ("catch", _visitors_r1); + ("catch_all", _visitors_r2); + ("try_else", _visitors_r3); + ("ty", _visitors_r4); + ("err_ty", _visitors_r5); + ("catch_loc_", _visitors_r6); + ("else_loc_", _visitors_r7); + ("loc_", _visitors_r8); + ] + + method visit_Texpr_exclamation : + _ -> expr -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_fconvert_to_result -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_bool env _visitors_fconvert_to_result + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_exclamation" + [ + ("expr", _visitors_r0); + ("ty", _visitors_r1); + ("convert_to_result", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_constraint : + _ -> expr -> typ -> stype -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_constraint" + [ + ("expr", _visitors_r0); + ("konstraint", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_pipe : + _ -> expr -> pipe_rhs -> stype -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_pipe" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_interp : + _ -> interp_elem list -> stype -> location -> S.t = + fun env -> + fun _visitors_felems -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_interp_elem env _visitors_felems + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_interp" + [ + ("elems", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Texpr_guard : + _ -> expr -> expr option -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + self#visit_option self#visit_expr env _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_guard" + [ + ("cond", _visitors_r0); + ("otherwise", _visitors_r1); + ("body", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Texpr_guard_let : + _ -> + pat -> + expr -> + pat_binders -> + match_case list option -> + expr -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = + self#visit_option + (self#visit_list self#visit_match_case) + env _visitors_fotherwise + in + let _visitors_r4 = self#visit_expr env _visitors_fbody in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_guard_let" + [ + ("pat", _visitors_r0); + ("rhs", _visitors_r1); + ("pat_binders", _visitors_r2); + ("otherwise", _visitors_r3); + ("body", _visitors_r4); + ("ty", _visitors_r5); + ("loc_", _visitors_r6); + ] + + method visit_Texpr_is : _ -> expr -> pat -> pat_binders -> location -> S.t + = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_fpat_binders -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_is" + [ + ("expr", _visitors_r0); + ("pat", _visitors_r1); + ("pat_binders", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Texpr_array_as_view : _ -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_farray -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_array_as_view" + [ + ("array", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Texpr_and : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_and" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Texpr_or : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Texpr_or" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_constant - : _ -> constant -> stype -> var option -> location -> S.t = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - self#visit_option self#visit_var env _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_constant" - [ - ("c", _visitors_r0); - ("ty", _visitors_r1); - ("name_", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_expr : _ -> expr -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Texpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + ty = _visitors_fty; + kind_ = _visitors_fkind_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fty _visitors_fkind_ _visitors_floc_ + | Texpr_method + { + meth = _visitors_fmeth; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + type_name = _visitors_ftype_name; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ + _visitors_farity_ _visitors_ftype_name _visitors_fprim + _visitors_fty _visitors_floc_ + | Texpr_unresolved_method + { + trait_name = _visitors_ftrait_name; + method_name = _visitors_fmethod_name; + self_type = _visitors_fself_type; + arity_ = _visitors_farity_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_unresolved_method env _visitors_ftrait_name + _visitors_fmethod_name _visitors_fself_type _visitors_farity_ + _visitors_fty _visitors_floc_ + | Texpr_ident + { + id = _visitors_fid; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + kind = _visitors_fkind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ + _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ + | Texpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + ty = _visitors_fty; + is_implicit = _visitors_fis_implicit; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fty _visitors_fis_implicit _visitors_floc_ + | Texpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + is_fixed_array = _visitors_fis_fixed_array; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array env _visitors_fexprs _visitors_fty + _visitors_fis_fixed_array _visitors_floc_ + | Texpr_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Texpr_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + tag = _visitors_ftag; + ty = _visitors_fty; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constr env _visitors_ftype_name + _visitors_fconstr _visitors_ftag _visitors_fty + _visitors_farity_ _visitors_floc_ + | Texpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Texpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Texpr_letfn + { + binder = _visitors_fbinder; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + is_rec = _visitors_fis_rec; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ + | Texpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fbody _visitors_fty + _visitors_floc_ + | Texpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Texpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Texpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record env _visitors_ftype_name + _visitors_ffields _visitors_fty _visitors_floc_ + | Texpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + all_fields = _visitors_fall_fields; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_fall_fields _visitors_ffields + _visitors_fty _visitors_floc_ + | Texpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_field env _visitors_frecord _visitors_faccessor + _visitors_fpos _visitors_fty _visitors_floc_ + | Texpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_faugmented_by + _visitors_fty _visitors_floc_ + | Texpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + ty = _visitors_fty; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_match env _visitors_fexpr _visitors_fcases + _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ + | Texpr_letmut + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letmut env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_fty _visitors_floc_ + | Texpr_hole + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + kind = _visitors_fkind; + } -> + self#visit_Texpr_hole env _visitors_fty _visitors_floc_ + _visitors_fkind + | Texpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Texpr_unit env _visitors_floc_ + | Texpr_break + { + arg = _visitors_farg; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_break env _visitors_farg _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_continue + { + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_continue env _visitors_fargs _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + steps = _visitors_fsteps; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition + _visitors_fsteps _visitors_fbody _visitors_ffor_else + _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_foreach + { + binders = _visitors_fbinders; + elem_tys = _visitors_felem_tys; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_foreach env _visitors_fbinders + _visitors_felem_tys _visitors_fexpr _visitors_fbody + _visitors_felse_block _visitors_fty _visitors_flabel + _visitors_floc_ + | Texpr_return + { + return_value = _visitors_freturn_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_return env _visitors_freturn_value _visitors_fty + _visitors_floc_ + | Texpr_raise + { + error_value = _visitors_ferror_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty + _visitors_floc_ + | Texpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + ty = _visitors_fty; + err_ty = _visitors_ferr_ty; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_fty + _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ + _visitors_floc_ + | Texpr_exclamation + { + expr = _visitors_fexpr; + ty = _visitors_fty; + convert_to_result = _visitors_fconvert_to_result; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty + _visitors_fconvert_to_result _visitors_floc_ + | Texpr_constraint + { + expr = _visitors_fexpr; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constraint env _visitors_fexpr + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Texpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs + _visitors_fty _visitors_floc_ + | Texpr_interp + { + elems = _visitors_felems; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_interp env _visitors_felems _visitors_fty + _visitors_floc_ + | Texpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_fty _visitors_floc_ + | Texpr_guard_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fotherwise _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + pat_binders = _visitors_fpat_binders; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_is env _visitors_fexpr _visitors_fpat + _visitors_fpat_binders _visitors_floc_ + | Texpr_array_as_view + { + array = _visitors_farray; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array_as_view env _visitors_farray _visitors_fty + _visitors_floc_ + | Texpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Texpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ - method visit_Texpr_constr - : _ -> - Syntax.constructor -> - constr_tag -> - stype -> - fn_arity -> - location -> - S.t = - fun env _visitors_fconstr _visitors_ftag _visitors_fty _visitors_farity_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_constr" - [ - ("constr", _visitors_r0); - ("tag", _visitors_r1); - ("ty", _visitors_r2); - ("arity_", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_argument : _ -> argument -> S.t = + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + self#visit_record env + [ ("arg_value", _visitors_r0); ("arg_kind", _visitors_r1) ] + + method visit_Pipe_partial_apply : + _ -> expr -> argument list -> location -> S.t = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + self#visit_list self#visit_argument env _visitors_fargs + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pipe_partial_apply" + [ + ("func", _visitors_r0); + ("args", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_while - : _ -> expr -> expr -> expr option -> stype -> location -> S.t = - fun env _visitors_floop_cond _visitors_floop_body _visitors_fwhile_else - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fwhile_else - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_while" - [ - ("loop_cond", _visitors_r0); - ("loop_body", _visitors_r1); - ("while_else", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_Pipe_invalid : _ -> expr -> stype -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Pipe_invalid" + [ + ("expr", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_function : _ -> fn -> stype -> location -> S.t = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_function" - [ - ("func", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + method visit_pipe_rhs : _ -> pipe_rhs -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pipe_partial_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs + _visitors_floc_ + | Pipe_invalid + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty + _visitors_floc_ - method visit_Texpr_if - : _ -> expr -> expr -> expr option -> stype -> location -> S.t = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_fifnot - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_if" - [ - ("cond", _visitors_r0); - ("ifso", _visitors_r1); - ("ifnot", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_Interp_lit : _ -> string -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_string env _visitors_c0 in + self#visit_inline_tuple env "Interp_lit" [ _visitors_r0 ] - method visit_Texpr_letfn - : _ -> binder -> fn -> expr -> stype -> bool -> location -> S.t = - fun env _visitors_fbinder _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fis_rec _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_bool env _visitors_fis_rec in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_letfn" - [ - ("binder", _visitors_r0); - ("fn", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("is_rec", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_Interp_expr : _ -> expr -> expr -> location -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fto_string -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_expr env _visitors_fto_string in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Interp_expr" + [ + ("expr", _visitors_r0); + ("to_string", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_letrec - : _ -> (binder * fn) list -> expr -> stype -> location -> S.t = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_letrec" - [ - ("bindings", _visitors_r0); - ("body", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_interp_elem : _ -> interp_elem -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 + | Interp_expr + { + expr = _visitors_fexpr; + to_string = _visitors_fto_string; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string + _visitors_floc_ + + method visit_Field_def : + _ -> Syntax.label -> expr -> bool -> bool -> int -> S.t = + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_mut -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = self#visit_bool env _visitors_fis_mut in + let _visitors_r3 = self#visit_bool env _visitors_fis_pun in + let _visitors_r4 = self#visit_int env _visitors_fpos in + self#visit_inline_record env "Field_def" + [ + ("label", _visitors_r0); + ("expr", _visitors_r1); + ("is_mut", _visitors_r2); + ("is_pun", _visitors_r3); + ("pos", _visitors_r4); + ] - method visit_Texpr_let - : _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> S.t - = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_let" - [ - ("pat", _visitors_r0); - ("rhs", _visitors_r1); - ("pat_binders", _visitors_r2); - ("body", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_field_def : _ -> field_def -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_mut = _visitors_fis_mut; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_mut _visitors_fis_pun _visitors_fpos - method visit_Texpr_sequence - : _ -> expr -> expr -> stype -> location -> S.t = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_sequence" - [ - ("expr1", _visitors_r0); - ("expr2", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_Field_pat : _ -> Syntax.label -> pat -> bool -> int -> S.t = + fun env -> + fun _visitors_flabel -> + fun _visitors_fpat -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = self#visit_bool env _visitors_fis_pun in + let _visitors_r3 = self#visit_int env _visitors_fpos in + self#visit_inline_record env "Field_pat" + [ + ("label", _visitors_r0); + ("pat", _visitors_r1); + ("is_pun", _visitors_r2); + ("pos", _visitors_r3); + ] - method visit_Texpr_tuple : _ -> expr list -> stype -> location -> S.t = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_tuple" - [ - ("exprs", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + method visit_field_pat : _ -> field_pat -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pat = _visitors_fpat; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpat + _visitors_fis_pun _visitors_fpos - method visit_Texpr_record - : _ -> type_name option -> field_def list -> stype -> location -> S.t - = - fun env _visitors_ftype_name _visitors_ffields _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_type_name env _visitors_ftype_name - in - let _visitors_r1 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_record" - [ - ("type_name", _visitors_r0); - ("fields", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + method visit_constr_pat_args : _ -> constr_pat_args -> S.t = + fun env -> self#visit_list self#visit_constr_pat_arg env - method visit_Texpr_record_update - : _ -> - type_name option -> - expr -> - field_info list -> - field_def list -> - stype -> - location -> - S.t = - fun env _visitors_ftype_name _visitors_frecord _visitors_fall_fields - _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_type_name env _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - self#visit_list self#visit_field_info env _visitors_fall_fields - in - let _visitors_r3 = - self#visit_list self#visit_field_def env _visitors_ffields - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_record_update" - [ - ("type_name", _visitors_r0); - ("record", _visitors_r1); - ("all_fields", _visitors_r2); - ("fields", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_Constr_pat_arg : + _ -> pat -> Syntax.argument_kind -> int -> S.t = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + let _visitors_r2 = self#visit_int env _visitors_fpos in + self#visit_inline_record env "Constr_pat_arg" + [ + ("pat", _visitors_r0); + ("kind", _visitors_r1); + ("pos", _visitors_r2); + ] - method visit_Texpr_field - : _ -> expr -> Syntax.accessor -> int -> stype -> location -> S.t = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = self#visit_int env _visitors_fpos in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_field" - [ - ("record", _visitors_r0); - ("accessor", _visitors_r1); - ("pos", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_constr_pat_arg : _ -> constr_pat_arg -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg + { + pat = _visitors_fpat; + kind = _visitors_fkind; + pos = _visitors_fpos; + } -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + _visitors_fpos + + method visit_Param : + _ -> binder -> typ option -> stype -> param_kind -> S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fkonstraint + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_param_kind env _visitors_fkind in + self#visit_inline_record env "Param" + [ + ("binder", _visitors_r0); + ("konstraint", _visitors_r1); + ("ty", _visitors_r2); + ("kind", _visitors_r3); + ] + + method visit_Discard_positional_param : + _ -> stype -> typ option -> location -> S.t = + fun env -> + fun _visitors_fty -> + fun _visitors_fkonstraint -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fkonstraint + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Discard_positional_param" + [ + ("ty", _visitors_r0); + ("konstraint", _visitors_r1); + ("loc_", _visitors_r2); + ] - method visit_Texpr_mutate - : _ -> - expr -> - Syntax.label -> - expr -> - int -> - expr option -> - stype -> - location -> - S.t = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_faugmented_by _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = self#visit_int env _visitors_fpos in - let _visitors_r4 = - self#visit_option self#visit_expr env _visitors_faugmented_by - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_mutate" - [ - ("record", _visitors_r0); - ("label", _visitors_r1); - ("field", _visitors_r2); - ("pos", _visitors_r3); - ("augmented_by", _visitors_r4); - ("ty", _visitors_r5); - ("loc_", _visitors_r6); - ] + method visit_param : _ -> param -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Param + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + kind = _visitors_fkind; + } -> + self#visit_Param env _visitors_fbinder _visitors_fkonstraint + _visitors_fty _visitors_fkind + | Discard_positional_param + { + ty = _visitors_fty; + konstraint = _visitors_fkonstraint; + loc_ = _visitors_floc_; + } -> + self#visit_Discard_positional_param env _visitors_fty + _visitors_fkonstraint _visitors_floc_ - method visit_Texpr_match - : _ -> expr -> match_case list -> stype -> location -> location -> S.t - = - fun env _visitors_fexpr _visitors_fcases _visitors_fty - _visitors_fmatch_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - self#visit_list self#visit_match_case env _visitors_fcases - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_fmatch_loc_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_match" - [ - ("expr", _visitors_r0); - ("cases", _visitors_r1); - ("ty", _visitors_r2); - ("match_loc_", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_Positional : _ -> S.t = + fun env -> self#visit_inline_tuple env "Positional" [] - method visit_Texpr_letmut - : _ -> - binder -> - typ option -> - expr -> - expr -> - stype -> - location -> - S.t = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_letmut" - [ - ("binder", _visitors_r0); - ("konstraint", _visitors_r1); - ("expr", _visitors_r2); - ("body", _visitors_r3); - ("ty", _visitors_r4); - ("loc_", _visitors_r5); - ] + method visit_Labelled : _ -> S.t = + fun env -> self#visit_inline_tuple env "Labelled" [] - method visit_Texpr_assign - : _ -> var -> expr -> expr option -> stype -> location -> S.t = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - self#visit_option self#visit_expr env _visitors_faugmented_by - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_assign" - [ - ("var", _visitors_r0); - ("expr", _visitors_r1); - ("augmented_by", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + method visit_Optional : _ -> expr -> S.t = + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + self#visit_inline_tuple env "Optional" [ _visitors_r0 ] - method visit_Texpr_hole : _ -> stype -> location -> syntax_hole -> S.t = - fun env _visitors_fty _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in - self#visit_inline_record env "Texpr_hole" - [ - ("ty", _visitors_r0); - ("loc_", _visitors_r1); - ("kind", _visitors_r2); - ] + method visit_Autofill : _ -> S.t = + fun env -> self#visit_inline_tuple env "Autofill" [] - method visit_Texpr_unit : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_unit" [ ("loc_", _visitors_r0) ] - - method visit_Texpr_break : _ -> expr option -> stype -> location -> S.t = - fun env _visitors_farg _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_farg - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_break" - [ - ("arg", _visitors_r0); ("ty", _visitors_r1); ("loc_", _visitors_r2); - ] + method visit_Question_optional : _ -> S.t = + fun env -> self#visit_inline_tuple env "Question_optional" [] - method visit_Texpr_continue : _ -> expr list -> stype -> location -> S.t = - fun env _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_continue" - [ - ("args", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Texpr_loop - : _ -> param list -> expr -> expr list -> stype -> location -> S.t = - fun env _visitors_fparams _visitors_fbody _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_param env _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - self#visit_list self#visit_expr env _visitors_fargs - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_loop" - [ - ("params", _visitors_r0); - ("body", _visitors_r1); - ("args", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Texpr_for - : _ -> - (binder * expr) list -> - expr option -> - (var * expr) list -> - expr -> - expr option -> - stype -> - location -> - S.t = - fun env _visitors_fbinders _visitors_fcondition _visitors_fsteps - _visitors_fbody _visitors_ffor_else _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fbinders - in - let _visitors_r1 = - self#visit_option self#visit_expr env _visitors_fcondition - in - let _visitors_r2 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_fsteps - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - self#visit_option self#visit_expr env _visitors_ffor_else - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_for" - [ - ("binders", _visitors_r0); - ("condition", _visitors_r1); - ("steps", _visitors_r2); - ("body", _visitors_r3); - ("for_else", _visitors_r4); - ("ty", _visitors_r5); - ("loc_", _visitors_r6); - ] - - method visit_Texpr_foreach - : _ -> - binder option list -> - stype list -> - expr -> - expr -> - expr option -> - stype -> - location -> - S.t = - fun env _visitors_fbinders _visitors_felem_tys _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (self#visit_option self#visit_binder) - env _visitors_fbinders - in - let _visitors_r1 = - self#visit_list self#visit_stype env _visitors_felem_tys - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - self#visit_option self#visit_expr env _visitors_felse_block - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_foreach" - [ - ("binders", _visitors_r0); - ("elem_tys", _visitors_r1); - ("expr", _visitors_r2); - ("body", _visitors_r3); - ("else_block", _visitors_r4); - ("ty", _visitors_r5); - ("loc_", _visitors_r6); - ] - - method visit_Texpr_return : _ -> expr option -> stype -> location -> S.t = - fun env _visitors_freturn_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_option self#visit_expr env _visitors_freturn_value - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_return" - [ - ("return_value", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Texpr_raise : _ -> expr -> stype -> location -> S.t = - fun env _visitors_ferror_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferror_value in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_raise" - [ - ("error_value", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Texpr_try - : _ -> - expr -> - match_case list -> - bool -> - match_case list option -> - stype -> - stype -> - location -> - location -> - location -> - S.t = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_fty _visitors_ferr_ty - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - self#visit_list self#visit_match_case env _visitors_fcatch - in - let _visitors_r2 = self#visit_bool env _visitors_fcatch_all in - let _visitors_r3 = - self#visit_option - (self#visit_list self#visit_match_case) - env _visitors_ftry_else - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in - let _visitors_r6 = self#visit_location env _visitors_fcatch_loc_ in - let _visitors_r7 = self#visit_location env _visitors_felse_loc_ in - let _visitors_r8 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_try" - [ - ("body", _visitors_r0); - ("catch", _visitors_r1); - ("catch_all", _visitors_r2); - ("try_else", _visitors_r3); - ("ty", _visitors_r4); - ("err_ty", _visitors_r5); - ("catch_loc_", _visitors_r6); - ("else_loc_", _visitors_r7); - ("loc_", _visitors_r8); - ] - - method visit_Texpr_exclamation - : _ -> expr -> stype -> bool -> location -> S.t = - fun env _visitors_fexpr _visitors_fty _visitors_fconvert_to_result - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_bool env _visitors_fconvert_to_result in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_exclamation" - [ - ("expr", _visitors_r0); - ("ty", _visitors_r1); - ("convert_to_result", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Texpr_constraint - : _ -> expr -> typ -> stype -> location -> S.t = - fun env _visitors_fexpr _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_constraint" - [ - ("expr", _visitors_r0); - ("konstraint", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Texpr_pipe - : _ -> expr -> pipe_rhs -> stype -> location -> S.t = - fun env _visitors_flhs _visitors_frhs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_pipe" - [ - ("lhs", _visitors_r0); - ("rhs", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Texpr_interp - : _ -> interp_elem list -> stype -> location -> S.t = - fun env _visitors_felems _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_interp_elem env _visitors_felems - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_interp" - [ - ("elems", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Texpr_guard - : _ -> expr -> expr option -> expr -> stype -> location -> S.t = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - self#visit_option self#visit_expr env _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_guard" - [ - ("cond", _visitors_r0); - ("otherwise", _visitors_r1); - ("body", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] - - method visit_Texpr_guard_let - : _ -> - pat -> - expr -> - pat_binders -> - match_case list option -> - expr -> - stype -> - location -> - S.t = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fotherwise _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = - self#visit_option - (self#visit_list self#visit_match_case) - env _visitors_fotherwise - in - let _visitors_r4 = self#visit_expr env _visitors_fbody in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Texpr_guard_let" - [ - ("pat", _visitors_r0); - ("rhs", _visitors_r1); - ("pat_binders", _visitors_r2); - ("otherwise", _visitors_r3); - ("body", _visitors_r4); - ("ty", _visitors_r5); - ("loc_", _visitors_r6); - ] - - method visit_expr : _ -> expr -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Texpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - ty = _visitors_fty; - kind_ = _visitors_fkind_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fty _visitors_fkind_ _visitors_floc_ - | Texpr_method - { - meth = _visitors_fmeth; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - type_name = _visitors_ftype_name; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ - _visitors_farity_ _visitors_ftype_name _visitors_fprim - _visitors_fty _visitors_floc_ - | Texpr_unresolved_method - { - trait_name = _visitors_ftrait_name; - method_name = _visitors_fmethod_name; - self_type = _visitors_fself_type; - arity_ = _visitors_farity_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_unresolved_method env _visitors_ftrait_name - _visitors_fmethod_name _visitors_fself_type _visitors_farity_ - _visitors_fty _visitors_floc_ - | Texpr_ident - { - id = _visitors_fid; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - kind = _visitors_fkind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ - _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ - | Texpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - ty = _visitors_fty; - is_implicit = _visitors_fis_implicit; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fty _visitors_fis_implicit _visitors_floc_ - | Texpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - is_fixed_array = _visitors_fis_fixed_array; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_array env _visitors_fexprs _visitors_fty - _visitors_fis_fixed_array _visitors_floc_ - | Texpr_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Texpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - ty = _visitors_fty; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fty _visitors_farity_ _visitors_floc_ - | Texpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_fty - _visitors_floc_ - | Texpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Texpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Texpr_letfn - { - binder = _visitors_fbinder; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - is_rec = _visitors_fis_rec; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ - | Texpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fbody _visitors_fty - _visitors_floc_ - | Texpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Texpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Texpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record env _visitors_ftype_name _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - all_fields = _visitors_fall_fields; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_fall_fields _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Texpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_faugmented_by - _visitors_fty _visitors_floc_ - | Texpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - ty = _visitors_fty; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_match env _visitors_fexpr _visitors_fcases - _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ - | Texpr_letmut - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letmut env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_fty _visitors_floc_ - | Texpr_hole - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - kind = _visitors_fkind; - } -> - self#visit_Texpr_hole env _visitors_fty _visitors_floc_ - _visitors_fkind - | Texpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Texpr_unit env _visitors_floc_ - | Texpr_break - { - arg = _visitors_farg; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_break env _visitors_farg _visitors_fty - _visitors_floc_ - | Texpr_continue - { - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_continue env _visitors_fargs _visitors_fty - _visitors_floc_ - | Texpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_fty _visitors_floc_ - | Texpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - steps = _visitors_fsteps; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fsteps _visitors_fbody _visitors_ffor_else - _visitors_fty _visitors_floc_ - | Texpr_foreach - { - binders = _visitors_fbinders; - elem_tys = _visitors_felem_tys; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_foreach env _visitors_fbinders - _visitors_felem_tys _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_fty _visitors_floc_ - | Texpr_return - { - return_value = _visitors_freturn_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_return env _visitors_freturn_value _visitors_fty - _visitors_floc_ - | Texpr_raise - { - error_value = _visitors_ferror_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty - _visitors_floc_ - | Texpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - ty = _visitors_fty; - err_ty = _visitors_ferr_ty; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_fty - _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ - _visitors_floc_ - | Texpr_exclamation - { - expr = _visitors_fexpr; - ty = _visitors_fty; - convert_to_result = _visitors_fconvert_to_result; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty - _visitors_fconvert_to_result _visitors_floc_ - | Texpr_constraint - { - expr = _visitors_fexpr; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constraint env _visitors_fexpr - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Texpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs - _visitors_fty _visitors_floc_ - | Texpr_interp - { - elems = _visitors_felems; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_interp env _visitors_felems _visitors_fty - _visitors_floc_ - | Texpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_fty _visitors_floc_ - | Texpr_guard_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ - - method visit_argument : _ -> argument -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - self#visit_record env - [ ("arg_value", _visitors_r0); ("arg_kind", _visitors_r1) ] - - method visit_Pipe_partial_apply - : _ -> expr -> argument list -> location -> S.t = - fun env _visitors_ffunc _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - self#visit_list self#visit_argument env _visitors_fargs - in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pipe_partial_apply" - [ - ("func", _visitors_r0); - ("args", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Pipe_invalid : _ -> expr -> stype -> location -> S.t = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Pipe_invalid" - [ - ("expr", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_pipe_rhs : _ -> pipe_rhs -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Pipe_partial_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs - _visitors_floc_ - | Pipe_invalid - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty - _visitors_floc_ - - method visit_Interp_lit : _ -> string -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_string env _visitors_c0 in - self#visit_inline_tuple env "Interp_lit" [ _visitors_r0 ] - - method visit_Interp_expr : _ -> expr -> expr -> location -> S.t = - fun env _visitors_fexpr _visitors_fto_string _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_expr env _visitors_fto_string in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Interp_expr" - [ - ("expr", _visitors_r0); - ("to_string", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_interp_elem : _ -> interp_elem -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 - | Interp_expr - { - expr = _visitors_fexpr; - to_string = _visitors_fto_string; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string - _visitors_floc_ - - method visit_Field_def - : _ -> Syntax.label -> expr -> bool -> bool -> int -> S.t = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_mut - _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = self#visit_bool env _visitors_fis_mut in - let _visitors_r3 = self#visit_bool env _visitors_fis_pun in - let _visitors_r4 = self#visit_int env _visitors_fpos in - self#visit_inline_record env "Field_def" - [ - ("label", _visitors_r0); - ("expr", _visitors_r1); - ("is_mut", _visitors_r2); - ("is_pun", _visitors_r3); - ("pos", _visitors_r4); - ] - - method visit_field_def : _ -> field_def -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_mut = _visitors_fis_mut; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_mut _visitors_fis_pun _visitors_fpos - - method visit_Field_pat : _ -> Syntax.label -> pat -> bool -> int -> S.t = - fun env _visitors_flabel _visitors_fpat _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pat env _visitors_fpat in - let _visitors_r2 = self#visit_bool env _visitors_fis_pun in - let _visitors_r3 = self#visit_int env _visitors_fpos in - self#visit_inline_record env "Field_pat" - [ - ("label", _visitors_r0); - ("pat", _visitors_r1); - ("is_pun", _visitors_r2); - ("pos", _visitors_r3); - ] - - method visit_field_pat : _ -> field_pat -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pat = _visitors_fpat; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpat - _visitors_fis_pun _visitors_fpos - - method visit_constr_pat_args : _ -> constr_pat_args -> S.t = - fun env -> self#visit_list self#visit_constr_pat_arg env - - method visit_Constr_pat_arg - : _ -> pat -> Syntax.argument_kind -> int -> S.t = - fun env _visitors_fpat _visitors_fkind _visitors_fpos -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - let _visitors_r2 = self#visit_int env _visitors_fpos in - self#visit_inline_record env "Constr_pat_arg" - [ - ("pat", _visitors_r0); - ("kind", _visitors_r1); - ("pos", _visitors_r2); - ] - - method visit_constr_pat_arg : _ -> constr_pat_arg -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg - { - pat = _visitors_fpat; - kind = _visitors_fkind; - pos = _visitors_fpos; - } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - _visitors_fpos - - method visit_Param - : _ -> binder -> typ option -> stype -> param_kind -> S.t = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fty - _visitors_fkind -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_fkonstraint - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_param_kind env _visitors_fkind in - self#visit_inline_record env "Param" - [ - ("binder", _visitors_r0); - ("konstraint", _visitors_r1); - ("ty", _visitors_r2); - ("kind", _visitors_r3); - ] - - method visit_param : _ -> param -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Param - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - kind = _visitors_fkind; - } -> - self#visit_Param env _visitors_fbinder _visitors_fkonstraint - _visitors_fty _visitors_fkind - - method visit_Positional : _ -> S.t = - fun env -> self#visit_inline_tuple env "Positional" [] - - method visit_Labelled : _ -> S.t = - fun env -> self#visit_inline_tuple env "Labelled" [] - - method visit_Optional : _ -> expr -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - self#visit_inline_tuple env "Optional" [ _visitors_r0 ] - - method visit_Autofill : _ -> S.t = - fun env -> self#visit_inline_tuple env "Autofill" [] - - method visit_Question_optional : _ -> S.t = - fun env -> self#visit_inline_tuple env "Question_optional" [] - - method visit_param_kind : _ -> param_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 - | Autofill -> self#visit_Autofill env - | Question_optional -> self#visit_Question_optional env + method visit_param_kind : _ -> param_kind -> S.t = + fun env -> + fun _visitors_this -> + match _visitors_this with + | Positional -> self#visit_Positional env + | Labelled -> self#visit_Labelled env + | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 + | Autofill -> self#visit_Autofill env + | Question_optional -> self#visit_Question_optional env method visit_params : _ -> params -> S.t = fun env -> self#visit_list self#visit_param env method visit_fn : _ -> fn -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_params env _visitors_this.params in - let _visitors_r1 = - self#visit_location env _visitors_this.params_loc_ - in - let _visitors_r2 = self#visit_expr env _visitors_this.body in - let _visitors_r3 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_this.ret_constraint - in - let _visitors_r4 = self#visit_stype env _visitors_this.ty in - let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in - self#visit_record env - [ - ("params", _visitors_r0); - ("params_loc_", _visitors_r1); - ("body", _visitors_r2); - ("ret_constraint", _visitors_r3); - ("ty", _visitors_r4); - ("kind_", _visitors_r5); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_params env _visitors_this.params in + let _visitors_r1 = + self#visit_location env _visitors_this.params_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + let _visitors_r3 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = self#visit_error_typ env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_this.ret_constraint + in + let _visitors_r4 = self#visit_stype env _visitors_this.ty in + let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in + self#visit_record env + [ + ("params", _visitors_r0); + ("params_loc_", _visitors_r1); + ("body", _visitors_r2); + ("ret_constraint", _visitors_r3); + ("ty", _visitors_r4); + ("kind_", _visitors_r5); + ] method visit_match_case : _ -> match_case -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_pat env _visitors_this.pat in - let _visitors_r1 = self#visit_expr env _visitors_this.action in - let _visitors_r2 = - self#visit_pat_binders env _visitors_this.pat_binders - in - self#visit_record env - [ - ("pat", _visitors_r0); - ("action", _visitors_r1); - ("pat_binders", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pat env _visitors_this.pat in + let _visitors_r1 = self#visit_expr env _visitors_this.action in + let _visitors_r2 = + self#visit_option self#visit_expr env _visitors_this.guard + in + let _visitors_r3 = + self#visit_pat_binders env _visitors_this.pat_binders + in + self#visit_record env + [ + ("pat", _visitors_r0); + ("action", _visitors_r1); + ("guard", _visitors_r2); + ("pat_binders", _visitors_r3); + ] method visit_Error_typ : _ -> typ -> S.t = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - self#visit_inline_record env "Error_typ" [ ("ty", _visitors_r0) ] + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + self#visit_inline_record env "Error_typ" [ ("ty", _visitors_r0) ] method visit_Default_error_typ : _ -> location -> S.t = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Default_error_typ" - [ ("loc_", _visitors_r0) ] + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Default_error_typ" + [ ("loc_", _visitors_r0) ] method visit_No_error_typ : _ -> S.t = fun env -> self#visit_inline_tuple env "No_error_typ" [] method visit_error_typ : _ -> error_typ -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Tany : _ -> stype -> location -> S.t = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tany" - [ ("ty", _visitors_r0); ("loc_", _visitors_r1) ] - - method visit_Tarrow - : _ -> typ list -> typ -> error_typ -> stype -> location -> S.t = - fun env _visitors_fparams _visitors_freturn _visitors_ferr_ty - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_typ env _visitors_fparams - in - let _visitors_r1 = self#visit_typ env _visitors_freturn in - let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tarrow" - [ - ("params", _visitors_r0); - ("return", _visitors_r1); - ("err_ty", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tany" + [ ("ty", _visitors_r0); ("loc_", _visitors_r1) ] + + method visit_Tarrow : + _ -> typ list -> typ -> error_typ -> stype -> location -> S.t = + fun env -> + fun _visitors_fparams -> + fun _visitors_freturn -> + fun _visitors_ferr_ty -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_typ env _visitors_fparams + in + let _visitors_r1 = self#visit_typ env _visitors_freturn in + let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tarrow" + [ + ("params", _visitors_r0); + ("return", _visitors_r1); + ("err_ty", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_T_tuple : _ -> typ list -> stype -> location -> S.t = - fun env _visitors_fparams _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_typ env _visitors_fparams - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "T_tuple" - [ - ("params", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Tname - : _ -> constrid_loc -> typ list -> stype -> bool -> location -> S.t = - fun env _visitors_fconstr _visitors_fparams _visitors_fty - _visitors_fis_alias_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constrid_loc env _visitors_fconstr in - let _visitors_r1 = - self#visit_list self#visit_typ env _visitors_fparams - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_bool env _visitors_fis_alias_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tname" - [ - ("constr", _visitors_r0); - ("params", _visitors_r1); - ("ty", _visitors_r2); - ("is_alias_", _visitors_r3); - ("loc_", _visitors_r4); - ] + fun env -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_typ env _visitors_fparams + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "T_tuple" + [ + ("params", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Tname : + _ -> constrid_loc -> typ list -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = + self#visit_list self#visit_typ env _visitors_fparams + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_bool env _visitors_fis_alias_ in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tname" + [ + ("constr", _visitors_r0); + ("params", _visitors_r1); + ("ty", _visitors_r2); + ("is_alias_", _visitors_r3); + ("loc_", _visitors_r4); + ] + + method visit_Tobject : + _ -> constrid_loc -> stype -> bool -> location -> S.t = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_bool env _visitors_fis_alias_ in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tobject" + [ + ("constr", _visitors_r0); + ("ty", _visitors_r1); + ("is_alias_", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_typ : _ -> typ -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tany env _visitors_fty _visitors_floc_ - | Tarrow - { - params = _visitors_fparams; - return = _visitors_freturn; - err_ty = _visitors_ferr_ty; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tarrow env _visitors_fparams _visitors_freturn - _visitors_ferr_ty _visitors_fty _visitors_floc_ - | T_tuple - { - params = _visitors_fparams; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_T_tuple env _visitors_fparams _visitors_fty - _visitors_floc_ - | Tname - { - constr = _visitors_fconstr; - params = _visitors_fparams; - ty = _visitors_fty; - is_alias_ = _visitors_fis_alias_; - loc_ = _visitors_floc_; - } -> - self#visit_Tname env _visitors_fconstr _visitors_fparams - _visitors_fty _visitors_fis_alias_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tany env _visitors_fty _visitors_floc_ + | Tarrow + { + params = _visitors_fparams; + return = _visitors_freturn; + err_ty = _visitors_ferr_ty; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tarrow env _visitors_fparams _visitors_freturn + _visitors_ferr_ty _visitors_fty _visitors_floc_ + | T_tuple + { + params = _visitors_fparams; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_T_tuple env _visitors_fparams _visitors_fty + _visitors_floc_ + | Tname + { + constr = _visitors_fconstr; + params = _visitors_fparams; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tname env _visitors_fconstr _visitors_fparams + _visitors_fty _visitors_fis_alias_ _visitors_floc_ + | Tobject + { + constr = _visitors_fconstr; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tobject env _visitors_fconstr _visitors_fty + _visitors_fis_alias_ _visitors_floc_ method visit_Tpat_alias : _ -> pat -> binder -> stype -> location -> S.t = - fun env _visitors_fpat _visitors_falias _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_alias" - [ - ("pat", _visitors_r0); - ("alias", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_alias" + [ + ("pat", _visitors_r0); + ("alias", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Tpat_any : _ -> stype -> location -> S.t = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_any" - [ ("ty", _visitors_r0); ("loc_", _visitors_r1) ] + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_any" + [ ("ty", _visitors_r0); ("loc_", _visitors_r1) ] method visit_Tpat_array : _ -> array_pattern -> stype -> location -> S.t = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_array" - [ - ("pats", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Tpat_constant - : _ -> constant -> stype -> var option -> location -> S.t = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constant env _visitors_fc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - self#visit_option self#visit_var env _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_constant" - [ - ("c", _visitors_r0); - ("ty", _visitors_r1); - ("name_", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Tpat_constr - : _ -> - Syntax.constructor -> - constr_pat_args -> - constr_tag -> - stype -> - bool -> - location -> - S.t = - fun env _visitors_fconstr _visitors_fargs _visitors_ftag _visitors_fty - _visitors_fused_error_subtyping _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_pat_args env _visitors_fargs in - let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = - self#visit_bool env _visitors_fused_error_subtyping - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_constr" - [ - ("constr", _visitors_r0); - ("args", _visitors_r1); - ("tag", _visitors_r2); - ("ty", _visitors_r3); - ("used_error_subtyping", _visitors_r4); - ("loc_", _visitors_r5); - ] + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_array" + [ + ("pats", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Tpat_constant : + _ -> constant -> stype -> var option -> location -> S.t = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_constant env _visitors_fc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + self#visit_option self#visit_var env _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_constant" + [ + ("c", _visitors_r0); + ("ty", _visitors_r1); + ("name_", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Tpat_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_pat_args -> + constr_tag -> + stype -> + bool -> + fn_arity -> + stype list -> + location -> + S.t = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_fused_error_subtyping -> + fun _visitors_farity_ -> + fun _visitors_fall_args_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_option self#visit_type_name env + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = + self#visit_constr_pat_args env _visitors_fargs + in + let _visitors_r3 = + self#visit_constr_tag env _visitors_ftag + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = + self#visit_bool env _visitors_fused_error_subtyping + in + let _visitors_r6 = + self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r7 = + self#visit_list self#visit_stype env _visitors_fall_args_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_constr" + [ + ("type_name", _visitors_r0); + ("constr", _visitors_r1); + ("args", _visitors_r2); + ("tag", _visitors_r3); + ("ty", _visitors_r4); + ("used_error_subtyping", _visitors_r5); + ("arity_", _visitors_r6); + ("all_args_", _visitors_r7); + ("loc_", _visitors_r8); + ] method visit_Tpat_or : _ -> pat -> pat -> stype -> location -> S.t = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat1 in - let _visitors_r1 = self#visit_pat env _visitors_fpat2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_or" - [ - ("pat1", _visitors_r0); - ("pat2", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat1 in + let _visitors_r1 = self#visit_pat env _visitors_fpat2 in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_or" + [ + ("pat1", _visitors_r0); + ("pat2", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Tpat_tuple : _ -> pat list -> stype -> location -> S.t = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_pat env _visitors_fpats - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_tuple" - [ - ("pats", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_pat env _visitors_fpats + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_tuple" + [ + ("pats", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] method visit_Tpat_var : _ -> binder -> stype -> location -> S.t = - fun env _visitors_fbinder _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_var" - [ - ("binder", _visitors_r0); - ("ty", _visitors_r1); - ("loc_", _visitors_r2); - ] - - method visit_Tpat_record - : _ -> field_pat list -> bool -> stype -> location -> S.t = - fun env _visitors_ffields _visitors_fis_closed _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list self#visit_field_pat env _visitors_ffields - in - let _visitors_r1 = self#visit_bool env _visitors_fis_closed in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_record" - [ - ("fields", _visitors_r0); - ("is_closed", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_var" + [ + ("binder", _visitors_r0); + ("ty", _visitors_r1); + ("loc_", _visitors_r2); + ] + + method visit_Tpat_record : + _ -> field_pat list -> bool -> stype -> location -> S.t = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list self#visit_field_pat env _visitors_ffields + in + let _visitors_r1 = self#visit_bool env _visitors_fis_closed in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_record" + [ + ("fields", _visitors_r0); + ("is_closed", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] method visit_Tpat_constraint : _ -> pat -> typ -> stype -> location -> S.t = - fun env _visitors_fpat _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_constraint" - [ - ("pat", _visitors_r0); - ("konstraint", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Tpat_map - : _ -> - (constant * pat) list -> - ident * stype * stype array -> - stype -> - location -> - S.t = - fun env _visitors_felems _visitors_fop_get_info_ _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_constant env _visitors_c0 in - let _visitors_r1 = self#visit_pat env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_felems - in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_ident env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - let _visitors_r2 = - self#visit_array self#visit_stype env _visitors_c2 + fun env -> + fun _visitors_fpat -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_constraint" + [ + ("pat", _visitors_r0); + ("konstraint", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Tpat_map : + _ -> + (constant * pat) list -> + ident * stype * stype array -> + stype -> + location -> + S.t = + fun env -> + fun _visitors_felems -> + fun _visitors_fop_get_info_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_constant env _visitors_c0 in + let _visitors_r1 = self#visit_pat env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_felems in - self#visit_tuple env [ _visitors_r0; _visitors_r1; _visitors_r2 ]) - _visitors_fop_get_info_ - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_map" - [ - ("elems", _visitors_r0); - ("op_get_info_", _visitors_r1); - ("ty", _visitors_r2); - ("loc_", _visitors_r3); - ] - - method visit_Tpat_range - : _ -> pat -> pat -> bool -> stype -> location -> S.t = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_flhs in - let _visitors_r1 = self#visit_pat env _visitors_frhs in - let _visitors_r2 = self#visit_bool env _visitors_finclusive in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - self#visit_inline_record env "Tpat_range" - [ - ("lhs", _visitors_r0); - ("rhs", _visitors_r1); - ("inclusive", _visitors_r2); - ("ty", _visitors_r3); - ("loc_", _visitors_r4); - ] + let _visitors_r1 = + (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = self#visit_ident env _visitors_c0 in + let _visitors_r1 = self#visit_stype env _visitors_c1 in + let _visitors_r2 = + self#visit_array self#visit_stype env _visitors_c2 + in + self#visit_tuple env + [ _visitors_r0; _visitors_r1; _visitors_r2 ]) + _visitors_fop_get_info_ + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_map" + [ + ("elems", _visitors_r0); + ("op_get_info_", _visitors_r1); + ("ty", _visitors_r2); + ("loc_", _visitors_r3); + ] + + method visit_Tpat_range : + _ -> pat -> pat -> bool -> stype -> location -> S.t = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_flhs in + let _visitors_r1 = self#visit_pat env _visitors_frhs in + let _visitors_r2 = self#visit_bool env _visitors_finclusive in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + self#visit_inline_record env "Tpat_range" + [ + ("lhs", _visitors_r0); + ("rhs", _visitors_r1); + ("inclusive", _visitors_r2); + ("ty", _visitors_r3); + ("loc_", _visitors_r4); + ] method visit_pat : _ -> pat -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Tpat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_alias env _visitors_fpat _visitors_falias - _visitors_fty _visitors_floc_ - | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tpat_any env _visitors_fty _visitors_floc_ - | Tpat_array - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_array env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Tpat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - tag = _visitors_ftag; - ty = _visitors_fty; - used_error_subtyping = _visitors_fused_error_subtyping; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constr env _visitors_fconstr _visitors_fargs - _visitors_ftag _visitors_fty _visitors_fused_error_subtyping - _visitors_floc_ - | Tpat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_fty _visitors_floc_ - | Tpat_tuple - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_tuple env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_var - { - binder = _visitors_fbinder; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_var env _visitors_fbinder _visitors_fty - _visitors_floc_ - | Tpat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed - _visitors_fty _visitors_floc_ - | Tpat_constraint - { - pat = _visitors_fpat; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constraint env _visitors_fpat - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Tpat_map - { - elems = _visitors_felems; - op_get_info_ = _visitors_fop_get_info_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ - _visitors_fty _visitors_floc_ - | Tpat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tpat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_alias env _visitors_fpat _visitors_falias + _visitors_fty _visitors_floc_ + | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tpat_any env _visitors_fty _visitors_floc_ + | Tpat_array + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_array env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Tpat_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + args = _visitors_fargs; + tag = _visitors_ftag; + ty = _visitors_fty; + used_error_subtyping = _visitors_fused_error_subtyping; + arity_ = _visitors_farity_; + all_args_ = _visitors_fall_args_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constr env _visitors_ftype_name _visitors_fconstr + _visitors_fargs _visitors_ftag _visitors_fty + _visitors_fused_error_subtyping _visitors_farity_ + _visitors_fall_args_ _visitors_floc_ + | Tpat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_fty _visitors_floc_ + | Tpat_tuple + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_tuple env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_var + { + binder = _visitors_fbinder; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_var env _visitors_fbinder _visitors_fty + _visitors_floc_ + | Tpat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed + _visitors_fty _visitors_floc_ + | Tpat_constraint + { + pat = _visitors_fpat; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constraint env _visitors_fpat + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Tpat_map + { + elems = _visitors_felems; + op_get_info_ = _visitors_fop_get_info_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ + _visitors_fty _visitors_floc_ + | Tpat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_fty _visitors_floc_ method visit_Closed : _ -> pat list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_list self#visit_pat env _visitors_c0 in - self#visit_inline_tuple env "Closed" [ _visitors_r0 ] - - method visit_Open - : _ -> pat list -> pat list -> (binder * stype) option -> S.t = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = self#visit_list self#visit_pat env _visitors_c0 in - let _visitors_r1 = self#visit_list self#visit_pat env _visitors_c1 in - let _visitors_r2 = - self#visit_option - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_c2 - in - self#visit_inline_tuple env "Open" - [ _visitors_r0; _visitors_r1; _visitors_r2 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_list self#visit_pat env _visitors_c0 in + self#visit_inline_tuple env "Closed" [ _visitors_r0 ] + + method visit_Open : + _ -> pat list -> pat list -> (binder * stype) option -> S.t = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + self#visit_list self#visit_pat env _visitors_c0 + in + let _visitors_r1 = + self#visit_list self#visit_pat env _visitors_c1 + in + let _visitors_r2 = + self#visit_option + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_stype env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_c2 + in + self#visit_inline_tuple env "Open" + [ _visitors_r0; _visitors_r1; _visitors_r2 ] method visit_array_pattern : _ -> array_pattern -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 method visit_fun_decl : _ -> fun_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_fun_decl_kind env _visitors_this.kind in - let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = self#visit_bool env _visitors_this.is_pub in - let _visitors_r4 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in - self#visit_record env - [ - ("kind", _visitors_r0); - ("fn_binder", _visitors_r1); - ("fn", _visitors_r2); - ("is_pub", _visitors_r3); - ("ty_params_", _visitors_r4); - ("doc_", _visitors_r5); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_fun_decl_kind env _visitors_this.kind + in + let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = self#visit_bool env _visitors_this.is_pub in + let _visitors_r4 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r5 = + self#visit_list self#visit_type_name env + _visitors_this.constraint_names + in + let _visitors_r6 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r7 = self#visit_attributes env _visitors_this.attrs in + self#visit_record env + [ + ("kind", _visitors_r0); + ("fn_binder", _visitors_r1); + ("fn", _visitors_r2); + ("is_pub", _visitors_r3); + ("ty_params_", _visitors_r4); + ("constraint_names", _visitors_r5); + ("doc_", _visitors_r6); + ("attrs", _visitors_r7); + ] method visit_Fun_kind_regular : _ -> S.t = fun env -> self#visit_inline_tuple env "Fun_kind_regular" [] method visit_Fun_kind_method : _ -> type_name option -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_option self#visit_type_name env _visitors_c0 - in - self#visit_inline_tuple env "Fun_kind_method" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_option self#visit_type_name env _visitors_c0 + in + self#visit_inline_tuple env "Fun_kind_method" [ _visitors_r0 ] method visit_Fun_kind_default_impl : _ -> type_name -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_name env _visitors_c0 in - self#visit_inline_tuple env "Fun_kind_default_impl" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_name env _visitors_c0 in + self#visit_inline_tuple env "Fun_kind_default_impl" [ _visitors_r0 ] method visit_Fun_kind_impl : _ -> typ -> type_name -> S.t = - fun env _visitors_fself_ty _visitors_ftrait -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - self#visit_inline_record env "Fun_kind_impl" - [ ("self_ty", _visitors_r0); ("trait", _visitors_r1) ] + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + self#visit_inline_record env "Fun_kind_impl" + [ ("self_ty", _visitors_r0); ("trait", _visitors_r1) ] method visit_fun_decl_kind : _ -> fun_decl_kind -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Fun_kind_regular -> self#visit_Fun_kind_regular env - | Fun_kind_method _visitors_c0 -> - self#visit_Fun_kind_method env _visitors_c0 - | Fun_kind_default_impl _visitors_c0 -> - self#visit_Fun_kind_default_impl env _visitors_c0 - | Fun_kind_impl - { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> - self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait - - method visit_Timpl_expr - : _ -> expr -> bool -> _ -> absolute_loc -> bool -> S.t = - fun env _visitors_fexpr _visitors_fis_main _visitors_fexpr_id - _visitors_floc_ _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_bool env _visitors_fis_main in - let _visitors_r2 = self#visit_expr_id env _visitors_fexpr_id in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r4 = self#visit_bool env _visitors_fis_generated_ in - self#visit_inline_record env "Timpl_expr" - [ - ("expr", _visitors_r0); - ("is_main", _visitors_r1); - ("expr_id", _visitors_r2); - ("loc_", _visitors_r3); - ("is_generated_", _visitors_r4); - ] - - method visit_Timpl_fun_decl - : _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> S.t = - fun env _visitors_ffun_decl _visitors_farity_ _visitors_floc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r3 = self#visit_bool env _visitors_fis_generated_ in - self#visit_inline_record env "Timpl_fun_decl" - [ - ("fun_decl", _visitors_r0); - ("arity_", _visitors_r1); - ("loc_", _visitors_r2); - ("is_generated_", _visitors_r3); - ] - - method visit_Timpl_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - absolute_loc -> - docstring -> - bool -> - S.t = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fis_pub _visitors_floc_ _visitors_fdoc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - self#visit_option self#visit_typ env _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_bool env _visitors_fis_pub in - let _visitors_r4 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in - let _visitors_r6 = self#visit_bool env _visitors_fis_generated_ in - self#visit_inline_record env "Timpl_letdef" - [ - ("binder", _visitors_r0); - ("konstraint", _visitors_r1); - ("expr", _visitors_r2); - ("is_pub", _visitors_r3); - ("loc_", _visitors_r4); - ("doc_", _visitors_r5); - ("is_generated_", _visitors_r6); - ] + fun env -> + fun _visitors_this -> + match _visitors_this with + | Fun_kind_regular -> self#visit_Fun_kind_regular env + | Fun_kind_method _visitors_c0 -> + self#visit_Fun_kind_method env _visitors_c0 + | Fun_kind_default_impl _visitors_c0 -> + self#visit_Fun_kind_default_impl env _visitors_c0 + | Fun_kind_impl + { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> + self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait + + method visit_Timpl_expr : + _ -> expr -> bool -> _ -> absolute_loc -> bool -> S.t = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_fexpr_id -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_bool env _visitors_fis_main in + let _visitors_r2 = self#visit_expr_id env _visitors_fexpr_id in + let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r4 = + self#visit_bool env _visitors_fis_generated_ + in + self#visit_inline_record env "Timpl_expr" + [ + ("expr", _visitors_r0); + ("is_main", _visitors_r1); + ("expr_id", _visitors_r2); + ("loc_", _visitors_r3); + ("is_generated_", _visitors_r4); + ] + + method visit_Timpl_fun_decl : + _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> S.t = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r3 = self#visit_bool env _visitors_fis_generated_ in + self#visit_inline_record env "Timpl_fun_decl" + [ + ("fun_decl", _visitors_r0); + ("arity_", _visitors_r1); + ("loc_", _visitors_r2); + ("is_generated_", _visitors_r3); + ] + + method visit_Timpl_letdef : + _ -> + binder -> + typ option -> + expr -> + bool -> + absolute_loc -> + docstring -> + attributes -> + bool -> + S.t = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + fun _visitors_fdoc_ -> + fun _visitors_fattrs -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + self#visit_option self#visit_typ env _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_bool env _visitors_fis_pub in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + let _visitors_r6 = + self#visit_attributes env _visitors_fattrs + in + let _visitors_r7 = + self#visit_bool env _visitors_fis_generated_ + in + self#visit_inline_record env "Timpl_letdef" + [ + ("binder", _visitors_r0); + ("konstraint", _visitors_r1); + ("expr", _visitors_r2); + ("is_pub", _visitors_r3); + ("loc_", _visitors_r4); + ("doc_", _visitors_r5); + ("attrs", _visitors_r6); + ("is_generated_", _visitors_r7); + ] method visit_Timpl_stub_decl : _ -> stub_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in - self#visit_inline_tuple env "Timpl_stub_decl" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in + self#visit_inline_tuple env "Timpl_stub_decl" [ _visitors_r0 ] method visit_impl : _ -> impl -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Timpl_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - expr_id = _visitors_fexpr_id; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main - _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ - | Timpl_fun_decl - { - fun_decl = _visitors_ffun_decl; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_fun_decl env _visitors_ffun_decl - _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ - | Timpl_letdef - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_letdef env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub - _visitors_floc_ _visitors_fdoc_ _visitors_fis_generated_ - | Timpl_stub_decl _visitors_c0 -> - self#visit_Timpl_stub_decl env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Timpl_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + expr_id = _visitors_fexpr_id; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main + _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ + | Timpl_fun_decl + { + fun_decl = _visitors_ffun_decl; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_fun_decl env _visitors_ffun_decl + _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ + | Timpl_letdef + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + doc_ = _visitors_fdoc_; + attrs = _visitors_fattrs; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_letdef env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub + _visitors_floc_ _visitors_fdoc_ _visitors_fattrs + _visitors_fis_generated_ + | Timpl_stub_decl _visitors_c0 -> + self#visit_Timpl_stub_decl env _visitors_c0 method visit_impls : _ -> impls -> S.t = fun env -> self#visit_list self#visit_impl env method visit_type_decl : _ -> type_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.td_binder - in - let _visitors_r1 = self#visit_tvar_env env _visitors_this.td_params in - let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in - let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in - let _visitors_r4 = - self#visit_absolute_loc env _visitors_this.td_loc_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in - let _visitors_r6 = - self#visit_list self#visit_constrid_loc env - _visitors_this.td_deriving_ - in - self#visit_record env - [ - ("td_binder", _visitors_r0); - ("td_params", _visitors_r1); - ("td_desc", _visitors_r2); - ("td_vis", _visitors_r3); - ("td_loc_", _visitors_r4); - ("td_doc_", _visitors_r5); - ("td_deriving_", _visitors_r6); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.td_binder + in + let _visitors_r1 = + self#visit_tvar_env env _visitors_this.td_params + in + let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in + let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.td_loc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in + let _visitors_r6 = + self#visit_list self#visit_type_name env + _visitors_this.td_deriving_ + in + self#visit_record env + [ + ("td_binder", _visitors_r0); + ("td_params", _visitors_r1); + ("td_desc", _visitors_r2); + ("td_vis", _visitors_r3); + ("td_loc_", _visitors_r4); + ("td_doc_", _visitors_r5); + ("td_deriving_", _visitors_r6); + ] method visit_No_payload : _ -> S.t = fun env -> self#visit_inline_tuple env "No_payload" [] method visit_Single_payload : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Single_payload" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Single_payload" [ _visitors_r0 ] method visit_Enum_payload : _ -> constr_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_constr_decl env _visitors_c0 - in - self#visit_inline_tuple env "Enum_payload" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_constr_decl env _visitors_c0 + in + self#visit_inline_tuple env "Enum_payload" [ _visitors_r0 ] method visit_exception_decl : _ -> exception_decl -> S.t = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Td_abstract : _ -> S.t = fun env -> self#visit_inline_tuple env "Td_abstract" [] method visit_Td_error : _ -> exception_decl -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - self#visit_inline_tuple env "Td_error" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + self#visit_inline_tuple env "Td_error" [ _visitors_r0 ] method visit_Td_newtype : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Td_newtype" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Td_newtype" [ _visitors_r0 ] method visit_Td_variant : _ -> constr_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_constr_decl env _visitors_c0 - in - self#visit_inline_tuple env "Td_variant" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_constr_decl env _visitors_c0 + in + self#visit_inline_tuple env "Td_variant" [ _visitors_r0 ] method visit_Td_record : _ -> field_decl list -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = - self#visit_list self#visit_field_decl env _visitors_c0 - in - self#visit_inline_tuple env "Td_record" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + self#visit_list self#visit_field_decl env _visitors_c0 + in + self#visit_inline_tuple env "Td_record" [ _visitors_r0 ] method visit_Td_alias : _ -> typ -> S.t = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - self#visit_inline_tuple env "Td_alias" [ _visitors_r0 ] + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + self#visit_inline_tuple env "Td_alias" [ _visitors_r0 ] method visit_type_desc : _ -> type_desc -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Td_abstract -> self#visit_Td_abstract env - | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 - | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 - | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 - | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 - | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Td_abstract -> self#visit_Td_abstract env + | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 + | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 + | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 + | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 + | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 method visit_constr_decl_arg : _ -> constr_decl_arg -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in - let _visitors_r1 = self#visit_bool env _visitors_this.carg_mut in - let _visitors_r2 = - self#visit_option self#visit_label env _visitors_this.carg_label - in - self#visit_record env - [ - ("carg_typ", _visitors_r0); - ("carg_mut", _visitors_r1); - ("carg_label", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in + let _visitors_r1 = self#visit_bool env _visitors_this.carg_mut in + let _visitors_r2 = + self#visit_option self#visit_label env _visitors_this.carg_label + in + self#visit_record env + [ + ("carg_typ", _visitors_r0); + ("carg_mut", _visitors_r1); + ("carg_label", _visitors_r2); + ] method visit_constr_decl : _ -> constr_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.constr_name in - let _visitors_r1 = - self#visit_constr_tag env _visitors_this.constr_tag - in - let _visitors_r2 = - self#visit_list self#visit_constr_decl_arg env - _visitors_this.constr_args - in - let _visitors_r3 = - self#visit_fn_arity env _visitors_this.constr_arity_ - in - let _visitors_r4 = - self#visit_location env _visitors_this.constr_loc_ - in - self#visit_record env - [ - ("constr_name", _visitors_r0); - ("constr_tag", _visitors_r1); - ("constr_args", _visitors_r2); - ("constr_arity_", _visitors_r3); - ("constr_loc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.constr_name in + let _visitors_r1 = + self#visit_constr_tag env _visitors_this.constr_tag + in + let _visitors_r2 = + self#visit_list self#visit_constr_decl_arg env + _visitors_this.constr_args + in + let _visitors_r3 = + self#visit_fn_arity env _visitors_this.constr_arity_ + in + let _visitors_r4 = + self#visit_location env _visitors_this.constr_loc_ + in + self#visit_record env + [ + ("constr_name", _visitors_r0); + ("constr_tag", _visitors_r1); + ("constr_args", _visitors_r2); + ("constr_arity_", _visitors_r3); + ("constr_loc_", _visitors_r4); + ] method visit_field_decl : _ -> field_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.field_label in - let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in - let _visitors_r2 = self#visit_bool env _visitors_this.field_mut in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - self#visit_location env _visitors_this.field_loc_ - in - self#visit_record env - [ - ("field_label", _visitors_r0); - ("field_typ", _visitors_r1); - ("field_mut", _visitors_r2); - ("field_vis", _visitors_r3); - ("field_loc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.field_label in + let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in + let _visitors_r2 = self#visit_bool env _visitors_this.field_mut in + let _visitors_r3 = + self#visit_type_component_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + self#visit_location env _visitors_this.field_loc_ + in + self#visit_record env + [ + ("field_label", _visitors_r0); + ("field_typ", _visitors_r1); + ("field_mut", _visitors_r2); + ("field_vis", _visitors_r3); + ("field_loc_", _visitors_r4); + ] method visit_trait_decl : _ -> trait_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.trait_name - in - let _visitors_r1 = - self#visit_list self#visit_method_decl env - _visitors_this.trait_methods - in - let _visitors_r2 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.trait_loc_ - in - let _visitors_r4 = - self#visit_docstring env _visitors_this.trait_doc_ - in - self#visit_record env - [ - ("trait_name", _visitors_r0); - ("trait_methods", _visitors_r1); - ("trait_vis", _visitors_r2); - ("trait_loc_", _visitors_r3); - ("trait_doc_", _visitors_r4); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_name + in + let _visitors_r1 = + self#visit_list self#visit_type_name env + _visitors_this.trait_supers + in + let _visitors_r2 = + self#visit_list self#visit_method_decl env + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.trait_loc_ + in + let _visitors_r5 = + self#visit_docstring env _visitors_this.trait_doc_ + in + let _visitors_r6 = + self#visit_attributes env _visitors_this.trait_attrs + in + self#visit_record env + [ + ("trait_name", _visitors_r0); + ("trait_supers", _visitors_r1); + ("trait_methods", _visitors_r2); + ("trait_vis", _visitors_r3); + ("trait_loc_", _visitors_r4); + ("trait_doc_", _visitors_r5); + ("trait_attrs", _visitors_r6); + ] + + method visit_trait_alias_decl : _ -> trait_alias_decl -> S.t = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_alias_name + in + let _visitors_r1 = + self#visit_type_name env _visitors_this.trait_alias_target + in + let _visitors_r2 = + self#visit_bool env _visitors_this.trait_alias_is_pub + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.trait_alias_loc_ + in + let _visitors_r4 = + self#visit_docstring env _visitors_this.trait_alias_doc_ + in + self#visit_record env + [ + ("trait_alias_name", _visitors_r0); + ("trait_alias_target", _visitors_r1); + ("trait_alias_is_pub", _visitors_r2); + ("trait_alias_loc_", _visitors_r3); + ("trait_alias_doc_", _visitors_r4); + ] method visit_method_decl : _ -> method_decl -> S.t = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_syntax_binder env _visitors_this.method_name - in - let _visitors_r1 = - self#visit_list - (fun env (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - self#visit_option self#visit_label env _visitors_c0 - in - let _visitors_r1 = self#visit_typ env _visitors_c1 in - self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) - env _visitors_this.method_params - in - let _visitors_r2 = - self#visit_option self#visit_typ env _visitors_this.method_ret - in - let _visitors_r3 = - self#visit_option self#visit_typ env _visitors_this.method_err - in - let _visitors_r4 = - self#visit_location env _visitors_this.method_loc_ - in - self#visit_record env - [ - ("method_name", _visitors_r0); - ("method_params", _visitors_r1); - ("method_ret", _visitors_r2); - ("method_err", _visitors_r3); - ("method_loc_", _visitors_r4); - ] - - method visit_Output - : _ -> impls -> type_decl list -> trait_decl list -> S.t = - fun env _visitors_fvalue_defs _visitors_ftype_defs _visitors_ftrait_defs -> - let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in - let _visitors_r1 = - self#visit_list self#visit_type_decl env _visitors_ftype_defs - in - let _visitors_r2 = - self#visit_list self#visit_trait_decl env _visitors_ftrait_defs - in - self#visit_inline_record env "Output" - [ - ("value_defs", _visitors_r0); - ("type_defs", _visitors_r1); - ("trait_defs", _visitors_r2); - ] + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_syntax_binder env _visitors_this.method_name + in + let _visitors_r1 = + self#visit_list + (fun env -> + fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_option self#visit_label env _visitors_c0 + in + let _visitors_r1 = self#visit_typ env _visitors_c1 in + self#visit_tuple env [ _visitors_r0; _visitors_r1 ]) + env _visitors_this.method_params + in + let _visitors_r2 = + self#visit_option self#visit_typ env _visitors_this.method_ret + in + let _visitors_r3 = + self#visit_option self#visit_typ env _visitors_this.method_err + in + let _visitors_r4 = + self#visit_location env _visitors_this.method_loc_ + in + self#visit_record env + [ + ("method_name", _visitors_r0); + ("method_params", _visitors_r1); + ("method_ret", _visitors_r2); + ("method_err", _visitors_r3); + ("method_loc_", _visitors_r4); + ] + + method visit_Output : + _ -> + impls -> + type_decl list -> + trait_decl list -> + trait_alias_decl list -> + S.t = + fun env -> + fun _visitors_fvalue_defs -> + fun _visitors_ftype_defs -> + fun _visitors_ftrait_defs -> + fun _visitors_ftrait_alias -> + let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in + let _visitors_r1 = + self#visit_list self#visit_type_decl env _visitors_ftype_defs + in + let _visitors_r2 = + self#visit_list self#visit_trait_decl env _visitors_ftrait_defs + in + let _visitors_r3 = + self#visit_list self#visit_trait_alias_decl env + _visitors_ftrait_alias + in + self#visit_inline_record env "Output" + [ + ("value_defs", _visitors_r0); + ("type_defs", _visitors_r1); + ("trait_defs", _visitors_r2); + ("trait_alias", _visitors_r3); + ] method visit_output : _ -> output -> S.t = - fun env _visitors_this -> - match _visitors_this with - | Output - { - value_defs = _visitors_fvalue_defs; - type_defs = _visitors_ftype_defs; - trait_defs = _visitors_ftrait_defs; - } -> - self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs - _visitors_ftrait_defs + fun env -> + fun _visitors_this -> + match _visitors_this with + | Output + { + value_defs = _visitors_fvalue_defs; + type_defs = _visitors_ftype_defs; + trait_defs = _visitors_ftrait_defs; + trait_alias = _visitors_ftrait_alias; + } -> + self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs + _visitors_ftrait_defs _visitors_ftrait_alias end [@@@VISITORS.END] @@ -3587,2170 +4445,2825 @@ include struct inherit [_] iterbase method visit_stub_decl : _ -> stub_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_params env _visitors_this.params in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_this.ret - in - let _visitors_r3 = - self#visit_stub_body env _visitors_this.func_stubs - in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_this.is_pub in - let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in - let _visitors_r6 = - self#visit_fun_decl_kind env _visitors_this.kind_ - in - let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_params env _visitors_this.params in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_this.ret + in + let _visitors_r3 = + self#visit_stub_body env _visitors_this.func_stubs + in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_this.is_pub + in + let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in + let _visitors_r6 = + self#visit_fun_decl_kind env _visitors_this.kind_ + in + let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in + let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in + () method visit_Intrinsic : _ -> unit = fun env -> () method visit_Func_stub : _ -> func_stubs -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + () method visit_stub_body : _ -> stub_body -> unit = - fun env _visitors_this -> - match _visitors_this with - | Intrinsic -> self#visit_Intrinsic env - | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 - - method visit_Texpr_apply - : _ -> - expr -> - argument list -> - stype -> - apply_kind -> - location -> - unit = - fun env _visitors_ffunc _visitors_fargs _visitors_fty _visitors_fkind_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_method - : _ -> - var -> - stype array -> - fn_arity option -> - type_name -> - Primitive.prim option -> - stype -> - location -> - unit = - fun env _visitors_fmeth _visitors_fty_args_ _visitors_farity_ - _visitors_ftype_name _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fmeth in - let _visitors_r1 = - (fun _visitors_this -> - Basic_arr.iter _visitors_this (self#visit_stype env)) - _visitors_fty_args_ - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_fn_arity env) t - | None -> ()) - _visitors_farity_ - in - let _visitors_r3 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_prim env) t - | None -> ()) - _visitors_fprim - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_unresolved_method - : _ -> - type_path_loc -> - string -> - stype -> - fn_arity option -> - stype -> - location -> - unit = - fun env _visitors_ftrait_name _visitors_fmethod_name - _visitors_fself_type _visitors_farity_ _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_type_path_loc env _visitors_ftrait_name - in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_fmethod_name - in - let _visitors_r2 = self#visit_stype env _visitors_fself_type in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_fn_arity env) t - | None -> ()) - _visitors_farity_ - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_ident - : _ -> - var -> - stype array -> - fn_arity option -> - value_kind -> - stype -> - location -> - unit = - fun env _visitors_fid _visitors_fty_args_ _visitors_farity_ - _visitors_fkind _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - (fun _visitors_this -> - Basic_arr.iter _visitors_this (self#visit_stype env)) - _visitors_fty_args_ - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_fn_arity env) t - | None -> ()) - _visitors_farity_ - in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fkind in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_as - : _ -> expr -> type_name -> stype -> bool -> location -> unit = - fun env _visitors_fexpr _visitors_ftrait _visitors_fty - _visitors_fis_implicit _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_fis_implicit - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_array - : _ -> expr list -> stype -> bool -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_fis_fixed_array - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fis_fixed_array - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_constant - : _ -> constant -> stype -> var option -> location -> unit = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_var env) t - | None -> ()) - _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_constr - : _ -> - Syntax.constructor -> - constr_tag -> - stype -> - fn_arity -> - location -> - unit = - fun env _visitors_fconstr _visitors_ftag _visitors_fty _visitors_farity_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_while - : _ -> expr -> expr -> expr option -> stype -> location -> unit = - fun env _visitors_floop_cond _visitors_floop_body _visitors_fwhile_else - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fwhile_else - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_function : _ -> fn -> stype -> location -> unit = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_if - : _ -> expr -> expr -> expr option -> stype -> location -> unit = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fifnot - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_letfn - : _ -> binder -> fn -> expr -> stype -> bool -> location -> unit = - fun env _visitors_fbinder _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fis_rec _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fis_rec in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_letrec - : _ -> (binder * fn) list -> expr -> stype -> location -> unit = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - ())) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_let - : _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> unit + fun env -> + fun _visitors_this -> + match _visitors_this with + | Intrinsic -> self#visit_Intrinsic env + | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 + + method visit_Texpr_apply : + _ -> expr -> argument list -> stype -> apply_kind -> location -> unit + = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_fkind_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_method : + _ -> + var -> + stype array -> + fn_arity option -> + type_name -> + Primitive.prim option -> + stype -> + location -> + unit = + fun env -> + fun _visitors_fmeth -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_ftype_name -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fmeth in + let _visitors_r1 = + (fun _visitors_this -> + Basic_arr.iter _visitors_this (self#visit_stype env)) + _visitors_fty_args_ + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_fn_arity env) t + | None -> ()) + _visitors_farity_ + in + let _visitors_r3 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_prim env) t + | None -> ()) + _visitors_fprim + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_unresolved_method : + _ -> + type_name -> + string -> + stype -> + fn_arity option -> + stype -> + location -> + unit = + fun env -> + fun _visitors_ftrait_name -> + fun _visitors_fmethod_name -> + fun _visitors_fself_type -> + fun _visitors_farity_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftrait_name + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fmethod_name + in + let _visitors_r2 = self#visit_stype env _visitors_fself_type in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_fn_arity env) t + | None -> ()) + _visitors_farity_ + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_ident : + _ -> + var -> + stype array -> + fn_arity option -> + value_kind -> + stype -> + location -> + unit = + fun env -> + fun _visitors_fid -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + (fun _visitors_this -> + Basic_arr.iter _visitors_this (self#visit_stype env)) + _visitors_fty_args_ + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_fn_arity env) t + | None -> ()) + _visitors_farity_ + in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fkind in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_as : + _ -> expr -> type_name -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fty -> + fun _visitors_fis_implicit -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_implicit + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_array : + _ -> expr list -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_fis_fixed_array -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_fixed_array + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_constant : + _ -> constant -> stype -> var option -> location -> unit = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_var env) t + | None -> ()) + _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_tag -> + stype -> + fn_arity -> + location -> + unit = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_while : + _ -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + unit = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fwhile_else + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_loop_label_binder env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_function : _ -> fn -> stype -> bool -> location -> unit = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_sequence - : _ -> expr -> expr -> stype -> location -> unit = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_if : + _ -> expr -> expr -> expr option -> stype -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fifnot + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_letfn : + _ -> binder -> fn -> expr -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fis_rec -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fis_rec + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_letrec : + _ -> (binder * fn) list -> expr -> stype -> location -> unit = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + ())) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_let : + _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> unit = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_sequence : + _ -> expr list -> expr -> stype -> location -> unit = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_Texpr_tuple : _ -> expr list -> stype -> location -> unit = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_record - : _ -> type_name option -> field_def list -> stype -> location -> unit + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_record : + _ -> type_name option -> field_def list -> stype -> location -> unit = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_record_update : + _ -> + type_name option -> + expr -> + field_info list -> + field_def list -> + stype -> + location -> + unit = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_fall_fields -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_info env)) + _visitors_fall_fields + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_field : + _ -> expr -> Syntax.accessor -> int -> stype -> location -> unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_mutate : + _ -> + expr -> + Syntax.label -> + expr -> + int -> + expr option -> + stype -> + location -> + unit = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_faugmented_by + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_match : + _ -> expr -> match_case list -> stype -> location -> location -> unit + = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fty -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_match_case env)) + _visitors_fcases + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + self#visit_location env _visitors_fmatch_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_letmut : + _ -> binder -> typ option -> expr -> expr -> stype -> location -> unit = - fun env _visitors_ftype_name _visitors_ffields _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_ftype_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_record_update - : _ -> - type_name option -> - expr -> - field_info list -> - field_def list -> - stype -> - location -> - unit = - fun env _visitors_ftype_name _visitors_frecord _visitors_fall_fields - _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_info env)) - _visitors_fall_fields - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_field - : _ -> expr -> Syntax.accessor -> int -> stype -> location -> unit = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_mutate - : _ -> - expr -> - Syntax.label -> - expr -> - int -> - expr option -> - stype -> - location -> - unit = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_faugmented_by _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_faugmented_by - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_match - : _ -> - expr -> - match_case list -> - stype -> - location -> - location -> - unit = - fun env _visitors_fexpr _visitors_fcases _visitors_fty - _visitors_fmatch_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_match_case env)) - _visitors_fcases - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_fmatch_loc_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_letmut - : _ -> - binder -> - typ option -> - expr -> - expr -> - stype -> - location -> - unit = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_assign - : _ -> var -> expr -> expr option -> stype -> location -> unit = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_faugmented_by - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_assign : + _ -> var -> expr -> expr option -> stype -> location -> unit = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_faugmented_by + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () method visit_Texpr_hole : _ -> stype -> location -> syntax_hole -> unit = - fun env _visitors_fty _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in - () + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in + () method visit_Texpr_unit : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_break : _ -> expr option -> stype -> location -> unit = - fun env _visitors_farg _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_farg - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_continue : _ -> expr list -> stype -> location -> unit - = - fun env _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_loop - : _ -> param list -> expr -> expr list -> stype -> location -> unit = - fun env _visitors_fparams _visitors_fbody _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_for - : _ -> - (binder * expr) list -> - expr option -> - (var * expr) list -> - expr -> - expr option -> - stype -> - location -> - unit = - fun env _visitors_fbinders _visitors_fcondition _visitors_fsteps - _visitors_fbody _visitors_ffor_else _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fcondition - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - ())) - _visitors_fsteps - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_ffor_else - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_foreach - : _ -> - binder option list -> - stype list -> - expr -> - expr -> - expr option -> - stype -> - location -> - unit = - fun env _visitors_fbinders _visitors_felem_tys _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun _visitors_this -> + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_break : + _ -> expr option -> stype -> loop_label option -> location -> unit = + fun env -> + fun _visitors_farg -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_farg + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> match _visitors_this with - | Some t -> (self#visit_binder env) t - | None -> ())) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_stype env)) - _visitors_felem_tys - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_felse_block - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () + | Some t -> (self#visit_loop_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_continue : + _ -> expr list -> stype -> loop_label option -> location -> unit = + fun env -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_loop_label env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_loop : + _ -> + param list -> + expr -> + expr list -> + stype -> + loop_label_binder option -> + location -> + unit = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_loop_label_binder env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_for : + _ -> + (binder * expr) list -> + expr option -> + (var * expr) list -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + unit = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fsteps -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + ())) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fcondition + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + ())) + _visitors_fsteps + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_ffor_else + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_loop_label_binder env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_foreach : + _ -> + binder option list -> + stype list -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + unit = + fun env -> + fun _visitors_fbinders -> + fun _visitors_felem_tys -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_binder env) t + | None -> ())) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_stype env)) + _visitors_felem_tys + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_felse_block + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_loop_label_binder env) t + | None -> ()) + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + () method visit_Texpr_return : _ -> expr option -> stype -> location -> unit = - fun env _visitors_freturn_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_freturn_value - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_freturn_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_freturn_value + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Texpr_raise : _ -> expr -> stype -> location -> unit = - fun env _visitors_ferror_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferror_value in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_try - : _ -> - expr -> - match_case list -> - bool -> - match_case list option -> - stype -> - stype -> - location -> - location -> - location -> - unit = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_fty _visitors_ferr_ty - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_match_case env)) - _visitors_fcatch - in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fcatch_all in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_match_case env)) - t - | None -> ()) - _visitors_ftry_else - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in - let _visitors_r6 = self#visit_location env _visitors_fcatch_loc_ in - let _visitors_r7 = self#visit_location env _visitors_felse_loc_ in - let _visitors_r8 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_exclamation - : _ -> expr -> stype -> bool -> location -> unit = - fun env _visitors_fexpr _visitors_fty _visitors_fconvert_to_result - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_fconvert_to_result - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_constraint - : _ -> expr -> typ -> stype -> location -> unit = - fun env _visitors_fexpr _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_pipe - : _ -> expr -> pipe_rhs -> stype -> location -> unit = - fun env _visitors_flhs _visitors_frhs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_interp - : _ -> interp_elem list -> stype -> location -> unit = - fun env _visitors_felems _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_interp_elem env)) - _visitors_felems - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_guard - : _ -> expr -> expr option -> expr -> stype -> location -> unit = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_expr env) t - | None -> ()) - _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () - - method visit_Texpr_guard_let - : _ -> - pat -> - expr -> - pat_binders -> - match_case list option -> - expr -> - stype -> - location -> - unit = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fotherwise _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_match_case env)) - t - | None -> ()) - _visitors_fotherwise - in - let _visitors_r4 = self#visit_expr env _visitors_fbody in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_ferror_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferror_value in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_try : + _ -> + expr -> + match_case list -> + bool -> + match_case list option -> + stype -> + stype -> + location -> + location -> + location -> + unit = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_fty -> + fun _visitors_ferr_ty -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_match_case env)) + _visitors_fcatch + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fcatch_all + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_match_case env)) + t + | None -> ()) + _visitors_ftry_else + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in + let _visitors_r6 = + self#visit_location env _visitors_fcatch_loc_ + in + let _visitors_r7 = + self#visit_location env _visitors_felse_loc_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_exclamation : + _ -> expr -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_fconvert_to_result -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fconvert_to_result + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_constraint : + _ -> expr -> typ -> stype -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_pipe : + _ -> expr -> pipe_rhs -> stype -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_interp : + _ -> interp_elem list -> stype -> location -> unit = + fun env -> + fun _visitors_felems -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_interp_elem env)) + _visitors_felems + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_guard : + _ -> expr -> expr option -> expr -> stype -> location -> unit = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_guard_let : + _ -> + pat -> + expr -> + pat_binders -> + match_case list option -> + expr -> + stype -> + location -> + unit = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_match_case env)) + t + | None -> ()) + _visitors_fotherwise + in + let _visitors_r4 = self#visit_expr env _visitors_fbody in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_is : + _ -> expr -> pat -> pat_binders -> location -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_fpat_binders -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_array_as_view : _ -> expr -> stype -> location -> unit + = + fun env -> + fun _visitors_farray -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_and : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Texpr_or : _ -> expr -> expr -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_expr : _ -> expr -> unit = - fun env _visitors_this -> - match _visitors_this with - | Texpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - ty = _visitors_fty; - kind_ = _visitors_fkind_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fty _visitors_fkind_ _visitors_floc_ - | Texpr_method - { - meth = _visitors_fmeth; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - type_name = _visitors_ftype_name; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ - _visitors_farity_ _visitors_ftype_name _visitors_fprim - _visitors_fty _visitors_floc_ - | Texpr_unresolved_method - { - trait_name = _visitors_ftrait_name; - method_name = _visitors_fmethod_name; - self_type = _visitors_fself_type; - arity_ = _visitors_farity_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_unresolved_method env _visitors_ftrait_name - _visitors_fmethod_name _visitors_fself_type _visitors_farity_ - _visitors_fty _visitors_floc_ - | Texpr_ident - { - id = _visitors_fid; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - kind = _visitors_fkind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ - _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ - | Texpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - ty = _visitors_fty; - is_implicit = _visitors_fis_implicit; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fty _visitors_fis_implicit _visitors_floc_ - | Texpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - is_fixed_array = _visitors_fis_fixed_array; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_array env _visitors_fexprs _visitors_fty - _visitors_fis_fixed_array _visitors_floc_ - | Texpr_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Texpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - ty = _visitors_fty; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fty _visitors_farity_ _visitors_floc_ - | Texpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_fty - _visitors_floc_ - | Texpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Texpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Texpr_letfn - { - binder = _visitors_fbinder; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - is_rec = _visitors_fis_rec; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ - | Texpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fbody _visitors_fty - _visitors_floc_ - | Texpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Texpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Texpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record env _visitors_ftype_name _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - all_fields = _visitors_fall_fields; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_fall_fields _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Texpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_faugmented_by - _visitors_fty _visitors_floc_ - | Texpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - ty = _visitors_fty; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_match env _visitors_fexpr _visitors_fcases - _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ - | Texpr_letmut - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letmut env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_fty _visitors_floc_ - | Texpr_hole - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - kind = _visitors_fkind; - } -> - self#visit_Texpr_hole env _visitors_fty _visitors_floc_ - _visitors_fkind - | Texpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Texpr_unit env _visitors_floc_ - | Texpr_break - { - arg = _visitors_farg; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_break env _visitors_farg _visitors_fty - _visitors_floc_ - | Texpr_continue - { - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_continue env _visitors_fargs _visitors_fty - _visitors_floc_ - | Texpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_fty _visitors_floc_ - | Texpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - steps = _visitors_fsteps; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fsteps _visitors_fbody _visitors_ffor_else - _visitors_fty _visitors_floc_ - | Texpr_foreach - { - binders = _visitors_fbinders; - elem_tys = _visitors_felem_tys; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_foreach env _visitors_fbinders - _visitors_felem_tys _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_fty _visitors_floc_ - | Texpr_return - { - return_value = _visitors_freturn_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_return env _visitors_freturn_value _visitors_fty - _visitors_floc_ - | Texpr_raise - { - error_value = _visitors_ferror_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty - _visitors_floc_ - | Texpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - ty = _visitors_fty; - err_ty = _visitors_ferr_ty; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_fty - _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ - _visitors_floc_ - | Texpr_exclamation - { - expr = _visitors_fexpr; - ty = _visitors_fty; - convert_to_result = _visitors_fconvert_to_result; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty - _visitors_fconvert_to_result _visitors_floc_ - | Texpr_constraint - { - expr = _visitors_fexpr; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constraint env _visitors_fexpr - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Texpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs - _visitors_fty _visitors_floc_ - | Texpr_interp - { - elems = _visitors_felems; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_interp env _visitors_felems _visitors_fty - _visitors_floc_ - | Texpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_fty _visitors_floc_ - | Texpr_guard_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Texpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + ty = _visitors_fty; + kind_ = _visitors_fkind_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fty _visitors_fkind_ _visitors_floc_ + | Texpr_method + { + meth = _visitors_fmeth; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + type_name = _visitors_ftype_name; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ + _visitors_farity_ _visitors_ftype_name _visitors_fprim + _visitors_fty _visitors_floc_ + | Texpr_unresolved_method + { + trait_name = _visitors_ftrait_name; + method_name = _visitors_fmethod_name; + self_type = _visitors_fself_type; + arity_ = _visitors_farity_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_unresolved_method env _visitors_ftrait_name + _visitors_fmethod_name _visitors_fself_type _visitors_farity_ + _visitors_fty _visitors_floc_ + | Texpr_ident + { + id = _visitors_fid; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + kind = _visitors_fkind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ + _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ + | Texpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + ty = _visitors_fty; + is_implicit = _visitors_fis_implicit; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fty _visitors_fis_implicit _visitors_floc_ + | Texpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + is_fixed_array = _visitors_fis_fixed_array; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array env _visitors_fexprs _visitors_fty + _visitors_fis_fixed_array _visitors_floc_ + | Texpr_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Texpr_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + tag = _visitors_ftag; + ty = _visitors_fty; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constr env _visitors_ftype_name + _visitors_fconstr _visitors_ftag _visitors_fty + _visitors_farity_ _visitors_floc_ + | Texpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Texpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Texpr_letfn + { + binder = _visitors_fbinder; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + is_rec = _visitors_fis_rec; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ + | Texpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fbody _visitors_fty + _visitors_floc_ + | Texpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Texpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Texpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record env _visitors_ftype_name + _visitors_ffields _visitors_fty _visitors_floc_ + | Texpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + all_fields = _visitors_fall_fields; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_fall_fields _visitors_ffields + _visitors_fty _visitors_floc_ + | Texpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_field env _visitors_frecord _visitors_faccessor + _visitors_fpos _visitors_fty _visitors_floc_ + | Texpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_faugmented_by + _visitors_fty _visitors_floc_ + | Texpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + ty = _visitors_fty; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_match env _visitors_fexpr _visitors_fcases + _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ + | Texpr_letmut + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letmut env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_fty _visitors_floc_ + | Texpr_hole + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + kind = _visitors_fkind; + } -> + self#visit_Texpr_hole env _visitors_fty _visitors_floc_ + _visitors_fkind + | Texpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Texpr_unit env _visitors_floc_ + | Texpr_break + { + arg = _visitors_farg; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_break env _visitors_farg _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_continue + { + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_continue env _visitors_fargs _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + steps = _visitors_fsteps; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition + _visitors_fsteps _visitors_fbody _visitors_ffor_else + _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_foreach + { + binders = _visitors_fbinders; + elem_tys = _visitors_felem_tys; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_foreach env _visitors_fbinders + _visitors_felem_tys _visitors_fexpr _visitors_fbody + _visitors_felse_block _visitors_fty _visitors_flabel + _visitors_floc_ + | Texpr_return + { + return_value = _visitors_freturn_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_return env _visitors_freturn_value _visitors_fty + _visitors_floc_ + | Texpr_raise + { + error_value = _visitors_ferror_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty + _visitors_floc_ + | Texpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + ty = _visitors_fty; + err_ty = _visitors_ferr_ty; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_fty + _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ + _visitors_floc_ + | Texpr_exclamation + { + expr = _visitors_fexpr; + ty = _visitors_fty; + convert_to_result = _visitors_fconvert_to_result; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty + _visitors_fconvert_to_result _visitors_floc_ + | Texpr_constraint + { + expr = _visitors_fexpr; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constraint env _visitors_fexpr + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Texpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs + _visitors_fty _visitors_floc_ + | Texpr_interp + { + elems = _visitors_felems; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_interp env _visitors_felems _visitors_fty + _visitors_floc_ + | Texpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_fty _visitors_floc_ + | Texpr_guard_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fotherwise _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + pat_binders = _visitors_fpat_binders; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_is env _visitors_fexpr _visitors_fpat + _visitors_fpat_binders _visitors_floc_ + | Texpr_array_as_view + { + array = _visitors_farray; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array_as_view env _visitors_farray _visitors_fty + _visitors_floc_ + | Texpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Texpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_argument : _ -> argument -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - () - - method visit_Pipe_partial_apply - : _ -> expr -> argument list -> location -> unit = - fun env _visitors_ffunc _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + () + + method visit_Pipe_partial_apply : + _ -> expr -> argument list -> location -> unit = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Pipe_invalid : _ -> expr -> stype -> location -> unit = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_pipe_rhs : _ -> pipe_rhs -> unit = - fun env _visitors_this -> - match _visitors_this with - | Pipe_partial_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs - _visitors_floc_ - | Pipe_invalid - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pipe_partial_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs + _visitors_floc_ + | Pipe_invalid + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty + _visitors_floc_ method visit_Interp_lit : _ -> string -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in + () method visit_Interp_expr : _ -> expr -> expr -> location -> unit = - fun env _visitors_fexpr _visitors_fto_string _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_expr env _visitors_fto_string in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fexpr -> + fun _visitors_fto_string -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_expr env _visitors_fto_string in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_interp_elem : _ -> interp_elem -> unit = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 - | Interp_expr - { - expr = _visitors_fexpr; - to_string = _visitors_fto_string; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string - _visitors_floc_ - - method visit_Field_def - : _ -> Syntax.label -> expr -> bool -> bool -> int -> unit = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_mut - _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_mut in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fis_pun in - let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fpos in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 + | Interp_expr + { + expr = _visitors_fexpr; + to_string = _visitors_fto_string; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string + _visitors_floc_ + + method visit_Field_def : + _ -> Syntax.label -> expr -> bool -> bool -> int -> unit = + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_mut -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_mut + in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_pun + in + let _visitors_r4 = (fun _visitors_this -> ()) _visitors_fpos in + () method visit_field_def : _ -> field_def -> unit = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_mut = _visitors_fis_mut; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_mut _visitors_fis_pun _visitors_fpos + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_mut = _visitors_fis_mut; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_mut _visitors_fis_pun _visitors_fpos method visit_Field_pat : _ -> Syntax.label -> pat -> bool -> int -> unit = - fun env _visitors_flabel _visitors_fpat _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pat env _visitors_fpat in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pun in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in - () + fun env -> + fun _visitors_flabel -> + fun _visitors_fpat -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fis_pun in + let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fpos in + () method visit_field_pat : _ -> field_pat -> unit = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pat = _visitors_fpat; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpat - _visitors_fis_pun _visitors_fpos + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pat = _visitors_fpat; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpat + _visitors_fis_pun _visitors_fpos method visit_constr_pat_args : _ -> constr_pat_args -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_pat_arg env) - - method visit_Constr_pat_arg - : _ -> pat -> Syntax.argument_kind -> int -> unit = - fun env _visitors_fpat _visitors_fkind _visitors_fpos -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in - () + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_pat_arg env) + + method visit_Constr_pat_arg : + _ -> pat -> Syntax.argument_kind -> int -> unit = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fpos in + () method visit_constr_pat_arg : _ -> constr_pat_arg -> unit = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg - { - pat = _visitors_fpat; - kind = _visitors_fkind; - pos = _visitors_fpos; - } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - _visitors_fpos - - method visit_Param - : _ -> binder -> typ option -> stype -> param_kind -> unit = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fty - _visitors_fkind -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_param_kind env _visitors_fkind in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg + { + pat = _visitors_fpat; + kind = _visitors_fkind; + pos = _visitors_fpos; + } -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + _visitors_fpos + + method visit_Param : + _ -> binder -> typ option -> stype -> param_kind -> unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_param_kind env _visitors_fkind in + () + + method visit_Discard_positional_param : + _ -> stype -> typ option -> location -> unit = + fun env -> + fun _visitors_fty -> + fun _visitors_fkonstraint -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_param : _ -> param -> unit = - fun env _visitors_this -> - match _visitors_this with - | Param - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - kind = _visitors_fkind; - } -> - self#visit_Param env _visitors_fbinder _visitors_fkonstraint - _visitors_fty _visitors_fkind + fun env -> + fun _visitors_this -> + match _visitors_this with + | Param + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + kind = _visitors_fkind; + } -> + self#visit_Param env _visitors_fbinder _visitors_fkonstraint + _visitors_fty _visitors_fkind + | Discard_positional_param + { + ty = _visitors_fty; + konstraint = _visitors_fkonstraint; + loc_ = _visitors_floc_; + } -> + self#visit_Discard_positional_param env _visitors_fty + _visitors_fkonstraint _visitors_floc_ method visit_Positional : _ -> unit = fun env -> () method visit_Labelled : _ -> unit = fun env -> () method visit_Optional : _ -> expr -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + () method visit_Autofill : _ -> unit = fun env -> () method visit_Question_optional : _ -> unit = fun env -> () method visit_param_kind : _ -> param_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 - | Autofill -> self#visit_Autofill env - | Question_optional -> self#visit_Question_optional env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Positional -> self#visit_Positional env + | Labelled -> self#visit_Labelled env + | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 + | Autofill -> self#visit_Autofill env + | Question_optional -> self#visit_Question_optional env method visit_params : _ -> params -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_param env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_param env) method visit_fn : _ -> fn -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_params env _visitors_this.params in - let _visitors_r1 = - self#visit_location env _visitors_this.params_loc_ - in - let _visitors_r2 = self#visit_expr env _visitors_this.body in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = self#visit_error_typ env _visitors_c1 in - ()) - t - | None -> ()) - _visitors_this.ret_constraint - in - let _visitors_r4 = self#visit_stype env _visitors_this.ty in - let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_params env _visitors_this.params in + let _visitors_r1 = + self#visit_location env _visitors_this.params_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = self#visit_error_typ env _visitors_c1 in + ()) + t + | None -> ()) + _visitors_this.ret_constraint + in + let _visitors_r4 = self#visit_stype env _visitors_this.ty in + let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in + () method visit_match_case : _ -> match_case -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_pat env _visitors_this.pat in - let _visitors_r1 = self#visit_expr env _visitors_this.action in - let _visitors_r2 = - self#visit_pat_binders env _visitors_this.pat_binders - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pat env _visitors_this.pat in + let _visitors_r1 = self#visit_expr env _visitors_this.action in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_expr env) t + | None -> ()) + _visitors_this.guard + in + let _visitors_r3 = + self#visit_pat_binders env _visitors_this.pat_binders + in + () method visit_Error_typ : _ -> typ -> unit = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - () + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + () method visit_Default_error_typ : _ -> location -> unit = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + () method visit_No_error_typ : _ -> unit = fun env -> () method visit_error_typ : _ -> error_typ -> unit = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Tany : _ -> stype -> location -> unit = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - () - - method visit_Tarrow - : _ -> typ list -> typ -> error_typ -> stype -> location -> unit = - fun env _visitors_fparams _visitors_freturn _visitors_ferr_ty - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_typ env _visitors_freturn in - let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + () + + method visit_Tarrow : + _ -> typ list -> typ -> error_typ -> stype -> location -> unit = + fun env -> + fun _visitors_fparams -> + fun _visitors_freturn -> + fun _visitors_ferr_ty -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_typ env _visitors_freturn in + let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () method visit_T_tuple : _ -> typ list -> stype -> location -> unit = - fun env _visitors_fparams _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Tname - : _ -> constrid_loc -> typ list -> stype -> bool -> location -> unit = - fun env _visitors_fconstr _visitors_fparams _visitors_fty - _visitors_fis_alias_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constrid_loc env _visitors_fconstr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fis_alias_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Tname : + _ -> constrid_loc -> typ list -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_typ env)) + _visitors_fparams + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_alias_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () + + method visit_Tobject : + _ -> constrid_loc -> stype -> bool -> location -> unit = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fis_alias_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_typ : _ -> typ -> unit = - fun env _visitors_this -> - match _visitors_this with - | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tany env _visitors_fty _visitors_floc_ - | Tarrow - { - params = _visitors_fparams; - return = _visitors_freturn; - err_ty = _visitors_ferr_ty; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tarrow env _visitors_fparams _visitors_freturn - _visitors_ferr_ty _visitors_fty _visitors_floc_ - | T_tuple - { - params = _visitors_fparams; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_T_tuple env _visitors_fparams _visitors_fty - _visitors_floc_ - | Tname - { - constr = _visitors_fconstr; - params = _visitors_fparams; - ty = _visitors_fty; - is_alias_ = _visitors_fis_alias_; - loc_ = _visitors_floc_; - } -> - self#visit_Tname env _visitors_fconstr _visitors_fparams - _visitors_fty _visitors_fis_alias_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tany env _visitors_fty _visitors_floc_ + | Tarrow + { + params = _visitors_fparams; + return = _visitors_freturn; + err_ty = _visitors_ferr_ty; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tarrow env _visitors_fparams _visitors_freturn + _visitors_ferr_ty _visitors_fty _visitors_floc_ + | T_tuple + { + params = _visitors_fparams; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_T_tuple env _visitors_fparams _visitors_fty + _visitors_floc_ + | Tname + { + constr = _visitors_fconstr; + params = _visitors_fparams; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tname env _visitors_fconstr _visitors_fparams + _visitors_fty _visitors_fis_alias_ _visitors_floc_ + | Tobject + { + constr = _visitors_fconstr; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tobject env _visitors_fconstr _visitors_fty + _visitors_fis_alias_ _visitors_floc_ method visit_Tpat_alias : _ -> pat -> binder -> stype -> location -> unit = - fun env _visitors_fpat _visitors_falias _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_Tpat_any : _ -> stype -> location -> unit = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + () method visit_Tpat_array : _ -> array_pattern -> stype -> location -> unit = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_constant - : _ -> constant -> stype -> var option -> location -> unit = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_var env) t - | None -> ()) - _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_constr - : _ -> - Syntax.constructor -> - constr_pat_args -> - constr_tag -> - stype -> - bool -> - location -> - unit = - fun env _visitors_fconstr _visitors_fargs _visitors_ftag _visitors_fty - _visitors_fused_error_subtyping _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_pat_args env _visitors_fargs in - let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_fused_error_subtyping - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_constant : + _ -> constant -> stype -> var option -> location -> unit = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> ()) _visitors_fc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_var env) t + | None -> ()) + _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_pat_args -> + constr_tag -> + stype -> + bool -> + fn_arity -> + stype list -> + location -> + unit = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_fused_error_subtyping -> + fun _visitors_farity_ -> + fun _visitors_fall_args_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = + self#visit_constr_pat_args env _visitors_fargs + in + let _visitors_r3 = + self#visit_constr_tag env _visitors_ftag + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = + (fun _visitors_this -> ()) _visitors_fused_error_subtyping + in + let _visitors_r6 = + self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r7 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_stype env)) + _visitors_fall_args_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + () method visit_Tpat_or : _ -> pat -> pat -> stype -> location -> unit = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat1 in - let _visitors_r1 = self#visit_pat env _visitors_fpat2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat1 in + let _visitors_r1 = self#visit_pat env _visitors_fpat2 in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () method visit_Tpat_tuple : _ -> pat list -> stype -> location -> unit = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pat env)) - _visitors_fpats - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pat env)) + _visitors_fpats + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () method visit_Tpat_var : _ -> binder -> stype -> location -> unit = - fun env _visitors_fbinder _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_record - : _ -> field_pat list -> bool -> stype -> location -> unit = - fun env _visitors_ffields _visitors_fis_closed _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_pat env)) - _visitors_ffields - in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fis_closed in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_constraint - : _ -> pat -> typ -> stype -> location -> unit = - fun env _visitors_fpat _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_map - : _ -> - (constant * pat) list -> - ident * stype * stype array -> - stype -> - location -> - unit = - fun env _visitors_felems _visitors_fop_get_info_ _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = (fun _visitors_this -> ()) _visitors_c0 in - let _visitors_r1 = self#visit_pat env _visitors_c1 in - ())) - _visitors_felems - in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_ident env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - let _visitors_r2 = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_record : + _ -> field_pat list -> bool -> stype -> location -> unit = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_pat env)) + _visitors_ffields + in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_closed + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_constraint : + _ -> pat -> typ -> stype -> location -> unit = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_map : + _ -> + (constant * pat) list -> + ident * stype * stype array -> + stype -> + location -> + unit = + fun env -> + fun _visitors_felems -> + fun _visitors_fop_get_info_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> - Basic_arr.iter _visitors_this (self#visit_stype env)) - _visitors_c2 + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> ()) _visitors_c0 + in + let _visitors_r1 = self#visit_pat env _visitors_c1 in + ())) + _visitors_felems + in + let _visitors_r1 = + (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = self#visit_ident env _visitors_c0 in + let _visitors_r1 = self#visit_stype env _visitors_c1 in + let _visitors_r2 = + (fun _visitors_this -> + Basic_arr.iter _visitors_this (self#visit_stype env)) + _visitors_c2 + in + ()) + _visitors_fop_get_info_ in - ()) - _visitors_fop_get_info_ - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - () - - method visit_Tpat_range - : _ -> pat -> pat -> bool -> stype -> location -> unit = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_flhs in - let _visitors_r1 = self#visit_pat env _visitors_frhs in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_finclusive in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - () + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + () + + method visit_Tpat_range : + _ -> pat -> pat -> bool -> stype -> location -> unit = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_flhs in + let _visitors_r1 = self#visit_pat env _visitors_frhs in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_finclusive + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + () method visit_pat : _ -> pat -> unit = - fun env _visitors_this -> - match _visitors_this with - | Tpat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_alias env _visitors_fpat _visitors_falias - _visitors_fty _visitors_floc_ - | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tpat_any env _visitors_fty _visitors_floc_ - | Tpat_array - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_array env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Tpat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - tag = _visitors_ftag; - ty = _visitors_fty; - used_error_subtyping = _visitors_fused_error_subtyping; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constr env _visitors_fconstr _visitors_fargs - _visitors_ftag _visitors_fty _visitors_fused_error_subtyping - _visitors_floc_ - | Tpat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_fty _visitors_floc_ - | Tpat_tuple - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_tuple env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_var - { - binder = _visitors_fbinder; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_var env _visitors_fbinder _visitors_fty - _visitors_floc_ - | Tpat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed - _visitors_fty _visitors_floc_ - | Tpat_constraint - { - pat = _visitors_fpat; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constraint env _visitors_fpat - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Tpat_map - { - elems = _visitors_felems; - op_get_info_ = _visitors_fop_get_info_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ - _visitors_fty _visitors_floc_ - | Tpat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tpat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_alias env _visitors_fpat _visitors_falias + _visitors_fty _visitors_floc_ + | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tpat_any env _visitors_fty _visitors_floc_ + | Tpat_array + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_array env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Tpat_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + args = _visitors_fargs; + tag = _visitors_ftag; + ty = _visitors_fty; + used_error_subtyping = _visitors_fused_error_subtyping; + arity_ = _visitors_farity_; + all_args_ = _visitors_fall_args_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constr env _visitors_ftype_name _visitors_fconstr + _visitors_fargs _visitors_ftag _visitors_fty + _visitors_fused_error_subtyping _visitors_farity_ + _visitors_fall_args_ _visitors_floc_ + | Tpat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_fty _visitors_floc_ + | Tpat_tuple + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_tuple env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_var + { + binder = _visitors_fbinder; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_var env _visitors_fbinder _visitors_fty + _visitors_floc_ + | Tpat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed + _visitors_fty _visitors_floc_ + | Tpat_constraint + { + pat = _visitors_fpat; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constraint env _visitors_fpat + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Tpat_map + { + elems = _visitors_felems; + op_get_info_ = _visitors_fop_get_info_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ + _visitors_fty _visitors_floc_ + | Tpat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_fty _visitors_floc_ method visit_Closed : _ -> pat list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pat env)) - _visitors_c0 - in - () - - method visit_Open - : _ -> pat list -> pat list -> (binder * stype) option -> unit = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pat env)) - _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_pat env)) - _visitors_c1 - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - ()) - t - | None -> ()) - _visitors_c2 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pat env)) + _visitors_c0 + in + () + + method visit_Open : + _ -> pat list -> pat list -> (binder * stype) option -> unit = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pat env)) + _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_pat env)) + _visitors_c1 + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_stype env _visitors_c1 in + ()) + t + | None -> ()) + _visitors_c2 + in + () method visit_array_pattern : _ -> array_pattern -> unit = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 method visit_fun_decl : _ -> fun_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_fun_decl_kind env _visitors_this.kind in - let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_this.is_pub in - let _visitors_r4 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_fun_decl_kind env _visitors_this.kind + in + let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_this.is_pub + in + let _visitors_r4 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_type_name env)) + _visitors_this.constraint_names + in + let _visitors_r6 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r7 = self#visit_attributes env _visitors_this.attrs in + () method visit_Fun_kind_regular : _ -> unit = fun env -> () method visit_Fun_kind_method : _ -> type_name option -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_type_name env) t - | None -> ()) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_type_name env) t + | None -> ()) + _visitors_c0 + in + () method visit_Fun_kind_default_impl : _ -> type_name -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_name env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_name env _visitors_c0 in + () method visit_Fun_kind_impl : _ -> typ -> type_name -> unit = - fun env _visitors_fself_ty _visitors_ftrait -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - () + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + () method visit_fun_decl_kind : _ -> fun_decl_kind -> unit = - fun env _visitors_this -> - match _visitors_this with - | Fun_kind_regular -> self#visit_Fun_kind_regular env - | Fun_kind_method _visitors_c0 -> - self#visit_Fun_kind_method env _visitors_c0 - | Fun_kind_default_impl _visitors_c0 -> - self#visit_Fun_kind_default_impl env _visitors_c0 - | Fun_kind_impl - { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> - self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait - - method visit_Timpl_expr - : _ -> expr -> bool -> _ -> absolute_loc -> bool -> unit = - fun env _visitors_fexpr _visitors_fis_main _visitors_fexpr_id - _visitors_floc_ _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = (fun _visitors_this -> ()) _visitors_fis_main in - let _visitors_r2 = (fun _visitors_this -> ()) _visitors_fexpr_id in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r4 = - (fun _visitors_this -> ()) _visitors_fis_generated_ - in - () - - method visit_Timpl_fun_decl - : _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> unit = - fun env _visitors_ffun_decl _visitors_farity_ _visitors_floc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r3 = - (fun _visitors_this -> ()) _visitors_fis_generated_ - in - () - - method visit_Timpl_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - absolute_loc -> - docstring -> - bool -> - unit = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fis_pub _visitors_floc_ _visitors_fdoc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = (fun _visitors_this -> ()) _visitors_fis_pub in - let _visitors_r4 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in - let _visitors_r6 = - (fun _visitors_this -> ()) _visitors_fis_generated_ - in - () + fun env -> + fun _visitors_this -> + match _visitors_this with + | Fun_kind_regular -> self#visit_Fun_kind_regular env + | Fun_kind_method _visitors_c0 -> + self#visit_Fun_kind_method env _visitors_c0 + | Fun_kind_default_impl _visitors_c0 -> + self#visit_Fun_kind_default_impl env _visitors_c0 + | Fun_kind_impl + { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> + self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait + + method visit_Timpl_expr : + _ -> expr -> bool -> _ -> absolute_loc -> bool -> unit = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_fexpr_id -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_fis_main + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_fexpr_id + in + let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r4 = + (fun _visitors_this -> ()) _visitors_fis_generated_ + in + () + + method visit_Timpl_fun_decl : + _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> unit = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_generated_ + in + () + + method visit_Timpl_letdef : + _ -> + binder -> + typ option -> + expr -> + bool -> + absolute_loc -> + docstring -> + attributes -> + bool -> + unit = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + fun _visitors_fdoc_ -> + fun _visitors_fattrs -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = + (fun _visitors_this -> ()) _visitors_fis_pub + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + let _visitors_r6 = + self#visit_attributes env _visitors_fattrs + in + let _visitors_r7 = + (fun _visitors_this -> ()) _visitors_fis_generated_ + in + () method visit_Timpl_stub_decl : _ -> stub_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in + () method visit_impl : _ -> impl -> unit = - fun env _visitors_this -> - match _visitors_this with - | Timpl_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - expr_id = _visitors_fexpr_id; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main - _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ - | Timpl_fun_decl - { - fun_decl = _visitors_ffun_decl; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_fun_decl env _visitors_ffun_decl - _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ - | Timpl_letdef - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_letdef env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub - _visitors_floc_ _visitors_fdoc_ _visitors_fis_generated_ - | Timpl_stub_decl _visitors_c0 -> - self#visit_Timpl_stub_decl env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Timpl_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + expr_id = _visitors_fexpr_id; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main + _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ + | Timpl_fun_decl + { + fun_decl = _visitors_ffun_decl; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_fun_decl env _visitors_ffun_decl + _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ + | Timpl_letdef + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + doc_ = _visitors_fdoc_; + attrs = _visitors_fattrs; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_letdef env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub + _visitors_floc_ _visitors_fdoc_ _visitors_fattrs + _visitors_fis_generated_ + | Timpl_stub_decl _visitors_c0 -> + self#visit_Timpl_stub_decl env _visitors_c0 method visit_impls : _ -> impls -> unit = - fun env _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_impl env) + fun env -> + fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_impl env) method visit_type_decl : _ -> type_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.td_binder - in - let _visitors_r1 = self#visit_tvar_env env _visitors_this.td_params in - let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in - let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in - let _visitors_r4 = - self#visit_absolute_loc env _visitors_this.td_loc_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in - let _visitors_r6 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constrid_loc env)) - _visitors_this.td_deriving_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.td_binder + in + let _visitors_r1 = + self#visit_tvar_env env _visitors_this.td_params + in + let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in + let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.td_loc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_type_name env)) + _visitors_this.td_deriving_ + in + () method visit_No_payload : _ -> unit = fun env -> () method visit_Single_payload : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_Enum_payload : _ -> constr_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_decl env)) + _visitors_c0 + in + () method visit_exception_decl : _ -> exception_decl -> unit = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Td_abstract : _ -> unit = fun env -> () method visit_Td_error : _ -> exception_decl -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + () method visit_Td_newtype : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_Td_variant : _ -> constr_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_decl env)) + _visitors_c0 + in + () method visit_Td_record : _ -> field_decl list -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_field_decl env)) - _visitors_c0 - in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_field_decl env)) + _visitors_c0 + in + () method visit_Td_alias : _ -> typ -> unit = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - () + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + () method visit_type_desc : _ -> type_desc -> unit = - fun env _visitors_this -> - match _visitors_this with - | Td_abstract -> self#visit_Td_abstract env - | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 - | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 - | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 - | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 - | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Td_abstract -> self#visit_Td_abstract env + | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 + | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 + | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 + | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 + | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 method visit_constr_decl_arg : _ -> constr_decl_arg -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in - let _visitors_r1 = - (fun _visitors_this -> ()) _visitors_this.carg_mut - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_label env) t - | None -> ()) - _visitors_this.carg_label - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in + let _visitors_r1 = + (fun _visitors_this -> ()) _visitors_this.carg_mut + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_this.carg_label + in + () method visit_constr_decl : _ -> constr_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.constr_name in - let _visitors_r1 = - self#visit_constr_tag env _visitors_this.constr_tag - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_constr_decl_arg env)) - _visitors_this.constr_args - in - let _visitors_r3 = - self#visit_fn_arity env _visitors_this.constr_arity_ - in - let _visitors_r4 = - self#visit_location env _visitors_this.constr_loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.constr_name in + let _visitors_r1 = + self#visit_constr_tag env _visitors_this.constr_tag + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_constr_decl_arg env)) + _visitors_this.constr_args + in + let _visitors_r3 = + self#visit_fn_arity env _visitors_this.constr_arity_ + in + let _visitors_r4 = + self#visit_location env _visitors_this.constr_loc_ + in + () method visit_field_decl : _ -> field_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.field_label in - let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in - let _visitors_r2 = - (fun _visitors_this -> ()) _visitors_this.field_mut - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - self#visit_location env _visitors_this.field_loc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.field_label in + let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.field_mut + in + let _visitors_r3 = + self#visit_type_component_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + self#visit_location env _visitors_this.field_loc_ + in + () method visit_trait_decl : _ -> trait_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.trait_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_method_decl env)) - _visitors_this.trait_methods - in - let _visitors_r2 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.trait_loc_ - in - let _visitors_r4 = - self#visit_docstring env _visitors_this.trait_doc_ - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_type_name env)) + _visitors_this.trait_supers + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_method_decl env)) + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.trait_loc_ + in + let _visitors_r5 = + self#visit_docstring env _visitors_this.trait_doc_ + in + let _visitors_r6 = + self#visit_attributes env _visitors_this.trait_attrs + in + () + + method visit_trait_alias_decl : _ -> trait_alias_decl -> unit = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_alias_name + in + let _visitors_r1 = + self#visit_type_name env _visitors_this.trait_alias_target + in + let _visitors_r2 = + (fun _visitors_this -> ()) _visitors_this.trait_alias_is_pub + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.trait_alias_loc_ + in + let _visitors_r4 = + self#visit_docstring env _visitors_this.trait_alias_doc_ + in + () method visit_method_decl : _ -> method_decl -> unit = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_syntax_binder env _visitors_this.method_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_label env) t - | None -> ()) - _visitors_c0 - in - let _visitors_r1 = self#visit_typ env _visitors_c1 in - ())) - _visitors_this.method_params - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_this.method_ret - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> (self#visit_typ env) t - | None -> ()) - _visitors_this.method_err - in - let _visitors_r4 = - self#visit_location env _visitors_this.method_loc_ - in - () - - method visit_Output - : _ -> impls -> type_decl list -> trait_decl list -> unit = - fun env _visitors_fvalue_defs _visitors_ftype_defs _visitors_ftrait_defs -> - let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_type_decl env)) - _visitors_ftype_defs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.iter _visitors_this (self#visit_trait_decl env)) - _visitors_ftrait_defs - in - () + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_syntax_binder env _visitors_this.method_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_label env) t + | None -> ()) + _visitors_c0 + in + let _visitors_r1 = self#visit_typ env _visitors_c1 in + ())) + _visitors_this.method_params + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_this.method_ret + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> (self#visit_typ env) t + | None -> ()) + _visitors_this.method_err + in + let _visitors_r4 = + self#visit_location env _visitors_this.method_loc_ + in + () + + method visit_Output : + _ -> + impls -> + type_decl list -> + trait_decl list -> + trait_alias_decl list -> + unit = + fun env -> + fun _visitors_fvalue_defs -> + fun _visitors_ftype_defs -> + fun _visitors_ftrait_defs -> + fun _visitors_ftrait_alias -> + let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_type_decl env)) + _visitors_ftype_defs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this ~f:(self#visit_trait_decl env)) + _visitors_ftrait_defs + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.iter _visitors_this + ~f:(self#visit_trait_alias_decl env)) + _visitors_ftrait_alias + in + () method visit_output : _ -> output -> unit = - fun env _visitors_this -> - match _visitors_this with - | Output - { - value_defs = _visitors_fvalue_defs; - type_defs = _visitors_ftype_defs; - trait_defs = _visitors_ftrait_defs; - } -> - self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs - _visitors_ftrait_defs + fun env -> + fun _visitors_this -> + match _visitors_this with + | Output + { + value_defs = _visitors_fvalue_defs; + type_defs = _visitors_ftype_defs; + trait_defs = _visitors_ftrait_defs; + trait_alias = _visitors_ftrait_alias; + } -> + self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs + _visitors_ftrait_defs _visitors_ftrait_alias end [@@@VISITORS.END] @@ -5765,1649 +7278,2076 @@ include struct inherit [_] mapbase method visit_stub_decl : _ -> stub_decl -> stub_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_binder env _visitors_this.binder in - let _visitors_r1 = self#visit_params env _visitors_this.params in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_this.ret - in - let _visitors_r3 = - self#visit_stub_body env _visitors_this.func_stubs - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_pub - in - let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in - let _visitors_r6 = - self#visit_fun_decl_kind env _visitors_this.kind_ - in - let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in - let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in - { - binder = _visitors_r0; - params = _visitors_r1; - ret = _visitors_r2; - func_stubs = _visitors_r3; - is_pub = _visitors_r4; - arity_ = _visitors_r5; - kind_ = _visitors_r6; - loc_ = _visitors_r7; - doc_ = _visitors_r8; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_binder env _visitors_this.binder in + let _visitors_r1 = self#visit_params env _visitors_this.params in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_this.ret + in + let _visitors_r3 = + self#visit_stub_body env _visitors_this.func_stubs + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_pub + in + let _visitors_r5 = self#visit_fn_arity env _visitors_this.arity_ in + let _visitors_r6 = + self#visit_fun_decl_kind env _visitors_this.kind_ + in + let _visitors_r7 = self#visit_absolute_loc env _visitors_this.loc_ in + let _visitors_r8 = self#visit_docstring env _visitors_this.doc_ in + { + binder = _visitors_r0; + params = _visitors_r1; + ret = _visitors_r2; + func_stubs = _visitors_r3; + is_pub = _visitors_r4; + arity_ = _visitors_r5; + kind_ = _visitors_r6; + loc_ = _visitors_r7; + doc_ = _visitors_r8; + } method visit_Intrinsic : _ -> stub_body = fun env -> Intrinsic method visit_Func_stub : _ -> func_stubs -> stub_body = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in - Func_stub _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_func_stubs env _visitors_c0 in + Func_stub _visitors_r0 method visit_stub_body : _ -> stub_body -> stub_body = - fun env _visitors_this -> - match _visitors_this with - | Intrinsic -> self#visit_Intrinsic env - | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 - - method visit_Texpr_apply - : _ -> - expr -> - argument list -> - stype -> - apply_kind -> - location -> - expr = - fun env _visitors_ffunc _visitors_fargs _visitors_fty _visitors_fkind_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_apply - { - func = _visitors_r0; - args = _visitors_r1; - ty = _visitors_r2; - kind_ = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_method - : _ -> - var -> - stype array -> - fn_arity option -> - type_name -> - Primitive.prim option -> - stype -> - location -> - expr = - fun env _visitors_fmeth _visitors_fty_args_ _visitors_farity_ - _visitors_ftype_name _visitors_fprim _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fmeth in - let _visitors_r1 = - (fun _visitors_this -> - Basic_arr.map _visitors_this (self#visit_stype env)) - _visitors_fty_args_ - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_fn_arity env) t) - | None -> None) - _visitors_farity_ - in - let _visitors_r3 = self#visit_type_name env _visitors_ftype_name in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_prim env) t) - | None -> None) - _visitors_fprim - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Texpr_method - { - meth = _visitors_r0; - ty_args_ = _visitors_r1; - arity_ = _visitors_r2; - type_name = _visitors_r3; - prim = _visitors_r4; - ty = _visitors_r5; - loc_ = _visitors_r6; - } - - method visit_Texpr_unresolved_method - : _ -> - type_path_loc -> - string -> - stype -> - fn_arity option -> - stype -> - location -> - expr = - fun env _visitors_ftrait_name _visitors_fmethod_name - _visitors_fself_type _visitors_farity_ _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - self#visit_type_path_loc env _visitors_ftrait_name - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fmethod_name - in - let _visitors_r2 = self#visit_stype env _visitors_fself_type in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_fn_arity env) t) - | None -> None) - _visitors_farity_ - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_unresolved_method - { - trait_name = _visitors_r0; - method_name = _visitors_r1; - self_type = _visitors_r2; - arity_ = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_ident - : _ -> - var -> - stype array -> - fn_arity option -> - value_kind -> - stype -> - location -> - expr = - fun env _visitors_fid _visitors_fty_args_ _visitors_farity_ - _visitors_fkind _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fid in - let _visitors_r1 = - (fun _visitors_this -> - Basic_arr.map _visitors_this (self#visit_stype env)) - _visitors_fty_args_ - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_fn_arity env) t) - | None -> None) - _visitors_farity_ - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fkind - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_ident - { - id = _visitors_r0; - ty_args_ = _visitors_r1; - arity_ = _visitors_r2; - kind = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_as - : _ -> expr -> type_name -> stype -> bool -> location -> expr = - fun env _visitors_fexpr _visitors_ftrait _visitors_fty - _visitors_fis_implicit _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_implicit - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_as - { - expr = _visitors_r0; - trait = _visitors_r1; - ty = _visitors_r2; - is_implicit = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_array - : _ -> expr list -> stype -> bool -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_fis_fixed_array - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_fixed_array - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_array - { - exprs = _visitors_r0; - ty = _visitors_r1; - is_fixed_array = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_constant - : _ -> constant -> stype -> var option -> location -> expr = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_var env) t) - | None -> None) - _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_constant - { - c = _visitors_r0; - ty = _visitors_r1; - name_ = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_constr - : _ -> - Syntax.constructor -> - constr_tag -> - stype -> - fn_arity -> - location -> - expr = - fun env _visitors_fconstr _visitors_ftag _visitors_fty _visitors_farity_ - _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_constr - { - constr = _visitors_r0; - tag = _visitors_r1; - ty = _visitors_r2; - arity_ = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_while - : _ -> expr -> expr -> expr option -> stype -> location -> expr = - fun env _visitors_floop_cond _visitors_floop_body _visitors_fwhile_else - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_floop_cond in - let _visitors_r1 = self#visit_expr env _visitors_floop_body in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fwhile_else - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_while - { - loop_cond = _visitors_r0; - loop_body = _visitors_r1; - while_else = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_function : _ -> fn -> stype -> location -> expr = - fun env _visitors_ffunc _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_fn env _visitors_ffunc in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_function - { func = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Texpr_if - : _ -> expr -> expr -> expr option -> stype -> location -> expr = - fun env _visitors_fcond _visitors_fifso _visitors_fifnot _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = self#visit_expr env _visitors_fifso in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fifnot - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_if - { - cond = _visitors_r0; - ifso = _visitors_r1; - ifnot = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_letfn - : _ -> binder -> fn -> expr -> stype -> bool -> location -> expr = - fun env _visitors_fbinder _visitors_ffn _visitors_fbody _visitors_fty - _visitors_fis_rec _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_fn env _visitors_ffn in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fis_rec - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_letfn - { - binder = _visitors_r0; - fn = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - is_rec = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_letrec - : _ -> (binder * fn) list -> expr -> stype -> location -> expr = - fun env _visitors_fbindings _visitors_fbody _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_fn env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbindings - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_letrec - { - bindings = _visitors_r0; - body = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_let - : _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> expr + fun env -> + fun _visitors_this -> + match _visitors_this with + | Intrinsic -> self#visit_Intrinsic env + | Func_stub _visitors_c0 -> self#visit_Func_stub env _visitors_c0 + + method visit_Texpr_apply : + _ -> expr -> argument list -> stype -> apply_kind -> location -> expr = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_let - { - pat = _visitors_r0; - rhs = _visitors_r1; - pat_binders = _visitors_r2; - body = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_sequence - : _ -> expr -> expr -> stype -> location -> expr = - fun env _visitors_fexpr1 _visitors_fexpr2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr1 in - let _visitors_r1 = self#visit_expr env _visitors_fexpr2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_sequence - { - expr1 = _visitors_r0; - expr2 = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_fkind_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_apply_kind env _visitors_fkind_ in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_apply + { + func = _visitors_r0; + args = _visitors_r1; + ty = _visitors_r2; + kind_ = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_method : + _ -> + var -> + stype array -> + fn_arity option -> + type_name -> + Primitive.prim option -> + stype -> + location -> + expr = + fun env -> + fun _visitors_fmeth -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_ftype_name -> + fun _visitors_fprim -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fmeth in + let _visitors_r1 = + (fun _visitors_this -> + Basic_arr.map _visitors_this (self#visit_stype env)) + _visitors_fty_args_ + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_fn_arity env) t) + | None -> None) + _visitors_farity_ + in + let _visitors_r3 = + self#visit_type_name env _visitors_ftype_name + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_prim env) t) + | None -> None) + _visitors_fprim + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + Texpr_method + { + meth = _visitors_r0; + ty_args_ = _visitors_r1; + arity_ = _visitors_r2; + type_name = _visitors_r3; + prim = _visitors_r4; + ty = _visitors_r5; + loc_ = _visitors_r6; + } + + method visit_Texpr_unresolved_method : + _ -> + type_name -> + string -> + stype -> + fn_arity option -> + stype -> + location -> + expr = + fun env -> + fun _visitors_ftrait_name -> + fun _visitors_fmethod_name -> + fun _visitors_fself_type -> + fun _visitors_farity_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_type_name env _visitors_ftrait_name + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fmethod_name + in + let _visitors_r2 = self#visit_stype env _visitors_fself_type in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_fn_arity env) t) + | None -> None) + _visitors_farity_ + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_unresolved_method + { + trait_name = _visitors_r0; + method_name = _visitors_r1; + self_type = _visitors_r2; + arity_ = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_ident : + _ -> + var -> + stype array -> + fn_arity option -> + value_kind -> + stype -> + location -> + expr = + fun env -> + fun _visitors_fid -> + fun _visitors_fty_args_ -> + fun _visitors_farity_ -> + fun _visitors_fkind -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fid in + let _visitors_r1 = + (fun _visitors_this -> + Basic_arr.map _visitors_this (self#visit_stype env)) + _visitors_fty_args_ + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_fn_arity env) t) + | None -> None) + _visitors_farity_ + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fkind + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_ident + { + id = _visitors_r0; + ty_args_ = _visitors_r1; + arity_ = _visitors_r2; + kind = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_as : + _ -> expr -> type_name -> stype -> bool -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_ftrait -> + fun _visitors_fty -> + fun _visitors_fis_implicit -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_implicit + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_as + { + expr = _visitors_r0; + trait = _visitors_r1; + ty = _visitors_r2; + is_implicit = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_array : + _ -> expr list -> stype -> bool -> location -> expr = + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_fis_fixed_array -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_fixed_array + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_array + { + exprs = _visitors_r0; + ty = _visitors_r1; + is_fixed_array = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_constant : + _ -> constant -> stype -> var option -> location -> expr = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_var env) t) + | None -> None) + _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_constant + { + c = _visitors_r0; + ty = _visitors_r1; + name_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_tag -> + stype -> + fn_arity -> + location -> + expr = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_constr + { + type_name = _visitors_r0; + constr = _visitors_r1; + tag = _visitors_r2; + ty = _visitors_r3; + arity_ = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_while : + _ -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + expr = + fun env -> + fun _visitors_floop_cond -> + fun _visitors_floop_body -> + fun _visitors_fwhile_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_floop_cond in + let _visitors_r1 = self#visit_expr env _visitors_floop_body in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fwhile_else + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_loop_label_binder env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_while + { + loop_cond = _visitors_r0; + loop_body = _visitors_r1; + while_else = _visitors_r2; + ty = _visitors_r3; + label = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_function : _ -> fn -> stype -> bool -> location -> expr + = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fty -> + fun _visitors_fis_raw_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_fn env _visitors_ffunc in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_raw_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_function + { + func = _visitors_r0; + ty = _visitors_r1; + is_raw_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_if : + _ -> expr -> expr -> expr option -> stype -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fifso -> + fun _visitors_fifnot -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = self#visit_expr env _visitors_fifso in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fifnot + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_if + { + cond = _visitors_r0; + ifso = _visitors_r1; + ifnot = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_letfn : + _ -> binder -> fn -> expr -> stype -> bool -> location -> expr = + fun env -> + fun _visitors_fbinder -> + fun _visitors_ffn -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_fis_rec -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_fn env _visitors_ffn in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fis_rec + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_letfn + { + binder = _visitors_r0; + fn = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + is_rec = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_letrec : + _ -> (binder * fn) list -> expr -> stype -> location -> expr = + fun env -> + fun _visitors_fbindings -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_binder env _visitors_c0 in + let _visitors_r1 = self#visit_fn env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fbindings + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_letrec + { + bindings = _visitors_r0; + body = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_let : + _ -> pat -> expr -> pat_binders -> expr -> stype -> location -> expr = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_let + { + pat = _visitors_r0; + rhs = _visitors_r1; + pat_binders = _visitors_r2; + body = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_sequence : + _ -> expr list -> expr -> stype -> location -> expr = + fun env -> + fun _visitors_fexprs -> + fun _visitors_flast_expr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_expr env _visitors_flast_expr in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_sequence + { + exprs = _visitors_r0; + last_expr = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Texpr_tuple : _ -> expr list -> stype -> location -> expr = - fun env _visitors_fexprs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fexprs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_tuple - { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Texpr_record - : _ -> type_name option -> field_def list -> stype -> location -> expr + fun env -> + fun _visitors_fexprs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fexprs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_tuple + { exprs = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Texpr_record : + _ -> type_name option -> field_def list -> stype -> location -> expr = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_record + { + type_name = _visitors_r0; + fields = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_record_update : + _ -> + type_name option -> + expr -> + field_info list -> + field_def list -> + stype -> + location -> + expr = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_frecord -> + fun _visitors_fall_fields -> + fun _visitors_ffields -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = self#visit_expr env _visitors_frecord in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_info env)) + _visitors_fall_fields + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_def env)) + _visitors_ffields + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_record_update + { + type_name = _visitors_r0; + record = _visitors_r1; + all_fields = _visitors_r2; + fields = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_field : + _ -> expr -> Syntax.accessor -> int -> stype -> location -> expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_faccessor -> + fun _visitors_fpos -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_accessor env _visitors_faccessor in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_field + { + record = _visitors_r0; + accessor = _visitors_r1; + pos = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_mutate : + _ -> + expr -> + Syntax.label -> + expr -> + int -> + expr option -> + stype -> + location -> + expr = + fun env -> + fun _visitors_frecord -> + fun _visitors_flabel -> + fun _visitors_ffield -> + fun _visitors_fpos -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_frecord in + let _visitors_r1 = self#visit_label env _visitors_flabel in + let _visitors_r2 = self#visit_expr env _visitors_ffield in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_faugmented_by + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + Texpr_mutate + { + record = _visitors_r0; + label = _visitors_r1; + field = _visitors_r2; + pos = _visitors_r3; + augmented_by = _visitors_r4; + ty = _visitors_r5; + loc_ = _visitors_r6; + } + + method visit_Texpr_match : + _ -> expr -> match_case list -> stype -> location -> location -> expr + = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fcases -> + fun _visitors_fty -> + fun _visitors_fmatch_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_match_case env)) + _visitors_fcases + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + self#visit_location env _visitors_fmatch_loc_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_match + { + expr = _visitors_r0; + cases = _visitors_r1; + ty = _visitors_r2; + match_loc_ = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_letmut : + _ -> binder -> typ option -> expr -> expr -> stype -> location -> expr = - fun env _visitors_ftype_name _visitors_ffields _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_ftype_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_record - { - type_name = _visitors_r0; - fields = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_record_update - : _ -> - type_name option -> - expr -> - field_info list -> - field_def list -> - stype -> - location -> - expr = - fun env _visitors_ftype_name _visitors_frecord _visitors_fall_fields - _visitors_ffields _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_ftype_name - in - let _visitors_r1 = self#visit_expr env _visitors_frecord in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_info env)) - _visitors_fall_fields - in - let _visitors_r3 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_def env)) - _visitors_ffields - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_record_update - { - type_name = _visitors_r0; - record = _visitors_r1; - all_fields = _visitors_r2; - fields = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_field - : _ -> expr -> Syntax.accessor -> int -> stype -> location -> expr = - fun env _visitors_frecord _visitors_faccessor _visitors_fpos - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_accessor env _visitors_faccessor in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_field - { - record = _visitors_r0; - accessor = _visitors_r1; - pos = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_mutate - : _ -> - expr -> - Syntax.label -> - expr -> - int -> - expr option -> - stype -> - location -> - expr = - fun env _visitors_frecord _visitors_flabel _visitors_ffield - _visitors_fpos _visitors_faugmented_by _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_frecord in - let _visitors_r1 = self#visit_label env _visitors_flabel in - let _visitors_r2 = self#visit_expr env _visitors_ffield in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_faugmented_by - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Texpr_mutate - { - record = _visitors_r0; - label = _visitors_r1; - field = _visitors_r2; - pos = _visitors_r3; - augmented_by = _visitors_r4; - ty = _visitors_r5; - loc_ = _visitors_r6; - } - - method visit_Texpr_match - : _ -> - expr -> - match_case list -> - stype -> - location -> - location -> - expr = - fun env _visitors_fexpr _visitors_fcases _visitors_fty - _visitors_fmatch_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_match_case env)) - _visitors_fcases - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_fmatch_loc_ in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_match - { - expr = _visitors_r0; - cases = _visitors_r1; - ty = _visitors_r2; - match_loc_ = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_letmut - : _ -> - binder -> - typ option -> - expr -> - expr -> - stype -> - location -> - expr = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Texpr_letmut - { - binder = _visitors_r0; - konstraint = _visitors_r1; - expr = _visitors_r2; - body = _visitors_r3; - ty = _visitors_r4; - loc_ = _visitors_r5; - } - - method visit_Texpr_assign - : _ -> var -> expr -> expr option -> stype -> location -> expr = - fun env _visitors_fvar _visitors_fexpr _visitors_faugmented_by - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_var env _visitors_fvar in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_faugmented_by - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_assign - { - var = _visitors_r0; - expr = _visitors_r1; - augmented_by = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_letmut + { + binder = _visitors_r0; + konstraint = _visitors_r1; + expr = _visitors_r2; + body = _visitors_r3; + ty = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_assign : + _ -> var -> expr -> expr option -> stype -> location -> expr = + fun env -> + fun _visitors_fvar -> + fun _visitors_fexpr -> + fun _visitors_faugmented_by -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_var env _visitors_fvar in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_faugmented_by + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_assign + { + var = _visitors_r0; + expr = _visitors_r1; + augmented_by = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } method visit_Texpr_hole : _ -> stype -> location -> syntax_hole -> expr = - fun env _visitors_fty _visitors_floc_ _visitors_fkind -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in - Texpr_hole - { ty = _visitors_r0; loc_ = _visitors_r1; kind = _visitors_r2 } + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + let _visitors_r2 = self#visit_syntax_hole env _visitors_fkind in + Texpr_hole + { ty = _visitors_r0; loc_ = _visitors_r1; kind = _visitors_r2 } method visit_Texpr_unit : _ -> location -> expr = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - Texpr_unit { loc_ = _visitors_r0 } - - method visit_Texpr_break : _ -> expr option -> stype -> location -> expr = - fun env _visitors_farg _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_farg - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_break - { arg = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Texpr_continue : _ -> expr list -> stype -> location -> expr - = - fun env _visitors_fargs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_continue - { args = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Texpr_loop - : _ -> param list -> expr -> expr list -> stype -> location -> expr = - fun env _visitors_fparams _visitors_fbody _visitors_fargs _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_expr env _visitors_fbody in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_expr env)) - _visitors_fargs - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_loop - { - params = _visitors_r0; - body = _visitors_r1; - args = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_for - : _ -> - (binder * expr) list -> - expr option -> - (var * expr) list -> - expr -> - expr option -> - stype -> - location -> - expr = - fun env _visitors_fbinders _visitors_fcondition _visitors_fsteps - _visitors_fbody _visitors_ffor_else _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fcondition - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_var env _visitors_c0 in - let _visitors_r1 = self#visit_expr env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_fsteps - in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_ffor_else - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Texpr_for - { - binders = _visitors_r0; - condition = _visitors_r1; - steps = _visitors_r2; - body = _visitors_r3; - for_else = _visitors_r4; - ty = _visitors_r5; - loc_ = _visitors_r6; - } - - method visit_Texpr_foreach - : _ -> - binder option list -> - stype list -> - expr -> - expr -> - expr option -> - stype -> - location -> - expr = - fun env _visitors_fbinders _visitors_felem_tys _visitors_fexpr - _visitors_fbody _visitors_felse_block _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun _visitors_this -> + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + Texpr_unit { loc_ = _visitors_r0 } + + method visit_Texpr_break : + _ -> expr option -> stype -> loop_label option -> location -> expr = + fun env -> + fun _visitors_farg -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_farg + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> match _visitors_this with - | Some t -> Some ((self#visit_binder env) t) - | None -> None)) - _visitors_fbinders - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_stype env)) - _visitors_felem_tys - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = self#visit_expr env _visitors_fbody in - let _visitors_r4 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_felse_block - in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Texpr_foreach - { - binders = _visitors_r0; - elem_tys = _visitors_r1; - expr = _visitors_r2; - body = _visitors_r3; - else_block = _visitors_r4; - ty = _visitors_r5; - loc_ = _visitors_r6; - } + | Some t -> Some ((self#visit_loop_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_break + { + arg = _visitors_r0; + ty = _visitors_r1; + label = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_continue : + _ -> expr list -> stype -> loop_label option -> location -> expr = + fun env -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_loop_label env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_continue + { + args = _visitors_r0; + ty = _visitors_r1; + label = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_loop : + _ -> + param list -> + expr -> + expr list -> + stype -> + loop_label_binder option -> + location -> + expr = + fun env -> + fun _visitors_fparams -> + fun _visitors_fbody -> + fun _visitors_fargs -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_expr env _visitors_fbody in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_expr env)) + _visitors_fargs + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_loop_label_binder env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r5 = self#visit_location env _visitors_floc_ in + Texpr_loop + { + params = _visitors_r0; + body = _visitors_r1; + args = _visitors_r2; + ty = _visitors_r3; + label = _visitors_r4; + loc_ = _visitors_r5; + } + + method visit_Texpr_for : + _ -> + (binder * expr) list -> + expr option -> + (var * expr) list -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + expr = + fun env -> + fun _visitors_fbinders -> + fun _visitors_fcondition -> + fun _visitors_fsteps -> + fun _visitors_fbody -> + fun _visitors_ffor_else -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fcondition + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_var env _visitors_c0 in + let _visitors_r1 = self#visit_expr env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_fsteps + in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_ffor_else + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_loop_label_binder env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + Texpr_for + { + binders = _visitors_r0; + condition = _visitors_r1; + steps = _visitors_r2; + body = _visitors_r3; + for_else = _visitors_r4; + ty = _visitors_r5; + label = _visitors_r6; + loc_ = _visitors_r7; + } + + method visit_Texpr_foreach : + _ -> + binder option list -> + stype list -> + expr -> + expr -> + expr option -> + stype -> + loop_label_binder option -> + location -> + expr = + fun env -> + fun _visitors_fbinders -> + fun _visitors_felem_tys -> + fun _visitors_fexpr -> + fun _visitors_fbody -> + fun _visitors_felse_block -> + fun _visitors_fty -> + fun _visitors_flabel -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_binder env) t) + | None -> None)) + _visitors_fbinders + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_stype env)) + _visitors_felem_tys + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = self#visit_expr env _visitors_fbody in + let _visitors_r4 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_felse_block + in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_loop_label_binder env) t) + | None -> None) + _visitors_flabel + in + let _visitors_r7 = self#visit_location env _visitors_floc_ in + Texpr_foreach + { + binders = _visitors_r0; + elem_tys = _visitors_r1; + expr = _visitors_r2; + body = _visitors_r3; + else_block = _visitors_r4; + ty = _visitors_r5; + label = _visitors_r6; + loc_ = _visitors_r7; + } method visit_Texpr_return : _ -> expr option -> stype -> location -> expr = - fun env _visitors_freturn_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_freturn_value - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_return - { - return_value = _visitors_r0; - ty = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_freturn_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_freturn_value + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_return + { + return_value = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } method visit_Texpr_raise : _ -> expr -> stype -> location -> expr = - fun env _visitors_ferror_value _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ferror_value in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_raise - { - error_value = _visitors_r0; - ty = _visitors_r1; - loc_ = _visitors_r2; - } - - method visit_Texpr_try - : _ -> - expr -> - match_case list -> - bool -> - match_case list option -> - stype -> - stype -> - location -> - location -> - location -> - expr = - fun env _visitors_fbody _visitors_fcatch _visitors_fcatch_all - _visitors_ftry_else _visitors_fty _visitors_ferr_ty - _visitors_fcatch_loc_ _visitors_felse_loc_ _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fbody in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_match_case env)) - _visitors_fcatch - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fcatch_all - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_match_case env)) - t) - | None -> None) - _visitors_ftry_else - in - let _visitors_r4 = self#visit_stype env _visitors_fty in - let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in - let _visitors_r6 = self#visit_location env _visitors_fcatch_loc_ in - let _visitors_r7 = self#visit_location env _visitors_felse_loc_ in - let _visitors_r8 = self#visit_location env _visitors_floc_ in - Texpr_try - { - body = _visitors_r0; - catch = _visitors_r1; - catch_all = _visitors_r2; - try_else = _visitors_r3; - ty = _visitors_r4; - err_ty = _visitors_r5; - catch_loc_ = _visitors_r6; - else_loc_ = _visitors_r7; - loc_ = _visitors_r8; - } - - method visit_Texpr_exclamation - : _ -> expr -> stype -> bool -> location -> expr = - fun env _visitors_fexpr _visitors_fty _visitors_fconvert_to_result - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fconvert_to_result - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_exclamation - { - expr = _visitors_r0; - ty = _visitors_r1; - convert_to_result = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_constraint - : _ -> expr -> typ -> stype -> location -> expr = - fun env _visitors_fexpr _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_constraint - { - expr = _visitors_r0; - konstraint = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_pipe - : _ -> expr -> pipe_rhs -> stype -> location -> expr = - fun env _visitors_flhs _visitors_frhs _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_flhs in - let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Texpr_pipe - { - lhs = _visitors_r0; - rhs = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Texpr_interp - : _ -> interp_elem list -> stype -> location -> expr = - fun env _visitors_felems _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_interp_elem env)) - _visitors_felems - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Texpr_interp - { elems = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Texpr_guard - : _ -> expr -> expr option -> expr -> stype -> location -> expr = - fun env _visitors_fcond _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fcond in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_expr env) t) - | None -> None) - _visitors_fotherwise - in - let _visitors_r2 = self#visit_expr env _visitors_fbody in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Texpr_guard - { - cond = _visitors_r0; - otherwise = _visitors_r1; - body = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } - - method visit_Texpr_guard_let - : _ -> - pat -> - expr -> - pat_binders -> - match_case list option -> - expr -> - stype -> - location -> - expr = - fun env _visitors_fpat _visitors_frhs _visitors_fpat_binders - _visitors_fotherwise _visitors_fbody _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_expr env _visitors_frhs in - let _visitors_r2 = - self#visit_pat_binders env _visitors_fpat_binders - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun _visitors_this -> + fun env -> + fun _visitors_ferror_value -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ferror_value in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_raise + { + error_value = _visitors_r0; + ty = _visitors_r1; + loc_ = _visitors_r2; + } + + method visit_Texpr_try : + _ -> + expr -> + match_case list -> + bool -> + match_case list option -> + stype -> + stype -> + location -> + location -> + location -> + expr = + fun env -> + fun _visitors_fbody -> + fun _visitors_fcatch -> + fun _visitors_fcatch_all -> + fun _visitors_ftry_else -> + fun _visitors_fty -> + fun _visitors_ferr_ty -> + fun _visitors_fcatch_loc_ -> + fun _visitors_felse_loc_ -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fbody in + let _visitors_r1 = + (fun _visitors_this -> Basic_lst.map _visitors_this (self#visit_match_case env)) - t) - | None -> None) - _visitors_fotherwise - in - let _visitors_r4 = self#visit_expr env _visitors_fbody in - let _visitors_r5 = self#visit_stype env _visitors_fty in - let _visitors_r6 = self#visit_location env _visitors_floc_ in - Texpr_guard_let - { - pat = _visitors_r0; - rhs = _visitors_r1; - pat_binders = _visitors_r2; - otherwise = _visitors_r3; - body = _visitors_r4; - ty = _visitors_r5; - loc_ = _visitors_r6; - } + _visitors_fcatch + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fcatch_all + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_match_case env)) + t) + | None -> None) + _visitors_ftry_else + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = self#visit_stype env _visitors_ferr_ty in + let _visitors_r6 = + self#visit_location env _visitors_fcatch_loc_ + in + let _visitors_r7 = + self#visit_location env _visitors_felse_loc_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + Texpr_try + { + body = _visitors_r0; + catch = _visitors_r1; + catch_all = _visitors_r2; + try_else = _visitors_r3; + ty = _visitors_r4; + err_ty = _visitors_r5; + catch_loc_ = _visitors_r6; + else_loc_ = _visitors_r7; + loc_ = _visitors_r8; + } + + method visit_Texpr_exclamation : + _ -> expr -> stype -> bool -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_fconvert_to_result -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) + _visitors_fconvert_to_result + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_exclamation + { + expr = _visitors_r0; + ty = _visitors_r1; + convert_to_result = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_constraint : + _ -> expr -> typ -> stype -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_constraint + { + expr = _visitors_r0; + konstraint = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_pipe : + _ -> expr -> pipe_rhs -> stype -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_pipe_rhs env _visitors_frhs in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_pipe + { + lhs = _visitors_r0; + rhs = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_interp : + _ -> interp_elem list -> stype -> location -> expr = + fun env -> + fun _visitors_felems -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_interp_elem env)) + _visitors_felems + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_interp + { elems = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Texpr_guard : + _ -> expr -> expr option -> expr -> stype -> location -> expr = + fun env -> + fun _visitors_fcond -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fcond in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_fotherwise + in + let _visitors_r2 = self#visit_expr env _visitors_fbody in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Texpr_guard + { + cond = _visitors_r0; + otherwise = _visitors_r1; + body = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Texpr_guard_let : + _ -> + pat -> + expr -> + pat_binders -> + match_case list option -> + expr -> + stype -> + location -> + expr = + fun env -> + fun _visitors_fpat -> + fun _visitors_frhs -> + fun _visitors_fpat_binders -> + fun _visitors_fotherwise -> + fun _visitors_fbody -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun _visitors_this -> + Basic_lst.map _visitors_this + (self#visit_match_case env)) + t) + | None -> None) + _visitors_fotherwise + in + let _visitors_r4 = self#visit_expr env _visitors_fbody in + let _visitors_r5 = self#visit_stype env _visitors_fty in + let _visitors_r6 = self#visit_location env _visitors_floc_ in + Texpr_guard_let + { + pat = _visitors_r0; + rhs = _visitors_r1; + pat_binders = _visitors_r2; + otherwise = _visitors_r3; + body = _visitors_r4; + ty = _visitors_r5; + loc_ = _visitors_r6; + } + + method visit_Texpr_is : + _ -> expr -> pat -> pat_binders -> location -> expr = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fpat -> + fun _visitors_fpat_binders -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = + self#visit_pat_binders env _visitors_fpat_binders + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Texpr_is + { + expr = _visitors_r0; + pat = _visitors_r1; + pat_binders = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Texpr_array_as_view : _ -> expr -> stype -> location -> expr + = + fun env -> + fun _visitors_farray -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_farray in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_array_as_view + { array = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Texpr_and : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_and + { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Texpr_or : _ -> expr -> expr -> location -> expr = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_flhs in + let _visitors_r1 = self#visit_expr env _visitors_frhs in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Texpr_or + { lhs = _visitors_r0; rhs = _visitors_r1; loc_ = _visitors_r2 } method visit_expr : _ -> expr -> expr = - fun env _visitors_this -> - match _visitors_this with - | Texpr_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - ty = _visitors_fty; - kind_ = _visitors_fkind_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs - _visitors_fty _visitors_fkind_ _visitors_floc_ - | Texpr_method - { - meth = _visitors_fmeth; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - type_name = _visitors_ftype_name; - prim = _visitors_fprim; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ - _visitors_farity_ _visitors_ftype_name _visitors_fprim - _visitors_fty _visitors_floc_ - | Texpr_unresolved_method - { - trait_name = _visitors_ftrait_name; - method_name = _visitors_fmethod_name; - self_type = _visitors_fself_type; - arity_ = _visitors_farity_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_unresolved_method env _visitors_ftrait_name - _visitors_fmethod_name _visitors_fself_type _visitors_farity_ - _visitors_fty _visitors_floc_ - | Texpr_ident - { - id = _visitors_fid; - ty_args_ = _visitors_fty_args_; - arity_ = _visitors_farity_; - kind = _visitors_fkind; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ - _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ - | Texpr_as - { - expr = _visitors_fexpr; - trait = _visitors_ftrait; - ty = _visitors_fty; - is_implicit = _visitors_fis_implicit; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait - _visitors_fty _visitors_fis_implicit _visitors_floc_ - | Texpr_array - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - is_fixed_array = _visitors_fis_fixed_array; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_array env _visitors_fexprs _visitors_fty - _visitors_fis_fixed_array _visitors_floc_ - | Texpr_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Texpr_constr - { - constr = _visitors_fconstr; - tag = _visitors_ftag; - ty = _visitors_fty; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constr env _visitors_fconstr _visitors_ftag - _visitors_fty _visitors_farity_ _visitors_floc_ - | Texpr_while - { - loop_cond = _visitors_floop_cond; - loop_body = _visitors_floop_body; - while_else = _visitors_fwhile_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_while env _visitors_floop_cond - _visitors_floop_body _visitors_fwhile_else _visitors_fty - _visitors_floc_ - | Texpr_function - { - func = _visitors_ffunc; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_function env _visitors_ffunc _visitors_fty - _visitors_floc_ - | Texpr_if - { - cond = _visitors_fcond; - ifso = _visitors_fifso; - ifnot = _visitors_fifnot; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_if env _visitors_fcond _visitors_fifso - _visitors_fifnot _visitors_fty _visitors_floc_ - | Texpr_letfn - { - binder = _visitors_fbinder; - fn = _visitors_ffn; - body = _visitors_fbody; - ty = _visitors_fty; - is_rec = _visitors_fis_rec; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn - _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ - | Texpr_letrec - { - bindings = _visitors_fbindings; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fbody _visitors_fty - _visitors_floc_ - | Texpr_sequence - { - expr1 = _visitors_fexpr1; - expr2 = _visitors_fexpr2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_sequence env _visitors_fexpr1 _visitors_fexpr2 - _visitors_fty _visitors_floc_ - | Texpr_tuple - { - exprs = _visitors_fexprs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty - _visitors_floc_ - | Texpr_record - { - type_name = _visitors_ftype_name; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record env _visitors_ftype_name _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_record_update - { - type_name = _visitors_ftype_name; - record = _visitors_frecord; - all_fields = _visitors_fall_fields; - fields = _visitors_ffields; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_record_update env _visitors_ftype_name - _visitors_frecord _visitors_fall_fields _visitors_ffields - _visitors_fty _visitors_floc_ - | Texpr_field - { - record = _visitors_frecord; - accessor = _visitors_faccessor; - pos = _visitors_fpos; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_field env _visitors_frecord _visitors_faccessor - _visitors_fpos _visitors_fty _visitors_floc_ - | Texpr_mutate - { - record = _visitors_frecord; - label = _visitors_flabel; - field = _visitors_ffield; - pos = _visitors_fpos; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel - _visitors_ffield _visitors_fpos _visitors_faugmented_by - _visitors_fty _visitors_floc_ - | Texpr_match - { - expr = _visitors_fexpr; - cases = _visitors_fcases; - ty = _visitors_fty; - match_loc_ = _visitors_fmatch_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_match env _visitors_fexpr _visitors_fcases - _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ - | Texpr_letmut - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_letmut env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fbody - _visitors_fty _visitors_floc_ - | Texpr_assign - { - var = _visitors_fvar; - expr = _visitors_fexpr; - augmented_by = _visitors_faugmented_by; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr - _visitors_faugmented_by _visitors_fty _visitors_floc_ - | Texpr_hole - { - ty = _visitors_fty; - loc_ = _visitors_floc_; - kind = _visitors_fkind; - } -> - self#visit_Texpr_hole env _visitors_fty _visitors_floc_ - _visitors_fkind - | Texpr_unit { loc_ = _visitors_floc_ } -> - self#visit_Texpr_unit env _visitors_floc_ - | Texpr_break - { - arg = _visitors_farg; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_break env _visitors_farg _visitors_fty - _visitors_floc_ - | Texpr_continue - { - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_continue env _visitors_fargs _visitors_fty - _visitors_floc_ - | Texpr_loop - { - params = _visitors_fparams; - body = _visitors_fbody; - args = _visitors_fargs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_loop env _visitors_fparams _visitors_fbody - _visitors_fargs _visitors_fty _visitors_floc_ - | Texpr_for - { - binders = _visitors_fbinders; - condition = _visitors_fcondition; - steps = _visitors_fsteps; - body = _visitors_fbody; - for_else = _visitors_ffor_else; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition - _visitors_fsteps _visitors_fbody _visitors_ffor_else - _visitors_fty _visitors_floc_ - | Texpr_foreach - { - binders = _visitors_fbinders; - elem_tys = _visitors_felem_tys; - expr = _visitors_fexpr; - body = _visitors_fbody; - else_block = _visitors_felse_block; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_foreach env _visitors_fbinders - _visitors_felem_tys _visitors_fexpr _visitors_fbody - _visitors_felse_block _visitors_fty _visitors_floc_ - | Texpr_return - { - return_value = _visitors_freturn_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_return env _visitors_freturn_value _visitors_fty - _visitors_floc_ - | Texpr_raise - { - error_value = _visitors_ferror_value; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty - _visitors_floc_ - | Texpr_try - { - body = _visitors_fbody; - catch = _visitors_fcatch; - catch_all = _visitors_fcatch_all; - try_else = _visitors_ftry_else; - ty = _visitors_fty; - err_ty = _visitors_ferr_ty; - catch_loc_ = _visitors_fcatch_loc_; - else_loc_ = _visitors_felse_loc_; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_try env _visitors_fbody _visitors_fcatch - _visitors_fcatch_all _visitors_ftry_else _visitors_fty - _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ - _visitors_floc_ - | Texpr_exclamation - { - expr = _visitors_fexpr; - ty = _visitors_fty; - convert_to_result = _visitors_fconvert_to_result; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty - _visitors_fconvert_to_result _visitors_floc_ - | Texpr_constraint - { - expr = _visitors_fexpr; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_constraint env _visitors_fexpr - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Texpr_pipe - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs - _visitors_fty _visitors_floc_ - | Texpr_interp - { - elems = _visitors_felems; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_interp env _visitors_felems _visitors_fty - _visitors_floc_ - | Texpr_guard - { - cond = _visitors_fcond; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise - _visitors_fbody _visitors_fty _visitors_floc_ - | Texpr_guard_let - { - pat = _visitors_fpat; - rhs = _visitors_frhs; - pat_binders = _visitors_fpat_binders; - otherwise = _visitors_fotherwise; - body = _visitors_fbody; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs - _visitors_fpat_binders _visitors_fotherwise _visitors_fbody - _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Texpr_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + ty = _visitors_fty; + kind_ = _visitors_fkind_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_apply env _visitors_ffunc _visitors_fargs + _visitors_fty _visitors_fkind_ _visitors_floc_ + | Texpr_method + { + meth = _visitors_fmeth; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + type_name = _visitors_ftype_name; + prim = _visitors_fprim; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_method env _visitors_fmeth _visitors_fty_args_ + _visitors_farity_ _visitors_ftype_name _visitors_fprim + _visitors_fty _visitors_floc_ + | Texpr_unresolved_method + { + trait_name = _visitors_ftrait_name; + method_name = _visitors_fmethod_name; + self_type = _visitors_fself_type; + arity_ = _visitors_farity_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_unresolved_method env _visitors_ftrait_name + _visitors_fmethod_name _visitors_fself_type _visitors_farity_ + _visitors_fty _visitors_floc_ + | Texpr_ident + { + id = _visitors_fid; + ty_args_ = _visitors_fty_args_; + arity_ = _visitors_farity_; + kind = _visitors_fkind; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_ident env _visitors_fid _visitors_fty_args_ + _visitors_farity_ _visitors_fkind _visitors_fty _visitors_floc_ + | Texpr_as + { + expr = _visitors_fexpr; + trait = _visitors_ftrait; + ty = _visitors_fty; + is_implicit = _visitors_fis_implicit; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_as env _visitors_fexpr _visitors_ftrait + _visitors_fty _visitors_fis_implicit _visitors_floc_ + | Texpr_array + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + is_fixed_array = _visitors_fis_fixed_array; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array env _visitors_fexprs _visitors_fty + _visitors_fis_fixed_array _visitors_floc_ + | Texpr_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Texpr_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + tag = _visitors_ftag; + ty = _visitors_fty; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constr env _visitors_ftype_name + _visitors_fconstr _visitors_ftag _visitors_fty + _visitors_farity_ _visitors_floc_ + | Texpr_while + { + loop_cond = _visitors_floop_cond; + loop_body = _visitors_floop_body; + while_else = _visitors_fwhile_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_while env _visitors_floop_cond + _visitors_floop_body _visitors_fwhile_else _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_function + { + func = _visitors_ffunc; + ty = _visitors_fty; + is_raw_ = _visitors_fis_raw_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_function env _visitors_ffunc _visitors_fty + _visitors_fis_raw_ _visitors_floc_ + | Texpr_if + { + cond = _visitors_fcond; + ifso = _visitors_fifso; + ifnot = _visitors_fifnot; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_if env _visitors_fcond _visitors_fifso + _visitors_fifnot _visitors_fty _visitors_floc_ + | Texpr_letfn + { + binder = _visitors_fbinder; + fn = _visitors_ffn; + body = _visitors_fbody; + ty = _visitors_fty; + is_rec = _visitors_fis_rec; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letfn env _visitors_fbinder _visitors_ffn + _visitors_fbody _visitors_fty _visitors_fis_rec _visitors_floc_ + | Texpr_letrec + { + bindings = _visitors_fbindings; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letrec env _visitors_fbindings _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fbody _visitors_fty + _visitors_floc_ + | Texpr_sequence + { + exprs = _visitors_fexprs; + last_expr = _visitors_flast_expr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_sequence env _visitors_fexprs + _visitors_flast_expr _visitors_fty _visitors_floc_ + | Texpr_tuple + { + exprs = _visitors_fexprs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_tuple env _visitors_fexprs _visitors_fty + _visitors_floc_ + | Texpr_record + { + type_name = _visitors_ftype_name; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record env _visitors_ftype_name + _visitors_ffields _visitors_fty _visitors_floc_ + | Texpr_record_update + { + type_name = _visitors_ftype_name; + record = _visitors_frecord; + all_fields = _visitors_fall_fields; + fields = _visitors_ffields; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_record_update env _visitors_ftype_name + _visitors_frecord _visitors_fall_fields _visitors_ffields + _visitors_fty _visitors_floc_ + | Texpr_field + { + record = _visitors_frecord; + accessor = _visitors_faccessor; + pos = _visitors_fpos; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_field env _visitors_frecord _visitors_faccessor + _visitors_fpos _visitors_fty _visitors_floc_ + | Texpr_mutate + { + record = _visitors_frecord; + label = _visitors_flabel; + field = _visitors_ffield; + pos = _visitors_fpos; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_mutate env _visitors_frecord _visitors_flabel + _visitors_ffield _visitors_fpos _visitors_faugmented_by + _visitors_fty _visitors_floc_ + | Texpr_match + { + expr = _visitors_fexpr; + cases = _visitors_fcases; + ty = _visitors_fty; + match_loc_ = _visitors_fmatch_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_match env _visitors_fexpr _visitors_fcases + _visitors_fty _visitors_fmatch_loc_ _visitors_floc_ + | Texpr_letmut + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_letmut env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_assign + { + var = _visitors_fvar; + expr = _visitors_fexpr; + augmented_by = _visitors_faugmented_by; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_assign env _visitors_fvar _visitors_fexpr + _visitors_faugmented_by _visitors_fty _visitors_floc_ + | Texpr_hole + { + ty = _visitors_fty; + loc_ = _visitors_floc_; + kind = _visitors_fkind; + } -> + self#visit_Texpr_hole env _visitors_fty _visitors_floc_ + _visitors_fkind + | Texpr_unit { loc_ = _visitors_floc_ } -> + self#visit_Texpr_unit env _visitors_floc_ + | Texpr_break + { + arg = _visitors_farg; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_break env _visitors_farg _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_continue + { + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_continue env _visitors_fargs _visitors_fty + _visitors_flabel _visitors_floc_ + | Texpr_loop + { + params = _visitors_fparams; + body = _visitors_fbody; + args = _visitors_fargs; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_loop env _visitors_fparams _visitors_fbody + _visitors_fargs _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_for + { + binders = _visitors_fbinders; + condition = _visitors_fcondition; + steps = _visitors_fsteps; + body = _visitors_fbody; + for_else = _visitors_ffor_else; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_for env _visitors_fbinders _visitors_fcondition + _visitors_fsteps _visitors_fbody _visitors_ffor_else + _visitors_fty _visitors_flabel _visitors_floc_ + | Texpr_foreach + { + binders = _visitors_fbinders; + elem_tys = _visitors_felem_tys; + expr = _visitors_fexpr; + body = _visitors_fbody; + else_block = _visitors_felse_block; + ty = _visitors_fty; + label = _visitors_flabel; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_foreach env _visitors_fbinders + _visitors_felem_tys _visitors_fexpr _visitors_fbody + _visitors_felse_block _visitors_fty _visitors_flabel + _visitors_floc_ + | Texpr_return + { + return_value = _visitors_freturn_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_return env _visitors_freturn_value _visitors_fty + _visitors_floc_ + | Texpr_raise + { + error_value = _visitors_ferror_value; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_raise env _visitors_ferror_value _visitors_fty + _visitors_floc_ + | Texpr_try + { + body = _visitors_fbody; + catch = _visitors_fcatch; + catch_all = _visitors_fcatch_all; + try_else = _visitors_ftry_else; + ty = _visitors_fty; + err_ty = _visitors_ferr_ty; + catch_loc_ = _visitors_fcatch_loc_; + else_loc_ = _visitors_felse_loc_; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_try env _visitors_fbody _visitors_fcatch + _visitors_fcatch_all _visitors_ftry_else _visitors_fty + _visitors_ferr_ty _visitors_fcatch_loc_ _visitors_felse_loc_ + _visitors_floc_ + | Texpr_exclamation + { + expr = _visitors_fexpr; + ty = _visitors_fty; + convert_to_result = _visitors_fconvert_to_result; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_exclamation env _visitors_fexpr _visitors_fty + _visitors_fconvert_to_result _visitors_floc_ + | Texpr_constraint + { + expr = _visitors_fexpr; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_constraint env _visitors_fexpr + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Texpr_pipe + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_pipe env _visitors_flhs _visitors_frhs + _visitors_fty _visitors_floc_ + | Texpr_interp + { + elems = _visitors_felems; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_interp env _visitors_felems _visitors_fty + _visitors_floc_ + | Texpr_guard + { + cond = _visitors_fcond; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard env _visitors_fcond _visitors_fotherwise + _visitors_fbody _visitors_fty _visitors_floc_ + | Texpr_guard_let + { + pat = _visitors_fpat; + rhs = _visitors_frhs; + pat_binders = _visitors_fpat_binders; + otherwise = _visitors_fotherwise; + body = _visitors_fbody; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_guard_let env _visitors_fpat _visitors_frhs + _visitors_fpat_binders _visitors_fotherwise _visitors_fbody + _visitors_fty _visitors_floc_ + | Texpr_is + { + expr = _visitors_fexpr; + pat = _visitors_fpat; + pat_binders = _visitors_fpat_binders; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_is env _visitors_fexpr _visitors_fpat + _visitors_fpat_binders _visitors_floc_ + | Texpr_array_as_view + { + array = _visitors_farray; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_array_as_view env _visitors_farray _visitors_fty + _visitors_floc_ + | Texpr_and + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_and env _visitors_flhs _visitors_frhs + _visitors_floc_ + | Texpr_or + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + loc_ = _visitors_floc_; + } -> + self#visit_Texpr_or env _visitors_flhs _visitors_frhs + _visitors_floc_ method visit_argument : _ -> argument -> argument = - fun env _visitors_this -> - let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in - let _visitors_r1 = - self#visit_argument_kind env _visitors_this.arg_kind - in - { arg_value = _visitors_r0; arg_kind = _visitors_r1 } - - method visit_Pipe_partial_apply - : _ -> expr -> argument list -> location -> pipe_rhs = - fun env _visitors_ffunc _visitors_fargs _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_ffunc in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_argument env)) - _visitors_fargs - in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Pipe_partial_apply - { func = _visitors_r0; args = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_expr env _visitors_this.arg_value in + let _visitors_r1 = + self#visit_argument_kind env _visitors_this.arg_kind + in + { arg_value = _visitors_r0; arg_kind = _visitors_r1 } + + method visit_Pipe_partial_apply : + _ -> expr -> argument list -> location -> pipe_rhs = + fun env -> + fun _visitors_ffunc -> + fun _visitors_fargs -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_ffunc in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_argument env)) + _visitors_fargs + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Pipe_partial_apply + { func = _visitors_r0; args = _visitors_r1; loc_ = _visitors_r2 } method visit_Pipe_invalid : _ -> expr -> stype -> location -> pipe_rhs = - fun env _visitors_fexpr _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Pipe_invalid - { expr = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fexpr -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Pipe_invalid + { expr = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_pipe_rhs : _ -> pipe_rhs -> pipe_rhs = - fun env _visitors_this -> - match _visitors_this with - | Pipe_partial_apply - { - func = _visitors_ffunc; - args = _visitors_fargs; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs - _visitors_floc_ - | Pipe_invalid - { - expr = _visitors_fexpr; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty - _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Pipe_partial_apply + { + func = _visitors_ffunc; + args = _visitors_fargs; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_partial_apply env _visitors_ffunc _visitors_fargs + _visitors_floc_ + | Pipe_invalid + { + expr = _visitors_fexpr; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Pipe_invalid env _visitors_fexpr _visitors_fty + _visitors_floc_ method visit_Interp_lit : _ -> string -> interp_elem = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - Interp_lit _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + Interp_lit _visitors_r0 method visit_Interp_expr : _ -> expr -> expr -> location -> interp_elem = - fun env _visitors_fexpr _visitors_fto_string _visitors_floc_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = self#visit_expr env _visitors_fto_string in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Interp_expr - { - expr = _visitors_r0; - to_string = _visitors_r1; - loc_ = _visitors_r2; - } + fun env -> + fun _visitors_fexpr -> + fun _visitors_fto_string -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = self#visit_expr env _visitors_fto_string in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Interp_expr + { + expr = _visitors_r0; + to_string = _visitors_r1; + loc_ = _visitors_r2; + } method visit_interp_elem : _ -> interp_elem -> interp_elem = - fun env _visitors_this -> - match _visitors_this with - | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 - | Interp_expr - { - expr = _visitors_fexpr; - to_string = _visitors_fto_string; - loc_ = _visitors_floc_; - } -> - self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string - _visitors_floc_ - - method visit_Field_def - : _ -> Syntax.label -> expr -> bool -> bool -> int -> field_def = - fun env _visitors_flabel _visitors_fexpr _visitors_fis_mut - _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_expr env _visitors_fexpr in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_mut - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pun - in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - Field_def - { - label = _visitors_r0; - expr = _visitors_r1; - is_mut = _visitors_r2; - is_pun = _visitors_r3; - pos = _visitors_r4; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Interp_lit _visitors_c0 -> self#visit_Interp_lit env _visitors_c0 + | Interp_expr + { + expr = _visitors_fexpr; + to_string = _visitors_fto_string; + loc_ = _visitors_floc_; + } -> + self#visit_Interp_expr env _visitors_fexpr _visitors_fto_string + _visitors_floc_ + + method visit_Field_def : + _ -> Syntax.label -> expr -> bool -> bool -> int -> field_def = + fun env -> + fun _visitors_flabel -> + fun _visitors_fexpr -> + fun _visitors_fis_mut -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_expr env _visitors_fexpr in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_mut + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pun + in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + Field_def + { + label = _visitors_r0; + expr = _visitors_r1; + is_mut = _visitors_r2; + is_pun = _visitors_r3; + pos = _visitors_r4; + } method visit_field_def : _ -> field_def -> field_def = - fun env _visitors_this -> - match _visitors_this with - | Field_def - { - label = _visitors_flabel; - expr = _visitors_fexpr; - is_mut = _visitors_fis_mut; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_def env _visitors_flabel _visitors_fexpr - _visitors_fis_mut _visitors_fis_pun _visitors_fpos - - method visit_Field_pat - : _ -> Syntax.label -> pat -> bool -> int -> field_pat = - fun env _visitors_flabel _visitors_fpat _visitors_fis_pun _visitors_fpos -> - let _visitors_r0 = self#visit_label env _visitors_flabel in - let _visitors_r1 = self#visit_pat env _visitors_fpat in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pun - in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - Field_pat - { - label = _visitors_r0; - pat = _visitors_r1; - is_pun = _visitors_r2; - pos = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_def + { + label = _visitors_flabel; + expr = _visitors_fexpr; + is_mut = _visitors_fis_mut; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_def env _visitors_flabel _visitors_fexpr + _visitors_fis_mut _visitors_fis_pun _visitors_fpos + + method visit_Field_pat : + _ -> Syntax.label -> pat -> bool -> int -> field_pat = + fun env -> + fun _visitors_flabel -> + fun _visitors_fpat -> + fun _visitors_fis_pun -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_label env _visitors_flabel in + let _visitors_r1 = self#visit_pat env _visitors_fpat in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pun + in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + Field_pat + { + label = _visitors_r0; + pat = _visitors_r1; + is_pun = _visitors_r2; + pos = _visitors_r3; + } method visit_field_pat : _ -> field_pat -> field_pat = - fun env _visitors_this -> - match _visitors_this with - | Field_pat - { - label = _visitors_flabel; - pat = _visitors_fpat; - is_pun = _visitors_fis_pun; - pos = _visitors_fpos; - } -> - self#visit_Field_pat env _visitors_flabel _visitors_fpat - _visitors_fis_pun _visitors_fpos + fun env -> + fun _visitors_this -> + match _visitors_this with + | Field_pat + { + label = _visitors_flabel; + pat = _visitors_fpat; + is_pun = _visitors_fis_pun; + pos = _visitors_fpos; + } -> + self#visit_Field_pat env _visitors_flabel _visitors_fpat + _visitors_fis_pun _visitors_fpos method visit_constr_pat_args : _ -> constr_pat_args -> constr_pat_args = - fun env _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_pat_arg env) - - method visit_Constr_pat_arg - : _ -> pat -> Syntax.argument_kind -> int -> constr_pat_arg = - fun env _visitors_fpat _visitors_fkind _visitors_fpos -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fpos - in - Constr_pat_arg - { pat = _visitors_r0; kind = _visitors_r1; pos = _visitors_r2 } + fun env -> + fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_pat_arg env) + + method visit_Constr_pat_arg : + _ -> pat -> Syntax.argument_kind -> int -> constr_pat_arg = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkind -> + fun _visitors_fpos -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_argument_kind env _visitors_fkind in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fpos + in + Constr_pat_arg + { pat = _visitors_r0; kind = _visitors_r1; pos = _visitors_r2 } method visit_constr_pat_arg : _ -> constr_pat_arg -> constr_pat_arg = - fun env _visitors_this -> - match _visitors_this with - | Constr_pat_arg - { - pat = _visitors_fpat; - kind = _visitors_fkind; - pos = _visitors_fpos; - } -> - self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind - _visitors_fpos - - method visit_Param - : _ -> binder -> typ option -> stype -> param_kind -> param = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fty - _visitors_fkind -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_param_kind env _visitors_fkind in - Param - { - binder = _visitors_r0; - konstraint = _visitors_r1; - ty = _visitors_r2; - kind = _visitors_r3; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Constr_pat_arg + { + pat = _visitors_fpat; + kind = _visitors_fkind; + pos = _visitors_fpos; + } -> + self#visit_Constr_pat_arg env _visitors_fpat _visitors_fkind + _visitors_fpos + + method visit_Param : + _ -> binder -> typ option -> stype -> param_kind -> param = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_fkind -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_param_kind env _visitors_fkind in + Param + { + binder = _visitors_r0; + konstraint = _visitors_r1; + ty = _visitors_r2; + kind = _visitors_r3; + } + + method visit_Discard_positional_param : + _ -> stype -> typ option -> location -> param = + fun env -> + fun _visitors_fty -> + fun _visitors_fkonstraint -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Discard_positional_param + { + ty = _visitors_r0; + konstraint = _visitors_r1; + loc_ = _visitors_r2; + } method visit_param : _ -> param -> param = - fun env _visitors_this -> - match _visitors_this with - | Param - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - kind = _visitors_fkind; - } -> - self#visit_Param env _visitors_fbinder _visitors_fkonstraint - _visitors_fty _visitors_fkind + fun env -> + fun _visitors_this -> + match _visitors_this with + | Param + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + kind = _visitors_fkind; + } -> + self#visit_Param env _visitors_fbinder _visitors_fkonstraint + _visitors_fty _visitors_fkind + | Discard_positional_param + { + ty = _visitors_fty; + konstraint = _visitors_fkonstraint; + loc_ = _visitors_floc_; + } -> + self#visit_Discard_positional_param env _visitors_fty + _visitors_fkonstraint _visitors_floc_ method visit_Positional : _ -> param_kind = fun env -> Positional method visit_Labelled : _ -> param_kind = fun env -> Labelled method visit_Optional : _ -> expr -> param_kind = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_expr env _visitors_c0 in - Optional _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_expr env _visitors_c0 in + Optional _visitors_r0 method visit_Autofill : _ -> param_kind = fun env -> Autofill @@ -7415,1004 +9355,1264 @@ include struct fun env -> Question_optional method visit_param_kind : _ -> param_kind -> param_kind = - fun env _visitors_this -> - match _visitors_this with - | Positional -> self#visit_Positional env - | Labelled -> self#visit_Labelled env - | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 - | Autofill -> self#visit_Autofill env - | Question_optional -> self#visit_Question_optional env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Positional -> self#visit_Positional env + | Labelled -> self#visit_Labelled env + | Optional _visitors_c0 -> self#visit_Optional env _visitors_c0 + | Autofill -> self#visit_Autofill env + | Question_optional -> self#visit_Question_optional env method visit_params : _ -> params -> params = - fun env _visitors_this -> - Basic_lst.map _visitors_this (self#visit_param env) + fun env -> + fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_param env) method visit_fn : _ -> fn -> fn = - fun env _visitors_this -> - let _visitors_r0 = self#visit_params env _visitors_this.params in - let _visitors_r1 = - self#visit_location env _visitors_this.params_loc_ - in - let _visitors_r2 = self#visit_expr env _visitors_this.body in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - let _visitors_r1 = - self#visit_error_typ env _visitors_c1 - in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_this.ret_constraint - in - let _visitors_r4 = self#visit_stype env _visitors_this.ty in - let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in - { - params = _visitors_r0; - params_loc_ = _visitors_r1; - body = _visitors_r2; - ret_constraint = _visitors_r3; - ty = _visitors_r4; - kind_ = _visitors_r5; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_params env _visitors_this.params in + let _visitors_r1 = + self#visit_location env _visitors_this.params_loc_ + in + let _visitors_r2 = self#visit_expr env _visitors_this.body in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + let _visitors_r1 = + self#visit_error_typ env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_this.ret_constraint + in + let _visitors_r4 = self#visit_stype env _visitors_this.ty in + let _visitors_r5 = self#visit_fn_kind env _visitors_this.kind_ in + { + params = _visitors_r0; + params_loc_ = _visitors_r1; + body = _visitors_r2; + ret_constraint = _visitors_r3; + ty = _visitors_r4; + kind_ = _visitors_r5; + } method visit_match_case : _ -> match_case -> match_case = - fun env _visitors_this -> - let _visitors_r0 = self#visit_pat env _visitors_this.pat in - let _visitors_r1 = self#visit_expr env _visitors_this.action in - let _visitors_r2 = - self#visit_pat_binders env _visitors_this.pat_binders - in - { - pat = _visitors_r0; - action = _visitors_r1; - pat_binders = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_pat env _visitors_this.pat in + let _visitors_r1 = self#visit_expr env _visitors_this.action in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_expr env) t) + | None -> None) + _visitors_this.guard + in + let _visitors_r3 = + self#visit_pat_binders env _visitors_this.pat_binders + in + { + pat = _visitors_r0; + action = _visitors_r1; + guard = _visitors_r2; + pat_binders = _visitors_r3; + } method visit_Error_typ : _ -> typ -> error_typ = - fun env _visitors_fty -> - let _visitors_r0 = self#visit_typ env _visitors_fty in - Error_typ { ty = _visitors_r0 } + fun env -> + fun _visitors_fty -> + let _visitors_r0 = self#visit_typ env _visitors_fty in + Error_typ { ty = _visitors_r0 } method visit_Default_error_typ : _ -> location -> error_typ = - fun env _visitors_floc_ -> - let _visitors_r0 = self#visit_location env _visitors_floc_ in - Default_error_typ { loc_ = _visitors_r0 } + fun env -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_location env _visitors_floc_ in + Default_error_typ { loc_ = _visitors_r0 } method visit_No_error_typ : _ -> error_typ = fun env -> No_error_typ method visit_error_typ : _ -> error_typ -> error_typ = - fun env _visitors_this -> - match _visitors_this with - | Error_typ { ty = _visitors_fty } -> - self#visit_Error_typ env _visitors_fty - | Default_error_typ { loc_ = _visitors_floc_ } -> - self#visit_Default_error_typ env _visitors_floc_ - | No_error_typ -> self#visit_No_error_typ env + fun env -> + fun _visitors_this -> + match _visitors_this with + | Error_typ { ty = _visitors_fty } -> + self#visit_Error_typ env _visitors_fty + | Default_error_typ { loc_ = _visitors_floc_ } -> + self#visit_Default_error_typ env _visitors_floc_ + | No_error_typ -> self#visit_No_error_typ env method visit_Tany : _ -> stype -> location -> typ = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - Tany { ty = _visitors_r0; loc_ = _visitors_r1 } - - method visit_Tarrow - : _ -> typ list -> typ -> error_typ -> stype -> location -> typ = - fun env _visitors_fparams _visitors_freturn _visitors_ferr_ty - _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_typ env _visitors_freturn in - let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Tarrow - { - params = _visitors_r0; - return = _visitors_r1; - err_ty = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + Tany { ty = _visitors_r0; loc_ = _visitors_r1 } + + method visit_Tarrow : + _ -> typ list -> typ -> error_typ -> stype -> location -> typ = + fun env -> + fun _visitors_fparams -> + fun _visitors_freturn -> + fun _visitors_ferr_ty -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_typ env _visitors_freturn in + let _visitors_r2 = self#visit_error_typ env _visitors_ferr_ty in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Tarrow + { + params = _visitors_r0; + return = _visitors_r1; + err_ty = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } method visit_T_tuple : _ -> typ list -> stype -> location -> typ = - fun env _visitors_fparams _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - T_tuple - { params = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Tname - : _ -> constrid_loc -> typ list -> stype -> bool -> location -> typ = - fun env _visitors_fconstr _visitors_fparams _visitors_fty - _visitors_fis_alias_ _visitors_floc_ -> - let _visitors_r0 = self#visit_constrid_loc env _visitors_fconstr in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_typ env)) - _visitors_fparams - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_alias_ - in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Tname - { - constr = _visitors_r0; - params = _visitors_r1; - ty = _visitors_r2; - is_alias_ = _visitors_r3; - loc_ = _visitors_r4; - } + fun env -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fparams + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + T_tuple + { params = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Tname : + _ -> constrid_loc -> typ list -> stype -> bool -> location -> typ = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fparams -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_typ env)) + _visitors_fparams + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_alias_ + in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Tname + { + constr = _visitors_r0; + params = _visitors_r1; + ty = _visitors_r2; + is_alias_ = _visitors_r3; + loc_ = _visitors_r4; + } + + method visit_Tobject : + _ -> constrid_loc -> stype -> bool -> location -> typ = + fun env -> + fun _visitors_fconstr -> + fun _visitors_fty -> + fun _visitors_fis_alias_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + self#visit_constrid_loc env _visitors_fconstr + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fis_alias_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tobject + { + constr = _visitors_r0; + ty = _visitors_r1; + is_alias_ = _visitors_r2; + loc_ = _visitors_r3; + } method visit_typ : _ -> typ -> typ = - fun env _visitors_this -> - match _visitors_this with - | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tany env _visitors_fty _visitors_floc_ - | Tarrow - { - params = _visitors_fparams; - return = _visitors_freturn; - err_ty = _visitors_ferr_ty; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tarrow env _visitors_fparams _visitors_freturn - _visitors_ferr_ty _visitors_fty _visitors_floc_ - | T_tuple - { - params = _visitors_fparams; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_T_tuple env _visitors_fparams _visitors_fty - _visitors_floc_ - | Tname - { - constr = _visitors_fconstr; - params = _visitors_fparams; - ty = _visitors_fty; - is_alias_ = _visitors_fis_alias_; - loc_ = _visitors_floc_; - } -> - self#visit_Tname env _visitors_fconstr _visitors_fparams - _visitors_fty _visitors_fis_alias_ _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tany { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tany env _visitors_fty _visitors_floc_ + | Tarrow + { + params = _visitors_fparams; + return = _visitors_freturn; + err_ty = _visitors_ferr_ty; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tarrow env _visitors_fparams _visitors_freturn + _visitors_ferr_ty _visitors_fty _visitors_floc_ + | T_tuple + { + params = _visitors_fparams; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_T_tuple env _visitors_fparams _visitors_fty + _visitors_floc_ + | Tname + { + constr = _visitors_fconstr; + params = _visitors_fparams; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tname env _visitors_fconstr _visitors_fparams + _visitors_fty _visitors_fis_alias_ _visitors_floc_ + | Tobject + { + constr = _visitors_fconstr; + ty = _visitors_fty; + is_alias_ = _visitors_fis_alias_; + loc_ = _visitors_floc_; + } -> + self#visit_Tobject env _visitors_fconstr _visitors_fty + _visitors_fis_alias_ _visitors_floc_ method visit_Tpat_alias : _ -> pat -> binder -> stype -> location -> pat = - fun env _visitors_fpat _visitors_falias _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_binder env _visitors_falias in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_alias - { - pat = _visitors_r0; - alias = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fpat -> + fun _visitors_falias -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_binder env _visitors_falias in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_alias + { + pat = _visitors_r0; + alias = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Tpat_any : _ -> stype -> location -> pat = - fun env _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_stype env _visitors_fty in - let _visitors_r1 = self#visit_location env _visitors_floc_ in - Tpat_any { ty = _visitors_r0; loc_ = _visitors_r1 } + fun env -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_stype env _visitors_fty in + let _visitors_r1 = self#visit_location env _visitors_floc_ in + Tpat_any { ty = _visitors_r0; loc_ = _visitors_r1 } method visit_Tpat_array : _ -> array_pattern -> stype -> location -> pat = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Tpat_array - { pats = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Tpat_constant - : _ -> constant -> stype -> var option -> location -> pat = - fun env _visitors_fc _visitors_fty _visitors_fname_ _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_fc - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_var env) t) - | None -> None) - _visitors_fname_ - in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_constant - { - c = _visitors_r0; - ty = _visitors_r1; - name_ = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Tpat_constr - : _ -> - Syntax.constructor -> - constr_pat_args -> - constr_tag -> - stype -> - bool -> - location -> - pat = - fun env _visitors_fconstr _visitors_fargs _visitors_ftag _visitors_fty - _visitors_fused_error_subtyping _visitors_floc_ -> - let _visitors_r0 = self#visit_constructor env _visitors_fconstr in - let _visitors_r1 = self#visit_constr_pat_args env _visitors_fargs in - let _visitors_r2 = self#visit_constr_tag env _visitors_ftag in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) - _visitors_fused_error_subtyping - in - let _visitors_r5 = self#visit_location env _visitors_floc_ in - Tpat_constr - { - constr = _visitors_r0; - args = _visitors_r1; - tag = _visitors_r2; - ty = _visitors_r3; - used_error_subtyping = _visitors_r4; - loc_ = _visitors_r5; - } + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_array_pattern env _visitors_fpats in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Tpat_array + { pats = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Tpat_constant : + _ -> constant -> stype -> var option -> location -> pat = + fun env -> + fun _visitors_fc -> + fun _visitors_fty -> + fun _visitors_fname_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_fc + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_var env) t) + | None -> None) + _visitors_fname_ + in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_constant + { + c = _visitors_r0; + ty = _visitors_r1; + name_ = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Tpat_constr : + _ -> + type_name option -> + Syntax.constr_name -> + constr_pat_args -> + constr_tag -> + stype -> + bool -> + fn_arity -> + stype list -> + location -> + pat = + fun env -> + fun _visitors_ftype_name -> + fun _visitors_fconstr -> + fun _visitors_fargs -> + fun _visitors_ftag -> + fun _visitors_fty -> + fun _visitors_fused_error_subtyping -> + fun _visitors_farity_ -> + fun _visitors_fall_args_ -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_ftype_name + in + let _visitors_r1 = + self#visit_constr_name env _visitors_fconstr + in + let _visitors_r2 = + self#visit_constr_pat_args env _visitors_fargs + in + let _visitors_r3 = + self#visit_constr_tag env _visitors_ftag + in + let _visitors_r4 = self#visit_stype env _visitors_fty in + let _visitors_r5 = + (fun _visitors_this -> _visitors_this) + _visitors_fused_error_subtyping + in + let _visitors_r6 = + self#visit_fn_arity env _visitors_farity_ + in + let _visitors_r7 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_stype env)) + _visitors_fall_args_ + in + let _visitors_r8 = self#visit_location env _visitors_floc_ in + Tpat_constr + { + type_name = _visitors_r0; + constr = _visitors_r1; + args = _visitors_r2; + tag = _visitors_r3; + ty = _visitors_r4; + used_error_subtyping = _visitors_r5; + arity_ = _visitors_r6; + all_args_ = _visitors_r7; + loc_ = _visitors_r8; + } method visit_Tpat_or : _ -> pat -> pat -> stype -> location -> pat = - fun env _visitors_fpat1 _visitors_fpat2 _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat1 in - let _visitors_r1 = self#visit_pat env _visitors_fpat2 in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_or - { - pat1 = _visitors_r0; - pat2 = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fpat1 -> + fun _visitors_fpat2 -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat1 in + let _visitors_r1 = self#visit_pat env _visitors_fpat2 in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_or + { + pat1 = _visitors_r0; + pat2 = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Tpat_tuple : _ -> pat list -> stype -> location -> pat = - fun env _visitors_fpats _visitors_fty _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pat env)) - _visitors_fpats - in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Tpat_tuple - { pats = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + fun env -> + fun _visitors_fpats -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pat env)) + _visitors_fpats + in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Tpat_tuple + { pats = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } method visit_Tpat_var : _ -> binder -> stype -> location -> pat = - fun env _visitors_fbinder _visitors_fty _visitors_floc_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = self#visit_stype env _visitors_fty in - let _visitors_r2 = self#visit_location env _visitors_floc_ in - Tpat_var - { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } - - method visit_Tpat_record - : _ -> field_pat list -> bool -> stype -> location -> pat = - fun env _visitors_ffields _visitors_fis_closed _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_pat env)) - _visitors_ffields - in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fis_closed - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_record - { - fields = _visitors_r0; - is_closed = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } + fun env -> + fun _visitors_fbinder -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = self#visit_stype env _visitors_fty in + let _visitors_r2 = self#visit_location env _visitors_floc_ in + Tpat_var + { binder = _visitors_r0; ty = _visitors_r1; loc_ = _visitors_r2 } + + method visit_Tpat_record : + _ -> field_pat list -> bool -> stype -> location -> pat = + fun env -> + fun _visitors_ffields -> + fun _visitors_fis_closed -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_pat env)) + _visitors_ffields + in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_closed + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_record + { + fields = _visitors_r0; + is_closed = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } method visit_Tpat_constraint : _ -> pat -> typ -> stype -> location -> pat = - fun env _visitors_fpat _visitors_fkonstraint _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_fpat in - let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_constraint - { - pat = _visitors_r0; - konstraint = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Tpat_map - : _ -> - (constant * pat) list -> - ident * stype * stype array -> - stype -> - location -> - pat = - fun env _visitors_felems _visitors_fop_get_info_ _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> _visitors_this) _visitors_c0 - in - let _visitors_r1 = self#visit_pat env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_felems - in - let _visitors_r1 = - (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> - let _visitors_r0 = self#visit_ident env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - let _visitors_r2 = + fun env -> + fun _visitors_fpat -> + fun _visitors_fkonstraint -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_fpat in + let _visitors_r1 = self#visit_typ env _visitors_fkonstraint in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_constraint + { + pat = _visitors_r0; + konstraint = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Tpat_map : + _ -> + (constant * pat) list -> + ident * stype * stype array -> + stype -> + location -> + pat = + fun env -> + fun _visitors_felems -> + fun _visitors_fop_get_info_ -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = (fun _visitors_this -> - Basic_arr.map _visitors_this (self#visit_stype env)) - _visitors_c2 + Basic_lst.map _visitors_this + (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> _visitors_this) _visitors_c0 + in + let _visitors_r1 = self#visit_pat env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_felems in - (_visitors_r0, _visitors_r1, _visitors_r2)) - _visitors_fop_get_info_ - in - let _visitors_r2 = self#visit_stype env _visitors_fty in - let _visitors_r3 = self#visit_location env _visitors_floc_ in - Tpat_map - { - elems = _visitors_r0; - op_get_info_ = _visitors_r1; - ty = _visitors_r2; - loc_ = _visitors_r3; - } - - method visit_Tpat_range - : _ -> pat -> pat -> bool -> stype -> location -> pat = - fun env _visitors_flhs _visitors_frhs _visitors_finclusive _visitors_fty - _visitors_floc_ -> - let _visitors_r0 = self#visit_pat env _visitors_flhs in - let _visitors_r1 = self#visit_pat env _visitors_frhs in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_finclusive - in - let _visitors_r3 = self#visit_stype env _visitors_fty in - let _visitors_r4 = self#visit_location env _visitors_floc_ in - Tpat_range - { - lhs = _visitors_r0; - rhs = _visitors_r1; - inclusive = _visitors_r2; - ty = _visitors_r3; - loc_ = _visitors_r4; - } + let _visitors_r1 = + (fun (_visitors_c0, _visitors_c1, _visitors_c2) -> + let _visitors_r0 = self#visit_ident env _visitors_c0 in + let _visitors_r1 = self#visit_stype env _visitors_c1 in + let _visitors_r2 = + (fun _visitors_this -> + Basic_arr.map _visitors_this (self#visit_stype env)) + _visitors_c2 + in + (_visitors_r0, _visitors_r1, _visitors_r2)) + _visitors_fop_get_info_ + in + let _visitors_r2 = self#visit_stype env _visitors_fty in + let _visitors_r3 = self#visit_location env _visitors_floc_ in + Tpat_map + { + elems = _visitors_r0; + op_get_info_ = _visitors_r1; + ty = _visitors_r2; + loc_ = _visitors_r3; + } + + method visit_Tpat_range : + _ -> pat -> pat -> bool -> stype -> location -> pat = + fun env -> + fun _visitors_flhs -> + fun _visitors_frhs -> + fun _visitors_finclusive -> + fun _visitors_fty -> + fun _visitors_floc_ -> + let _visitors_r0 = self#visit_pat env _visitors_flhs in + let _visitors_r1 = self#visit_pat env _visitors_frhs in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_finclusive + in + let _visitors_r3 = self#visit_stype env _visitors_fty in + let _visitors_r4 = self#visit_location env _visitors_floc_ in + Tpat_range + { + lhs = _visitors_r0; + rhs = _visitors_r1; + inclusive = _visitors_r2; + ty = _visitors_r3; + loc_ = _visitors_r4; + } method visit_pat : _ -> pat -> pat = - fun env _visitors_this -> - match _visitors_this with - | Tpat_alias - { - pat = _visitors_fpat; - alias = _visitors_falias; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_alias env _visitors_fpat _visitors_falias - _visitors_fty _visitors_floc_ - | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> - self#visit_Tpat_any env _visitors_fty _visitors_floc_ - | Tpat_array - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_array env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_constant - { - c = _visitors_fc; - ty = _visitors_fty; - name_ = _visitors_fname_; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constant env _visitors_fc _visitors_fty - _visitors_fname_ _visitors_floc_ - | Tpat_constr - { - constr = _visitors_fconstr; - args = _visitors_fargs; - tag = _visitors_ftag; - ty = _visitors_fty; - used_error_subtyping = _visitors_fused_error_subtyping; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constr env _visitors_fconstr _visitors_fargs - _visitors_ftag _visitors_fty _visitors_fused_error_subtyping - _visitors_floc_ - | Tpat_or - { - pat1 = _visitors_fpat1; - pat2 = _visitors_fpat2; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 - _visitors_fty _visitors_floc_ - | Tpat_tuple - { - pats = _visitors_fpats; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_tuple env _visitors_fpats _visitors_fty - _visitors_floc_ - | Tpat_var - { - binder = _visitors_fbinder; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_var env _visitors_fbinder _visitors_fty - _visitors_floc_ - | Tpat_record - { - fields = _visitors_ffields; - is_closed = _visitors_fis_closed; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed - _visitors_fty _visitors_floc_ - | Tpat_constraint - { - pat = _visitors_fpat; - konstraint = _visitors_fkonstraint; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_constraint env _visitors_fpat - _visitors_fkonstraint _visitors_fty _visitors_floc_ - | Tpat_map - { - elems = _visitors_felems; - op_get_info_ = _visitors_fop_get_info_; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ - _visitors_fty _visitors_floc_ - | Tpat_range - { - lhs = _visitors_flhs; - rhs = _visitors_frhs; - inclusive = _visitors_finclusive; - ty = _visitors_fty; - loc_ = _visitors_floc_; - } -> - self#visit_Tpat_range env _visitors_flhs _visitors_frhs - _visitors_finclusive _visitors_fty _visitors_floc_ + fun env -> + fun _visitors_this -> + match _visitors_this with + | Tpat_alias + { + pat = _visitors_fpat; + alias = _visitors_falias; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_alias env _visitors_fpat _visitors_falias + _visitors_fty _visitors_floc_ + | Tpat_any { ty = _visitors_fty; loc_ = _visitors_floc_ } -> + self#visit_Tpat_any env _visitors_fty _visitors_floc_ + | Tpat_array + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_array env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_constant + { + c = _visitors_fc; + ty = _visitors_fty; + name_ = _visitors_fname_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constant env _visitors_fc _visitors_fty + _visitors_fname_ _visitors_floc_ + | Tpat_constr + { + type_name = _visitors_ftype_name; + constr = _visitors_fconstr; + args = _visitors_fargs; + tag = _visitors_ftag; + ty = _visitors_fty; + used_error_subtyping = _visitors_fused_error_subtyping; + arity_ = _visitors_farity_; + all_args_ = _visitors_fall_args_; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constr env _visitors_ftype_name _visitors_fconstr + _visitors_fargs _visitors_ftag _visitors_fty + _visitors_fused_error_subtyping _visitors_farity_ + _visitors_fall_args_ _visitors_floc_ + | Tpat_or + { + pat1 = _visitors_fpat1; + pat2 = _visitors_fpat2; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_or env _visitors_fpat1 _visitors_fpat2 + _visitors_fty _visitors_floc_ + | Tpat_tuple + { + pats = _visitors_fpats; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_tuple env _visitors_fpats _visitors_fty + _visitors_floc_ + | Tpat_var + { + binder = _visitors_fbinder; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_var env _visitors_fbinder _visitors_fty + _visitors_floc_ + | Tpat_record + { + fields = _visitors_ffields; + is_closed = _visitors_fis_closed; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_record env _visitors_ffields _visitors_fis_closed + _visitors_fty _visitors_floc_ + | Tpat_constraint + { + pat = _visitors_fpat; + konstraint = _visitors_fkonstraint; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_constraint env _visitors_fpat + _visitors_fkonstraint _visitors_fty _visitors_floc_ + | Tpat_map + { + elems = _visitors_felems; + op_get_info_ = _visitors_fop_get_info_; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_map env _visitors_felems _visitors_fop_get_info_ + _visitors_fty _visitors_floc_ + | Tpat_range + { + lhs = _visitors_flhs; + rhs = _visitors_frhs; + inclusive = _visitors_finclusive; + ty = _visitors_fty; + loc_ = _visitors_floc_; + } -> + self#visit_Tpat_range env _visitors_flhs _visitors_frhs + _visitors_finclusive _visitors_fty _visitors_floc_ method visit_Closed : _ -> pat list -> array_pattern = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pat env)) - _visitors_c0 - in - Closed _visitors_r0 - - method visit_Open - : _ -> - pat list -> - pat list -> - (binder * stype) option -> - array_pattern = - fun env _visitors_c0 _visitors_c1 _visitors_c2 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pat env)) - _visitors_c0 - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_pat env)) - _visitors_c1 - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> - Some - ((fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = self#visit_binder env _visitors_c0 in - let _visitors_r1 = self#visit_stype env _visitors_c1 in - (_visitors_r0, _visitors_r1)) - t) - | None -> None) - _visitors_c2 - in - Open (_visitors_r0, _visitors_r1, _visitors_r2) + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pat env)) + _visitors_c0 + in + Closed _visitors_r0 + + method visit_Open : + _ -> pat list -> pat list -> (binder * stype) option -> array_pattern + = + fun env -> + fun _visitors_c0 -> + fun _visitors_c1 -> + fun _visitors_c2 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pat env)) + _visitors_c0 + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_pat env)) + _visitors_c1 + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> + Some + ((fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + self#visit_binder env _visitors_c0 + in + let _visitors_r1 = + self#visit_stype env _visitors_c1 + in + (_visitors_r0, _visitors_r1)) + t) + | None -> None) + _visitors_c2 + in + Open (_visitors_r0, _visitors_r1, _visitors_r2) method visit_array_pattern : _ -> array_pattern -> array_pattern = - fun env _visitors_this -> - match _visitors_this with - | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 - | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> - self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Closed _visitors_c0 -> self#visit_Closed env _visitors_c0 + | Open (_visitors_c0, _visitors_c1, _visitors_c2) -> + self#visit_Open env _visitors_c0 _visitors_c1 _visitors_c2 method visit_fun_decl : _ -> fun_decl -> fun_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_fun_decl_kind env _visitors_this.kind in - let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in - let _visitors_r2 = self#visit_fn env _visitors_this.fn in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_this.is_pub - in - let _visitors_r4 = - self#visit_tvar_env env _visitors_this.ty_params_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.doc_ in - { - kind = _visitors_r0; - fn_binder = _visitors_r1; - fn = _visitors_r2; - is_pub = _visitors_r3; - ty_params_ = _visitors_r4; - doc_ = _visitors_r5; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_fun_decl_kind env _visitors_this.kind + in + let _visitors_r1 = self#visit_binder env _visitors_this.fn_binder in + let _visitors_r2 = self#visit_fn env _visitors_this.fn in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_this.is_pub + in + let _visitors_r4 = + self#visit_tvar_env env _visitors_this.ty_params_ + in + let _visitors_r5 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_type_name env)) + _visitors_this.constraint_names + in + let _visitors_r6 = self#visit_docstring env _visitors_this.doc_ in + let _visitors_r7 = self#visit_attributes env _visitors_this.attrs in + { + kind = _visitors_r0; + fn_binder = _visitors_r1; + fn = _visitors_r2; + is_pub = _visitors_r3; + ty_params_ = _visitors_r4; + constraint_names = _visitors_r5; + doc_ = _visitors_r6; + attrs = _visitors_r7; + } method visit_Fun_kind_regular : _ -> fun_decl_kind = fun env -> Fun_kind_regular method visit_Fun_kind_method : _ -> type_name option -> fun_decl_kind = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_type_name env) t) - | None -> None) - _visitors_c0 - in - Fun_kind_method _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_type_name env) t) + | None -> None) + _visitors_c0 + in + Fun_kind_method _visitors_r0 method visit_Fun_kind_default_impl : _ -> type_name -> fun_decl_kind = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_type_name env _visitors_c0 in - Fun_kind_default_impl _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_type_name env _visitors_c0 in + Fun_kind_default_impl _visitors_r0 method visit_Fun_kind_impl : _ -> typ -> type_name -> fun_decl_kind = - fun env _visitors_fself_ty _visitors_ftrait -> - let _visitors_r0 = self#visit_typ env _visitors_fself_ty in - let _visitors_r1 = self#visit_type_name env _visitors_ftrait in - Fun_kind_impl { self_ty = _visitors_r0; trait = _visitors_r1 } + fun env -> + fun _visitors_fself_ty -> + fun _visitors_ftrait -> + let _visitors_r0 = self#visit_typ env _visitors_fself_ty in + let _visitors_r1 = self#visit_type_name env _visitors_ftrait in + Fun_kind_impl { self_ty = _visitors_r0; trait = _visitors_r1 } method visit_fun_decl_kind : _ -> fun_decl_kind -> fun_decl_kind = - fun env _visitors_this -> - match _visitors_this with - | Fun_kind_regular -> self#visit_Fun_kind_regular env - | Fun_kind_method _visitors_c0 -> - self#visit_Fun_kind_method env _visitors_c0 - | Fun_kind_default_impl _visitors_c0 -> - self#visit_Fun_kind_default_impl env _visitors_c0 - | Fun_kind_impl - { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> - self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait - - method visit_Timpl_expr - : _ -> expr -> bool -> _ -> absolute_loc -> bool -> impl = - fun env _visitors_fexpr _visitors_fis_main _visitors_fexpr_id - _visitors_floc_ _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_expr env _visitors_fexpr in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_fis_main - in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_fexpr_id - in - let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r4 = - (fun _visitors_this -> _visitors_this) _visitors_fis_generated_ - in - Timpl_expr - { - expr = _visitors_r0; - is_main = _visitors_r1; - expr_id = _visitors_r2; - loc_ = _visitors_r3; - is_generated_ = _visitors_r4; - } - - method visit_Timpl_fun_decl - : _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> impl = - fun env _visitors_ffun_decl _visitors_farity_ _visitors_floc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in - let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in - let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_generated_ - in - Timpl_fun_decl - { - fun_decl = _visitors_r0; - arity_ = _visitors_r1; - loc_ = _visitors_r2; - is_generated_ = _visitors_r3; - } - - method visit_Timpl_letdef - : _ -> - binder -> - typ option -> - expr -> - bool -> - absolute_loc -> - docstring -> - bool -> - impl = - fun env _visitors_fbinder _visitors_fkonstraint _visitors_fexpr - _visitors_fis_pub _visitors_floc_ _visitors_fdoc_ - _visitors_fis_generated_ -> - let _visitors_r0 = self#visit_binder env _visitors_fbinder in - let _visitors_r1 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_fkonstraint - in - let _visitors_r2 = self#visit_expr env _visitors_fexpr in - let _visitors_r3 = - (fun _visitors_this -> _visitors_this) _visitors_fis_pub - in - let _visitors_r4 = self#visit_absolute_loc env _visitors_floc_ in - let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in - let _visitors_r6 = - (fun _visitors_this -> _visitors_this) _visitors_fis_generated_ - in - Timpl_letdef - { - binder = _visitors_r0; - konstraint = _visitors_r1; - expr = _visitors_r2; - is_pub = _visitors_r3; - loc_ = _visitors_r4; - doc_ = _visitors_r5; - is_generated_ = _visitors_r6; - } + fun env -> + fun _visitors_this -> + match _visitors_this with + | Fun_kind_regular -> self#visit_Fun_kind_regular env + | Fun_kind_method _visitors_c0 -> + self#visit_Fun_kind_method env _visitors_c0 + | Fun_kind_default_impl _visitors_c0 -> + self#visit_Fun_kind_default_impl env _visitors_c0 + | Fun_kind_impl + { self_ty = _visitors_fself_ty; trait = _visitors_ftrait } -> + self#visit_Fun_kind_impl env _visitors_fself_ty _visitors_ftrait + + method visit_Timpl_expr : + _ -> expr -> bool -> _ -> absolute_loc -> bool -> impl = + fun env -> + fun _visitors_fexpr -> + fun _visitors_fis_main -> + fun _visitors_fexpr_id -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_expr env _visitors_fexpr in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_fis_main + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_fexpr_id + in + let _visitors_r3 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r4 = + (fun _visitors_this -> _visitors_this) _visitors_fis_generated_ + in + Timpl_expr + { + expr = _visitors_r0; + is_main = _visitors_r1; + expr_id = _visitors_r2; + loc_ = _visitors_r3; + is_generated_ = _visitors_r4; + } + + method visit_Timpl_fun_decl : + _ -> fun_decl -> fn_arity -> absolute_loc -> bool -> impl = + fun env -> + fun _visitors_ffun_decl -> + fun _visitors_farity_ -> + fun _visitors_floc_ -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_fun_decl env _visitors_ffun_decl in + let _visitors_r1 = self#visit_fn_arity env _visitors_farity_ in + let _visitors_r2 = self#visit_absolute_loc env _visitors_floc_ in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_generated_ + in + Timpl_fun_decl + { + fun_decl = _visitors_r0; + arity_ = _visitors_r1; + loc_ = _visitors_r2; + is_generated_ = _visitors_r3; + } + + method visit_Timpl_letdef : + _ -> + binder -> + typ option -> + expr -> + bool -> + absolute_loc -> + docstring -> + attributes -> + bool -> + impl = + fun env -> + fun _visitors_fbinder -> + fun _visitors_fkonstraint -> + fun _visitors_fexpr -> + fun _visitors_fis_pub -> + fun _visitors_floc_ -> + fun _visitors_fdoc_ -> + fun _visitors_fattrs -> + fun _visitors_fis_generated_ -> + let _visitors_r0 = self#visit_binder env _visitors_fbinder in + let _visitors_r1 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_fkonstraint + in + let _visitors_r2 = self#visit_expr env _visitors_fexpr in + let _visitors_r3 = + (fun _visitors_this -> _visitors_this) _visitors_fis_pub + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_floc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_fdoc_ in + let _visitors_r6 = + self#visit_attributes env _visitors_fattrs + in + let _visitors_r7 = + (fun _visitors_this -> _visitors_this) + _visitors_fis_generated_ + in + Timpl_letdef + { + binder = _visitors_r0; + konstraint = _visitors_r1; + expr = _visitors_r2; + is_pub = _visitors_r3; + loc_ = _visitors_r4; + doc_ = _visitors_r5; + attrs = _visitors_r6; + is_generated_ = _visitors_r7; + } method visit_Timpl_stub_decl : _ -> stub_decl -> impl = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in - Timpl_stub_decl _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_stub_decl env _visitors_c0 in + Timpl_stub_decl _visitors_r0 method visit_impl : _ -> impl -> impl = - fun env _visitors_this -> - match _visitors_this with - | Timpl_expr - { - expr = _visitors_fexpr; - is_main = _visitors_fis_main; - expr_id = _visitors_fexpr_id; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main - _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ - | Timpl_fun_decl - { - fun_decl = _visitors_ffun_decl; - arity_ = _visitors_farity_; - loc_ = _visitors_floc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_fun_decl env _visitors_ffun_decl - _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ - | Timpl_letdef - { - binder = _visitors_fbinder; - konstraint = _visitors_fkonstraint; - expr = _visitors_fexpr; - is_pub = _visitors_fis_pub; - loc_ = _visitors_floc_; - doc_ = _visitors_fdoc_; - is_generated_ = _visitors_fis_generated_; - } -> - self#visit_Timpl_letdef env _visitors_fbinder - _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub - _visitors_floc_ _visitors_fdoc_ _visitors_fis_generated_ - | Timpl_stub_decl _visitors_c0 -> - self#visit_Timpl_stub_decl env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Timpl_expr + { + expr = _visitors_fexpr; + is_main = _visitors_fis_main; + expr_id = _visitors_fexpr_id; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_expr env _visitors_fexpr _visitors_fis_main + _visitors_fexpr_id _visitors_floc_ _visitors_fis_generated_ + | Timpl_fun_decl + { + fun_decl = _visitors_ffun_decl; + arity_ = _visitors_farity_; + loc_ = _visitors_floc_; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_fun_decl env _visitors_ffun_decl + _visitors_farity_ _visitors_floc_ _visitors_fis_generated_ + | Timpl_letdef + { + binder = _visitors_fbinder; + konstraint = _visitors_fkonstraint; + expr = _visitors_fexpr; + is_pub = _visitors_fis_pub; + loc_ = _visitors_floc_; + doc_ = _visitors_fdoc_; + attrs = _visitors_fattrs; + is_generated_ = _visitors_fis_generated_; + } -> + self#visit_Timpl_letdef env _visitors_fbinder + _visitors_fkonstraint _visitors_fexpr _visitors_fis_pub + _visitors_floc_ _visitors_fdoc_ _visitors_fattrs + _visitors_fis_generated_ + | Timpl_stub_decl _visitors_c0 -> + self#visit_Timpl_stub_decl env _visitors_c0 method visit_impls : _ -> impls -> impls = - fun env _visitors_this -> - Basic_lst.map _visitors_this (self#visit_impl env) + fun env -> + fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_impl env) method visit_type_decl : _ -> type_decl -> type_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.td_binder - in - let _visitors_r1 = self#visit_tvar_env env _visitors_this.td_params in - let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in - let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in - let _visitors_r4 = - self#visit_absolute_loc env _visitors_this.td_loc_ - in - let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in - let _visitors_r6 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constrid_loc env)) - _visitors_this.td_deriving_ - in - { - td_binder = _visitors_r0; - td_params = _visitors_r1; - td_desc = _visitors_r2; - td_vis = _visitors_r3; - td_loc_ = _visitors_r4; - td_doc_ = _visitors_r5; - td_deriving_ = _visitors_r6; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.td_binder + in + let _visitors_r1 = + self#visit_tvar_env env _visitors_this.td_params + in + let _visitors_r2 = self#visit_type_desc env _visitors_this.td_desc in + let _visitors_r3 = self#visit_visibility env _visitors_this.td_vis in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.td_loc_ + in + let _visitors_r5 = self#visit_docstring env _visitors_this.td_doc_ in + let _visitors_r6 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_type_name env)) + _visitors_this.td_deriving_ + in + { + td_binder = _visitors_r0; + td_params = _visitors_r1; + td_desc = _visitors_r2; + td_vis = _visitors_r3; + td_loc_ = _visitors_r4; + td_doc_ = _visitors_r5; + td_deriving_ = _visitors_r6; + } method visit_No_payload : _ -> exception_decl = fun env -> No_payload method visit_Single_payload : _ -> typ -> exception_decl = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Single_payload _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Single_payload _visitors_r0 method visit_Enum_payload : _ -> constr_decl list -> exception_decl = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - Enum_payload _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_decl env)) + _visitors_c0 + in + Enum_payload _visitors_r0 method visit_exception_decl : _ -> exception_decl -> exception_decl = - fun env _visitors_this -> - match _visitors_this with - | No_payload -> self#visit_No_payload env - | Single_payload _visitors_c0 -> - self#visit_Single_payload env _visitors_c0 - | Enum_payload _visitors_c0 -> - self#visit_Enum_payload env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | No_payload -> self#visit_No_payload env + | Single_payload _visitors_c0 -> + self#visit_Single_payload env _visitors_c0 + | Enum_payload _visitors_c0 -> + self#visit_Enum_payload env _visitors_c0 method visit_Td_abstract : _ -> type_desc = fun env -> Td_abstract method visit_Td_error : _ -> exception_decl -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in - Td_error _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_exception_decl env _visitors_c0 in + Td_error _visitors_r0 method visit_Td_newtype : _ -> typ -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Td_newtype _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Td_newtype _visitors_r0 method visit_Td_variant : _ -> constr_decl list -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_decl env)) - _visitors_c0 - in - Td_variant _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_decl env)) + _visitors_c0 + in + Td_variant _visitors_r0 method visit_Td_record : _ -> field_decl list -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_field_decl env)) - _visitors_c0 - in - Td_record _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_field_decl env)) + _visitors_c0 + in + Td_record _visitors_r0 method visit_Td_alias : _ -> typ -> type_desc = - fun env _visitors_c0 -> - let _visitors_r0 = self#visit_typ env _visitors_c0 in - Td_alias _visitors_r0 + fun env -> + fun _visitors_c0 -> + let _visitors_r0 = self#visit_typ env _visitors_c0 in + Td_alias _visitors_r0 method visit_type_desc : _ -> type_desc -> type_desc = - fun env _visitors_this -> - match _visitors_this with - | Td_abstract -> self#visit_Td_abstract env - | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 - | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 - | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 - | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 - | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 + fun env -> + fun _visitors_this -> + match _visitors_this with + | Td_abstract -> self#visit_Td_abstract env + | Td_error _visitors_c0 -> self#visit_Td_error env _visitors_c0 + | Td_newtype _visitors_c0 -> self#visit_Td_newtype env _visitors_c0 + | Td_variant _visitors_c0 -> self#visit_Td_variant env _visitors_c0 + | Td_record _visitors_c0 -> self#visit_Td_record env _visitors_c0 + | Td_alias _visitors_c0 -> self#visit_Td_alias env _visitors_c0 method visit_constr_decl_arg : _ -> constr_decl_arg -> constr_decl_arg = - fun env _visitors_this -> - let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in - let _visitors_r1 = - (fun _visitors_this -> _visitors_this) _visitors_this.carg_mut - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_label env) t) - | None -> None) - _visitors_this.carg_label - in - { - carg_typ = _visitors_r0; - carg_mut = _visitors_r1; - carg_label = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_typ env _visitors_this.carg_typ in + let _visitors_r1 = + (fun _visitors_this -> _visitors_this) _visitors_this.carg_mut + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_this.carg_label + in + { + carg_typ = _visitors_r0; + carg_mut = _visitors_r1; + carg_label = _visitors_r2; + } method visit_constr_decl : _ -> constr_decl -> constr_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.constr_name in - let _visitors_r1 = - self#visit_constr_tag env _visitors_this.constr_tag - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_constr_decl_arg env)) - _visitors_this.constr_args - in - let _visitors_r3 = - self#visit_fn_arity env _visitors_this.constr_arity_ - in - let _visitors_r4 = - self#visit_location env _visitors_this.constr_loc_ - in - { - constr_name = _visitors_r0; - constr_tag = _visitors_r1; - constr_args = _visitors_r2; - constr_arity_ = _visitors_r3; - constr_loc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.constr_name in + let _visitors_r1 = + self#visit_constr_tag env _visitors_this.constr_tag + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_constr_decl_arg env)) + _visitors_this.constr_args + in + let _visitors_r3 = + self#visit_fn_arity env _visitors_this.constr_arity_ + in + let _visitors_r4 = + self#visit_location env _visitors_this.constr_loc_ + in + { + constr_name = _visitors_r0; + constr_tag = _visitors_r1; + constr_args = _visitors_r2; + constr_arity_ = _visitors_r3; + constr_loc_ = _visitors_r4; + } method visit_field_decl : _ -> field_decl -> field_decl = - fun env _visitors_this -> - let _visitors_r0 = self#visit_label env _visitors_this.field_label in - let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in - let _visitors_r2 = - (fun _visitors_this -> _visitors_this) _visitors_this.field_mut - in - let _visitors_r3 = - self#visit_visibility env _visitors_this.field_vis - in - let _visitors_r4 = - self#visit_location env _visitors_this.field_loc_ - in - { - field_label = _visitors_r0; - field_typ = _visitors_r1; - field_mut = _visitors_r2; - field_vis = _visitors_r3; - field_loc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = self#visit_label env _visitors_this.field_label in + let _visitors_r1 = self#visit_typ env _visitors_this.field_typ in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) _visitors_this.field_mut + in + let _visitors_r3 = + self#visit_type_component_visibility env _visitors_this.field_vis + in + let _visitors_r4 = + self#visit_location env _visitors_this.field_loc_ + in + { + field_label = _visitors_r0; + field_typ = _visitors_r1; + field_mut = _visitors_r2; + field_vis = _visitors_r3; + field_loc_ = _visitors_r4; + } method visit_trait_decl : _ -> trait_decl -> trait_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_type_constr_loc env _visitors_this.trait_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_method_decl env)) - _visitors_this.trait_methods - in - let _visitors_r2 = - self#visit_visibility env _visitors_this.trait_vis - in - let _visitors_r3 = - self#visit_absolute_loc env _visitors_this.trait_loc_ - in - let _visitors_r4 = - self#visit_docstring env _visitors_this.trait_doc_ - in - { - trait_name = _visitors_r0; - trait_methods = _visitors_r1; - trait_vis = _visitors_r2; - trait_loc_ = _visitors_r3; - trait_doc_ = _visitors_r4; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_type_name env)) + _visitors_this.trait_supers + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_method_decl env)) + _visitors_this.trait_methods + in + let _visitors_r3 = + self#visit_visibility env _visitors_this.trait_vis + in + let _visitors_r4 = + self#visit_absolute_loc env _visitors_this.trait_loc_ + in + let _visitors_r5 = + self#visit_docstring env _visitors_this.trait_doc_ + in + let _visitors_r6 = + self#visit_attributes env _visitors_this.trait_attrs + in + { + trait_name = _visitors_r0; + trait_supers = _visitors_r1; + trait_methods = _visitors_r2; + trait_vis = _visitors_r3; + trait_loc_ = _visitors_r4; + trait_doc_ = _visitors_r5; + trait_attrs = _visitors_r6; + } + + method visit_trait_alias_decl : _ -> trait_alias_decl -> trait_alias_decl + = + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_type_constr_loc env _visitors_this.trait_alias_name + in + let _visitors_r1 = + self#visit_type_name env _visitors_this.trait_alias_target + in + let _visitors_r2 = + (fun _visitors_this -> _visitors_this) + _visitors_this.trait_alias_is_pub + in + let _visitors_r3 = + self#visit_absolute_loc env _visitors_this.trait_alias_loc_ + in + let _visitors_r4 = + self#visit_docstring env _visitors_this.trait_alias_doc_ + in + { + trait_alias_name = _visitors_r0; + trait_alias_target = _visitors_r1; + trait_alias_is_pub = _visitors_r2; + trait_alias_loc_ = _visitors_r3; + trait_alias_doc_ = _visitors_r4; + } method visit_method_decl : _ -> method_decl -> method_decl = - fun env _visitors_this -> - let _visitors_r0 = - self#visit_syntax_binder env _visitors_this.method_name - in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> - let _visitors_r0 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_label env) t) - | None -> None) - _visitors_c0 - in - let _visitors_r1 = self#visit_typ env _visitors_c1 in - (_visitors_r0, _visitors_r1))) - _visitors_this.method_params - in - let _visitors_r2 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_this.method_ret - in - let _visitors_r3 = - (fun _visitors_this -> - match _visitors_this with - | Some t -> Some ((self#visit_typ env) t) - | None -> None) - _visitors_this.method_err - in - let _visitors_r4 = - self#visit_location env _visitors_this.method_loc_ - in - { - method_name = _visitors_r0; - method_params = _visitors_r1; - method_ret = _visitors_r2; - method_err = _visitors_r3; - method_loc_ = _visitors_r4; - } - - method visit_Output - : _ -> impls -> type_decl list -> trait_decl list -> output = - fun env _visitors_fvalue_defs _visitors_ftype_defs _visitors_ftrait_defs -> - let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in - let _visitors_r1 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_type_decl env)) - _visitors_ftype_defs - in - let _visitors_r2 = - (fun _visitors_this -> - Basic_lst.map _visitors_this (self#visit_trait_decl env)) - _visitors_ftrait_defs - in - Output - { - value_defs = _visitors_r0; - type_defs = _visitors_r1; - trait_defs = _visitors_r2; - } + fun env -> + fun _visitors_this -> + let _visitors_r0 = + self#visit_syntax_binder env _visitors_this.method_name + in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (fun (_visitors_c0, _visitors_c1) -> + let _visitors_r0 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_label env) t) + | None -> None) + _visitors_c0 + in + let _visitors_r1 = self#visit_typ env _visitors_c1 in + (_visitors_r0, _visitors_r1))) + _visitors_this.method_params + in + let _visitors_r2 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_this.method_ret + in + let _visitors_r3 = + (fun _visitors_this -> + match _visitors_this with + | Some t -> Some ((self#visit_typ env) t) + | None -> None) + _visitors_this.method_err + in + let _visitors_r4 = + self#visit_location env _visitors_this.method_loc_ + in + { + method_name = _visitors_r0; + method_params = _visitors_r1; + method_ret = _visitors_r2; + method_err = _visitors_r3; + method_loc_ = _visitors_r4; + } + + method visit_Output : + _ -> + impls -> + type_decl list -> + trait_decl list -> + trait_alias_decl list -> + output = + fun env -> + fun _visitors_fvalue_defs -> + fun _visitors_ftype_defs -> + fun _visitors_ftrait_defs -> + fun _visitors_ftrait_alias -> + let _visitors_r0 = self#visit_impls env _visitors_fvalue_defs in + let _visitors_r1 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_type_decl env)) + _visitors_ftype_defs + in + let _visitors_r2 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_trait_decl env)) + _visitors_ftrait_defs + in + let _visitors_r3 = + (fun _visitors_this -> + Basic_lst.map _visitors_this (self#visit_trait_alias_decl env)) + _visitors_ftrait_alias + in + Output + { + value_defs = _visitors_r0; + type_defs = _visitors_r1; + trait_defs = _visitors_r2; + trait_alias = _visitors_r3; + } method visit_output : _ -> output -> output = - fun env _visitors_this -> - match _visitors_this with - | Output - { - value_defs = _visitors_fvalue_defs; - type_defs = _visitors_ftype_defs; - trait_defs = _visitors_ftrait_defs; - } -> - self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs - _visitors_ftrait_defs + fun env -> + fun _visitors_this -> + match _visitors_this with + | Output + { + value_defs = _visitors_fvalue_defs; + type_defs = _visitors_ftype_defs; + trait_defs = _visitors_ftrait_defs; + trait_alias = _visitors_ftrait_alias; + } -> + self#visit_Output env _visitors_fvalue_defs _visitors_ftype_defs + _visitors_ftrait_defs _visitors_ftrait_alias end [@@@VISITORS.END] @@ -8449,47 +10649,56 @@ include struct let _ = fun (_ : constr_decl) -> () let _ = fun (_ : field_decl) -> () let _ = fun (_ : trait_decl) -> () + let _ = fun (_ : trait_alias_decl) -> () let _ = fun (_ : method_decl) -> () let _ = fun (_ : output) -> () end let filter_fields ctor fields = - Lst.fold_right fields [] (fun field acc -> - match field with - | ("params_loc_" | "loc_" | "match_loc_" | "else_loc_" | "catch_loc_"), _ - when not !Basic_config.show_loc -> - acc - | "is_pub", S.Atom "false" -> acc - | "ty_params_", List [] -> acc - | "is_pun", Atom "false" -> acc - | "doc_", Atom "" -> acc - | "type_name", List [] -> acc - | "continue_block", List [] -> acc - | "is_generated_", Atom "false" -> acc - | "is_generated_", Atom "true" -> - ("is_generated_", S.List [ Atom "is_generated"; Atom "true" ]) :: acc - | "args", List [] when ctor = "Texpr_continue" -> acc - | "arg", List [] when ctor = "Texpr_break" -> acc - | "is_main", S.Atom "false" -> acc - | "arity_", List [] -> acc - | "arity_", List (List param_kinds :: []) - when Lst.for_all param_kinds (function Atom "_" -> true | _ -> false) -> - acc - | "arity_", List param_kinds - when Lst.for_all param_kinds (function Atom "_" -> true | _ -> false) -> - acc - | "kind", Atom "Positional" when ctor = "Param" -> acc - | "kind", Atom "Kind_regular" - | "kind", List [ Atom "Kind_method"; List [] ] -> - acc - | ("doc_" | "intf_doc_"), List [] -> acc - | "kind_", Atom "Lambda" -> acc - | "constr_", List [] -> acc - | "augmented_by", List [] -> acc - | "is_alias_", Atom "false" -> acc - | "used_error_subtyping", Atom "false" -> acc - | "name_", List [] -> acc - | _ -> field :: acc) + Lst.fold_right fields [] (fun field -> + fun acc -> + match field with + | ("params_loc_" | "loc_" | "match_loc_" | "else_loc_" | "catch_loc_"), _ + when not !Basic_config.show_loc -> + acc + | "is_pub", S.Atom "false" -> acc + | "ty_params_", List [] -> acc + | "is_pun", Atom "false" -> acc + | "doc_", Atom "" -> acc + | "type_name", List [] -> acc + | "continue_block", List [] -> acc + | "is_generated_", Atom "false" -> acc + | "is_generated_", Atom "true" -> + ("is_generated_", S.List [ Atom "is_generated"; Atom "true" ]) :: acc + | "args", List [] when ctor = "Texpr_continue" -> acc + | "arg", List [] when ctor = "Texpr_break" -> acc + | "is_main", S.Atom "false" -> acc + | "arity_", List [] -> acc + | "arity_", List (List param_kinds :: []) + when Lst.for_all param_kinds (function Atom "_" -> true | _ -> false) + -> + acc + | "arity_", List param_kinds + when Lst.for_all param_kinds (function Atom "_" -> true | _ -> false) + -> + acc + | "kind", Atom "Positional" when ctor = "Param" -> acc + | "kind", Atom "Kind_regular" + | "kind", List [ Atom "Kind_method"; List [] ] -> + acc + | ("doc_" | "intf_doc_"), List [] -> acc + | "kind_", Atom "Lambda" -> acc + | "constr_", List [] -> acc + | "augmented_by", List [] -> acc + | "is_alias_", Atom "false" -> acc + | "used_error_subtyping", Atom "false" -> acc + | "name_", List [] -> acc + | "label", List [] -> acc + | "constraint_names", List [] -> acc + | "is_raw_", Atom "false" -> acc + | "is_raw_", Atom "true" -> ("is_raw_", List [ Atom "raw" ]) :: acc + | "guard", List [] -> acc + | _ -> field :: acc) type loc_ctx = Use_absolute_loc of absolute_loc | Use_relative_loc @@ -8544,31 +10753,30 @@ let sexp = method! visit_location env loc = match env with - | Use_absolute_loc base -> Rloc.to_loc ~base loc |> sexp_of_absolute_loc + | Use_absolute_loc base -> sexp_of_absolute_loc (Rloc.to_loc ~base loc) | Use_relative_loc -> super#visit_location env loc end -let sexp_of_impls ~use_absolute_loc impls : S.t = - let impls = - List.map - (fun impl -> - let ctx = - if use_absolute_loc then - let base = - match impl with - | Timpl_expr { loc_; _ } - | Timpl_fun_decl { loc_; _ } - | Timpl_letdef { loc_; _ } - | Timpl_stub_decl { loc_; _ } -> - loc_ - in - Use_absolute_loc base - else Use_relative_loc - in - Basic_compress_stamp.normalize (sexp#visit_impl ctx impl)) - impls - in - S.List impls +let sexp_of_impls ~use_absolute_loc impls = + (let impls = + Lst.map impls (fun impl -> + let ctx = + if use_absolute_loc then + let base = + match impl with + | Timpl_expr { loc_; _ } + | Timpl_fun_decl { loc_; _ } + | Timpl_letdef { loc_; _ } + | Timpl_stub_decl { loc_; _ } -> + loc_ + in + Use_absolute_loc base + else Use_relative_loc + in + Basic_compress_stamp.normalize (sexp#visit_impl ctx impl)) + in + S.List impls + : S.t) let sexp_of_output ?(use_absolute_loc = false) (Output { value_defs; _ }) = sexp_of_impls ~use_absolute_loc value_defs @@ -8637,7 +10845,11 @@ let loc_of_typed_expr te = | Texpr_pipe { loc_; _ } | Texpr_interp { loc_; _ } | Texpr_guard { loc_; _ } - | Texpr_guard_let { loc_; _ } -> + | Texpr_guard_let { loc_; _ } + | Texpr_array_as_view { loc_; _ } + | Texpr_is { loc_; _ } + | Texpr_and { loc_; _ } + | Texpr_or { loc_; _ } -> loc_ let loc_of_typ ty = @@ -8645,7 +10857,8 @@ let loc_of_typ ty = | Tany { loc_; _ } | Tname { loc_; _ } | Tarrow { loc_; _ } - | T_tuple { loc_; _ } -> + | T_tuple { loc_; _ } + | Tobject { loc_; _ } -> loc_ let loc_of_pipe_rhs = function diff --git a/src/typedtree_util.ml b/src/typedtree_util.ml index f417c0d..4b77e29 100644 --- a/src/typedtree_util.ml +++ b/src/typedtree_util.ml @@ -14,6 +14,7 @@ module Lst = Basic_lst +module Ident = Basic_ident let type_of_typed_expr (te : Typedtree.expr) = match te with @@ -54,8 +55,10 @@ let type_of_typed_expr (te : Typedtree.expr) = | Texpr_continue { ty; _ } | Texpr_interp { ty; _ } | Texpr_guard { ty; _ } - | Texpr_guard_let { ty; _ } -> + | Texpr_guard_let { ty; _ } + | Texpr_array_as_view { ty; _ } -> ty + | Texpr_is _ | Texpr_and _ | Texpr_or _ -> Stype.bool | Texpr_unit _ -> Stype.unit let type_of_pat (pat : Typedtree.pat) = @@ -76,7 +79,11 @@ let type_of_pat (pat : Typedtree.pat) = let stype_of_typ (typ : Typedtree.typ) = match typ with - | Tany { ty; _ } | Tarrow { ty; _ } | T_tuple { ty; _ } | Tname { ty; _ } -> + | Tany { ty; _ } + | Tarrow { ty; _ } + | T_tuple { ty; _ } + | Tname { ty; _ } + | Tobject { ty; _ } -> ty let rec not_in (name : Basic_ident.t) (fn : Typedtree.expr) = @@ -105,7 +112,7 @@ let rec not_in (name : Basic_ident.t) (fn : Typedtree.expr) = | None -> true | Some else_block -> not_in name else_block) | Texpr_function { func; _ } -> not_in name func.body - | Texpr_loop { params = _; body; args; ty = _ } -> + | Texpr_loop { params = _; body; args; ty = _; label = _ } -> Lst.for_all args (not_in name) && not_in name body | Texpr_if { cond; ifso; ifnot; _ } -> ( not_in name cond && not_in name ifso @@ -117,7 +124,8 @@ let rec not_in (name : Basic_ident.t) (fn : Typedtree.expr) = not_in name fn.body && not_in name body | Texpr_let { rhs; pat_binders = _; body; _ } -> not_in name rhs && not_in name body - | Texpr_sequence { expr1; expr2; _ } -> not_in name expr1 && not_in name expr2 + | Texpr_sequence { exprs; last_expr; _ } -> + Lst.for_all exprs (not_in name) && not_in name last_expr | Texpr_tuple { exprs; _ } -> List.for_all (not_in name) exprs | Texpr_record { fields; _ } -> Lst.for_all fields (fun (Field_def def) -> not_in name def.expr) @@ -180,6 +188,52 @@ let rec not_in (name : Basic_ident.t) (fn : Typedtree.expr) = | Some otherwise -> Lst.for_all otherwise (fun { action; pat_binders = _; _ } -> not_in name action)) + | Texpr_is { expr; _ } -> not_in name expr + | Texpr_array_as_view { array; _ } -> not_in name array + | Texpr_and { lhs; rhs; _ } | Texpr_or { lhs; rhs; _ } -> + not_in name lhs && not_in name rhs let is_rec (binder : Typedtree.binder) (fn : Typedtree.fn) = not (not_in binder.binder_id fn.body) + +let free_vars_visitor = + object + inherit [_] Typedtree.iter + + method! visit_binder (exclude, free_vars) binder = + Ident.Hashset.add exclude binder.binder_id; + Ident.Hashset.remove free_vars binder.binder_id + + method! visit_var (exclude, free_vars) var = + match var.var_id with + | Pident _ as id -> + if not (Ident.Hashset.mem exclude id) then + Ident.Hashset.add free_vars id + | Pdot _ | Plocal_method _ | Pdyntrait_method _ -> () + end + +let free_vars expr = + let exclude = Ident.Hashset.create 7 in + let free_vars = Ident.Hashset.create 7 in + free_vars_visitor#visit_expr (exclude, free_vars) expr; + free_vars + +let pat_binders_of_cond (t : Typedtree.expr) = + (let rec go (t : Typedtree.expr) (acc : Typedtree.pat_binders) = + match t with + | Texpr_is { pat_binders; _ } -> List.append pat_binders acc + | Texpr_and { lhs; rhs } -> go lhs (go rhs acc) + | _ -> acc + in + go t [] + : Typedtree.pat_binders) + +let cond_contains_is (t : Typedtree.expr) = + (let rec go (t : Typedtree.expr) = + match t with + | Texpr_is _ -> true + | Texpr_and { lhs; rhs } | Texpr_or { lhs; rhs } -> go lhs || go rhs + | _ -> false + in + go t + : bool) diff --git a/src/typer.ml b/src/typer.ml index b759c6a..551cce6 100644 --- a/src/typer.ml +++ b/src/typer.ml @@ -27,65 +27,68 @@ module Literal = Lex_literal let add_error = Typeutil.add_local_typing_error let store_error = Typeutil.store_error let take_info_partial = Typeutil.take_info_partial +let unify_expr_and_store_error = Ctype.unify_expr_and_store_error -let typing_type ~diagnostics ~tvar_env ~global_env typ : Typedtree.typ = - Typeutil.typing_type ~is_toplevel:false ~allow_private:true ~tvar_env - ~types:(Global_env.get_all_types global_env) - typ - |> take_info_partial ~diagnostics +let typing_type ~diagnostics ~tvar_env ~global_env typ = + (Typeutil.typing_type ~allow_partial:true ~allow_private:true ~tvar_env + ~types:(Global_env.get_all_types global_env) + ~local_type_env:(Global_env.get_cur_local_type_env global_env) + typ ~diagnostics + : Typedtree.typ) let typing_type_name ~diagnostics ~tvar_env ~global_env - (type_name : Syntax.type_name) : - (Typeutil.type_name * Typedtree.type_name) option = - Typeutil.typing_type_name - ~types:(Global_env.get_all_types global_env) - ~tvar_env type_name ~allow_private:true - |> take_info_partial ~diagnostics + (type_name : Syntax.type_name) = + (Typeutil.typing_type_name + ~types:(Global_env.get_all_types global_env) + ~tvar_env type_name ~allow_private:true + ~local_type_env:(Global_env.get_cur_local_type_env global_env) + ~diagnostics + : (Typeutil.type_name * Typedtree.type_name) option) let find_value ~(env : Local_env.t) ~(global_env : Global_env.t) - (id : Longident.t) ~diagnostics ~loc : Value_info.t = - match id with - | Lident name -> ( - match Local_env.find_by_name_opt env name with - | Some r -> r - | None -> - Global_env.find_value global_env id ~loc - |> take_info_partial ~diagnostics) - | Ldot _ -> - Global_env.find_value global_env id ~loc |> take_info_partial ~diagnostics + (id : Longident.t) ~diagnostics ~loc = + (match id with + | Lident name -> ( + match Local_env.find_by_name_opt env name with + | Some r -> r + | None -> Global_env.find_value global_env id ~loc ~diagnostics) + | Ldot _ -> Global_env.find_value global_env id ~loc ~diagnostics + : Value_info.t) type unify_result = | Ok - | Error of Local_diagnostics.report + | Error of Local_diagnostics.error | TraitUpCast of Type_path.t -let unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty ~actual_ty loc : - unify_result = - let expect_ty' = Stype.type_repr expect_ty in - let actual_ty' = Stype.type_repr actual_ty in - let fallback () = - match Ctype.unify_expr ~expect_ty ~actual_ty loc with - | None -> Ok - | Some err -> Error err - [@@inline] - in - if Basic_prelude.phys_equal expect_ty' actual_ty' then Ok - else - match expect_ty' with - | T_trait expect_trait -> ( - match actual_ty' with - | T_trait actual_trait when Type_path.equal expect_trait actual_trait -> - Ok - | Tvar _ -> fallback () - | _ -> - let closure = - Trait_closure.compute_closure - ~types:(Global_env.get_all_types global_env) - [ { trait = expect_trait; loc_ = loc; required_by_ = [] } ] - in - List.iter (Poly_type.add_constraint cenv actual_ty') closure; - TraitUpCast expect_trait) - | _ -> fallback () +let unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty ~actual_ty loc = + (let expect_ty' = Stype.type_repr expect_ty in + let actual_ty' = Stype.type_repr actual_ty in + let fallback () = + match Ctype.unify_expr ~expect_ty ~actual_ty loc with + | None -> Ok + | Some err -> Error err + [@@inline] + in + if Basic_prelude.phys_equal expect_ty' actual_ty' then Ok + else + match expect_ty' with + | T_trait expect_trait -> ( + match actual_ty' with + | T_trait actual_trait when Type_path.equal expect_trait actual_trait + -> + Ok + | Tvar _ -> fallback () + | _ -> + let closure = + Trait_closure.compute_closure + ~types:(Global_env.get_all_types global_env) + [ { trait = expect_trait; loc_ = loc; src_ = Direct } ] + in + Basic_lst.iter closure + ~f:(Poly_type.add_constraint cenv actual_ty'); + TraitUpCast expect_trait) + | _ -> fallback () + : unify_result) let handle_unify_result (result : unify_result) ~diagnostics ~expr = match result with @@ -107,25 +110,24 @@ let handle_unify_result (result : unify_result) ~diagnostics ~expr = type maybe_typed = Typechecked of Typedtree.expr | Not_yet of Syntax.expr let wrap_newtype_constr (newtype_constr : Typedecl_info.constructor) - (expr : Typedtree.expr) newtype_typ (loc : Rloc.t) = + (expr : Typedtree.expr) newtype_typ (loc : Rloc.t) ~diagnostics = + (match newtype_constr.cs_vis with + | Readable -> + if Stype.is_external newtype_typ then + add_error diagnostics + (Errors.readonly_type ~name:newtype_constr.constr_name ~loc) + | Invisible | Read_write -> ()); let ty = Typedtree_util.type_of_typed_expr expr in let constr_desc = newtype_constr in - let syntax_constr : Syntax.constructor = - { - constr_name = - { name = newtype_constr.constr_name; loc_ = Rloc.no_location }; - extra_info = No_extra_info; - loc_ = Rloc.no_location; - } - in let constr_expr = Typedtree.Texpr_constr { - constr = syntax_constr; + type_name = None; + constr = { name = newtype_constr.constr_name; loc_ = Rloc.no_location }; tag = constr_desc.cs_tag; - ty = Builtin.type_arrow [ ty ] newtype_typ ~err_ty:None; + ty = Builtin.type_arrow [ ty ] newtype_typ ~err_ty:None ~is_async:false; arity_ = constr_desc.cs_arity_; - loc_ = loc; + loc_ = Rloc.no_location; } in Typedtree.Texpr_apply @@ -141,1639 +143,1778 @@ type expect_ty = Expect_type of Stype.t | Ignored let get_expected_type = function Expect_type ty -> ty | Ignored -> Stype.unit -let desugar_multiline_string ~loc_ elems : Syntax.expr = - if List.for_all Typeutil.is_raw_string elems then - let lines = - List.map - (function - | Syntax.Multiline_string s -> s - | Syntax.Multiline_interp _ -> assert false) - elems - in - let str = String.concat "\n" lines in - Pexpr_constant - { c = Const_string { string_val = str; string_repr = str }; loc_ } - else - let newline = - Syntax.Interp_lit { str = "\n"; repr = ""; loc_ = Rloc.no_location } - in - let rec loop elems acc = - match elems with - | [] -> acc - | x :: xs -> - let acc = - match x with - | Syntax.Multiline_string str -> - Syntax.Interp_lit { str; repr = ""; loc_ = Rloc.no_location } - :: acc - | Multiline_interp interps -> List.rev_append interps acc - in - if xs = [] then acc else loop xs (newline :: acc) - in - let rev_interps = loop elems [] in - let elems = - List.fold_left - (fun acc interp -> - match (interp, acc) with - | _, [] -> [ interp ] - | ( Syntax.Interp_lit { str = s1; repr = _ }, - Syntax.Interp_lit { str = s2; repr = _; loc_ } :: acc ) -> - Interp_lit { str = s1 ^ s2; repr = ""; loc_ } :: acc - | _, _ -> interp :: acc) - [] rev_interps - in - Syntax.Pexpr_interp { elems; loc_ } +let desugar_multiline_string ~loc_ elems = + (if List.for_all Typeutil.is_raw_string elems then + let lines = + Lst.map elems (function + | Syntax.Multiline_string s -> s + | Syntax.Multiline_interp _ -> assert false) + in + let str = String.concat "\n" lines in + Pexpr_constant + { c = Const_string { string_val = str; string_repr = str }; loc_ } + else + let newline = + Syntax.Interp_lit { str = "\n"; repr = ""; loc_ = Rloc.no_location } + in + let rec loop elems acc = + match elems with + | [] -> acc + | x :: xs -> + let acc = + match x with + | Syntax.Multiline_string str -> + Syntax.Interp_lit { str; repr = ""; loc_ = Rloc.no_location } + :: acc + | Multiline_interp interps -> List.rev_append interps acc + in + if xs = [] then acc else loop xs (newline :: acc) + in + let rev_interps = loop elems [] in + let elems = + List.fold_left + (fun acc -> + fun interp -> + match (interp, acc) with + | _, [] -> [ interp ] + | ( Syntax.Interp_lit { str = s1; repr = _ }, + Syntax.Interp_lit { str = s2; repr = _; loc_ } :: acc ) -> + Interp_lit { str = s1 ^ s2; repr = ""; loc_ } :: acc + | _, _ -> interp :: acc) + [] rev_interps + in + Syntax.Pexpr_interp { elems; loc_ } + : Syntax.expr) + +let expect_bool = Expect_type Stype.bool let rec infer_expr (env : Local_env.t) (expr : Syntax.expr) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let check_go = - check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let infer_go = - infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - match expr with - | Pexpr_array_get _ | Pexpr_array_get_slice _ | Pexpr_array_set _ -> - assert false - | Pexpr_array_augmented_set _ -> assert false - | Pexpr_unary _ -> assert false - | Pexpr_constr { constr; loc_ } -> - typing_constr_or_constant constr None ~expect_ty:None ~env ~loc:loc_ - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_apply { func = Pexpr_constr { constr }; args; attr; loc_ } -> - (if attr <> No_attr then - let error = Errors.invalid_apply_attr ~kind:`Constructor ~loc:loc_ in - add_error diagnostics error); - typing_constr_or_constant constr (Some args) ~expect_ty:None ~env - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_apply { func; args; attr; loc_ } -> - typing_application env (infer_go env func) args - ~kind:(Normal : Typedtree.apply_kind) - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics - | Pexpr_infix - { op = { var_name = Lident "&&"; loc_ = infix_loc }; lhs; rhs; loc_ } -> - let fn = - Typedtree.Texpr_ident - { - id = - { - var_id = Ident.of_qual_ident Basic_qual_ident.op_and; - loc_ = infix_loc; - }; - kind = Prim Primitive.Psequand; - ty = - Tarrow - { - params_ty = [ Stype.bool; Stype.bool ]; - ret_ty = Stype.bool; - err_ty = None; - generic_ = false; - }; - ty_args_ = [||]; - arity_ = Some (Fn_arity.simple 2); - loc_ = infix_loc; - } - in - let tlhs = check_go env lhs (Expect_type Stype.bool) in - let trhs = check_go env rhs (Expect_type Stype.bool) in - Texpr_apply - { - func = fn; - args = - [ - { arg_kind = Positional; arg_value = tlhs }; - { arg_kind = Positional; arg_value = trhs }; - ]; - ty = Stype.bool; - kind_ = Infix; - loc_; - } - | Pexpr_infix - { op = { var_name = Lident "||"; loc_ = infix_loc }; lhs; rhs; loc_ } -> - let fn = - Typedtree.Texpr_ident - { - id = - { - var_id = Ident.of_qual_ident Basic_qual_ident.op_or; - loc_ = infix_loc; - }; - kind = Prim Primitive.Psequor; - ty = - Tarrow - { - params_ty = [ Stype.bool; Stype.bool ]; - ret_ty = Stype.bool; - err_ty = None; - generic_ = false; - }; - ty_args_ = [||]; - arity_ = Some (Fn_arity.simple 2); - loc_ = infix_loc; - } - in - let tlhs = check_go env lhs (Expect_type Stype.bool) in - let trhs = check_go env rhs (Expect_type Stype.bool) in - Texpr_apply - { - func = fn; - args = - [ - { arg_kind = Positional; arg_value = tlhs }; - { arg_kind = Positional; arg_value = trhs }; - ]; - ty = Stype.bool; - kind_ = Infix; - loc_; - } - | Pexpr_infix - { op = { var_name = Lident ("..=" | "..<"); loc_ = infix_loc_ }; loc_; _ } - -> - add_error diagnostics (Errors.range_operator_only_in_for infix_loc_); - Texpr_hole - { ty = Stype.new_type_var Tvar_error; loc_; kind = Synthesized } - | Pexpr_infix { op; lhs; rhs; loc_ } -> - typing_infix_op env op (infer_go env lhs) rhs ~loc:loc_ ~global_env ~cenv - ~tvar_env ~control_ctx ~diagnostics - | Pexpr_array { exprs; loc_ } -> - let ty = Stype.new_type_var Tvar_normal in - let tes = Lst.map exprs (fun e -> check_go env e (Expect_type ty)) in - Texpr_array - { - exprs = tes; - ty = - Stype.T_constr - { - type_constructor = Type_path.Builtin.type_path_array; - tys = [ ty ]; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - }; - is_fixed_array = false; - loc_; - } - | Pexpr_array_spread { elems; loc_ } -> - typing_array_spread env elems ~loc:loc_ ~expect_ty:None ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_constant { c; loc_ } -> - let ty, c = - Typeutil.typing_constant c ~expect_ty:None ~loc:loc_ - |> take_info_partial ~diagnostics - in - Texpr_constant { c; ty; name_ = None; loc_ } - | Pexpr_multiline_string { elems; loc_ } -> - infer_go env (desugar_multiline_string ~loc_ elems) - | Pexpr_interp { elems; loc_ } -> - typing_interp ~control_ctx ~global_env ~diagnostics ~tvar_env ~cenv env - elems loc_ - | Pexpr_constraint { expr = e; ty; loc_ } -> - let ty = typing_type ~tvar_env ~global_env ty ~diagnostics in - let stype = Typedtree_util.stype_of_typ ty in - Texpr_constraint - { - expr = check_go env e (Expect_type stype); - konstraint = ty; - ty = stype; - loc_; - } - | Pexpr_while { loop_cond; loop_body; loc_; while_else } -> - check_while env loop_cond loop_body while_else - ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_function - { - func = - Lambda - { parameters; params_loc_; body; return_type; kind_; has_error }; - loc_; - } -> - let tfun, ty = - infer_function env parameters params_loc_ body return_type ~has_error - ~kind_ ~tvar_env ~cenv ~global_env ~diagnostics - in - Texpr_function { func = tfun; ty; loc_ } - | Pexpr_function { func = Match _ } -> assert false - | Pexpr_ident { id; loc_ } -> ( - let value_info = - find_value id.var_name ~env ~global_env ~diagnostics ~loc:loc_ - in - match value_info with - | Local_imm { id = var_id; typ } -> - let id : Typedtree.var = { var_id; loc_ = id.loc_ } in - let ty, (kind : Typedtree.value_kind) = - Type.deref_constr_type_to_local_value typ + ~(diagnostics : Local_diagnostics.t) = + (let check_go = + check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let infer_go = + infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + match expr with + | Pexpr_array_get _ -> assert false + | Pexpr_array_set _ -> assert false + | Pexpr_array_augmented_set _ -> assert false + | Pexpr_unary _ -> assert false + | Pexpr_array_get_slice { array; start_index; end_index; index_loc_; loc_ } + -> + let fallback () = + let desugared_expr = + Parsing_util.desugar_array_get_slice ~loc_ ~index_loc_ array + start_index end_index + in + infer_go env desugared_expr + [@@inline] + in + if start_index = None && end_index = None then + let array = infer_go env array in + match Typedtree_util.type_of_typed_expr array with + | T_constr { type_constructor; tys } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_array -> + let ty : Stype.t = + T_constr + { + type_constructor = Type_path.Builtin.type_path_arrayview; + tys; + generic_ = false; + is_suberror_ = false; + } + in + Texpr_array_as_view { array; ty; loc_ } + | _ -> fallback () + else fallback () + | Pexpr_constr { constr; loc_ } -> + typing_constr_or_constant constr None ~expect_ty:None ~env ~loc:loc_ + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_apply { func = Pexpr_constr { constr }; args; attr; loc_ } -> + (if attr <> No_attr then + let error = + Errors.invalid_apply_attr ~kind:`Constructor + ~attr:(Syntax.string_of_apply_attr attr) + ~loc:loc_ in - Texpr_ident { id; kind; ty; ty_args_ = [||]; arity_ = None; loc_ } - | Local_mut { id = var_id; typ } -> - let id : Typedtree.var = { var_id; loc_ = id.loc_ } in - Texpr_ident + add_error diagnostics error); + typing_constr_or_constant constr (Some args) ~expect_ty:None ~env + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_apply { func; args; attr; loc_ } -> + typing_application env (infer_go env func) args + ~kind:(Normal : Typedtree.apply_kind) + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics + | Pexpr_is { expr; pat; loc_ } -> + let expr = infer_go env expr in + let expr_ty = Typedtree_util.type_of_typed_expr expr in + let pat_binders, pat = + Pattern_typer.check_pat pat expr_ty ~tvar_env ~cenv ~global_env + ~diagnostics + in + Texpr_is { expr; pat; pat_binders; loc_ } + | Pexpr_infix { op = { var_name = Lident "&&" }; lhs; rhs; loc_ } -> + let tlhs = check_go env lhs expect_bool in + let pat_binders = Typedtree_util.pat_binders_of_cond tlhs in + let trhs = + check_go (Typeutil.add_pat_binders env pat_binders) rhs expect_bool + in + Texpr_and { lhs = tlhs; rhs = trhs; loc_ } + | Pexpr_infix { op = { var_name = Lident "||" }; lhs; rhs; loc_ } -> + let tlhs = check_go env lhs expect_bool in + let trhs = check_go env rhs expect_bool in + Texpr_or { lhs = tlhs; rhs = trhs; loc_ } + | Pexpr_infix + { + op = { var_name = Lident ("..=" | "..<"); loc_ = infix_loc_ }; + loc_; + _; + } -> + add_error diagnostics (Errors.range_operator_only_in_for infix_loc_); + Texpr_hole + { ty = Stype.new_type_var Tvar_error; loc_; kind = Synthesized } + | Pexpr_infix { op; lhs; rhs; loc_ } -> + typing_infix_op env op (infer_go env lhs) rhs ~loc:loc_ ~global_env ~cenv + ~tvar_env ~control_ctx ~diagnostics + | Pexpr_array { exprs; loc_ } -> + let ty = Stype.new_type_var Tvar_normal in + let tes = Lst.map exprs (fun e -> check_go env e (Expect_type ty)) in + Texpr_array + { + exprs = tes; + ty = + Stype.T_constr + { + type_constructor = Type_path.Builtin.type_path_array; + tys = [ ty ]; + generic_ = false; + is_suberror_ = false; + }; + is_fixed_array = false; + loc_; + } + | Pexpr_array_spread { elems; loc_ } -> + typing_array_spread env elems ~kind:`Array ~loc:loc_ ~expect_ty:None + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_constant { c; loc_ } -> + let ty, c = + Typeutil.typing_constant c ~expect_ty:None ~loc:loc_ ~diagnostics + in + Texpr_constant { c; ty; name_ = None; loc_ } + | Pexpr_multiline_string { elems; loc_ } -> + infer_go env (desugar_multiline_string ~loc_ elems) + | Pexpr_interp { elems; loc_ } -> + typing_interp ~control_ctx ~global_env ~diagnostics ~tvar_env ~cenv env + elems loc_ + | Pexpr_constraint { expr = e; ty; loc_ } -> + let ty = typing_type ~tvar_env ~global_env ty ~diagnostics in + let stype = Typedtree_util.stype_of_typ ty in + Texpr_constraint + { + expr = check_go env e (Expect_type stype); + konstraint = ty; + ty = stype; + loc_; + } + | Pexpr_while { loop_cond; loop_body; loc_; while_else; label } -> + check_while env loop_cond loop_body while_else ~label + ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_function + { + func = + Lambda + { + parameters; + params_loc_; + body; + return_type; + kind_; + has_error; + is_async; + }; + loc_; + } -> + let tfun, ty = + infer_function env parameters params_loc_ body return_type ~has_error + ~is_async ~kind_ ~tvar_env ~cenv ~global_env ~diagnostics + in + Texpr_function { func = tfun; ty; is_raw_ = false; loc_ } + | Pexpr_function { func = Match _ } -> assert false + | Pexpr_ident { id; loc_ } -> ( + let value_info = + find_value id.var_name ~env ~global_env ~diagnostics ~loc:loc_ + in + match value_info with + | Local_imm { id = var_id; typ } -> + let id : Typedtree.var = { var_id; loc_ = id.loc_ } in + let ty, (kind : Typedtree.value_kind) = + Type.deref_constr_type_to_local_value typ + in + Texpr_ident { id; kind; ty; ty_args_ = [||]; arity_ = None; loc_ } + | Local_mut { id = var_id; typ } -> + let id : Typedtree.var = { var_id; loc_ = id.loc_ } in + Texpr_ident + { + id; + kind = Mutable; + ty = typ; + ty_args_ = [||]; + arity_ = None; + loc_; + } + | Toplevel_value + { + id = qid; + typ; + ty_params_; + arity_; + kind; + doc_; + direct_use_loc_; + attrs; + _; + } -> + Checked_attributes.check_alerts ~diagnostics attrs loc_; + Docstring.check_alerts ~diagnostics (Docstring.pragmas doc_) loc_; + let qid = + match direct_use_loc_ with + | Explicit_import _ | Implicit_import_all _ -> + Basic_qual_ident.make_implicit_pkg + ~pkg:(Basic_qual_ident.get_pkg qid) + ~name:(Basic_qual_ident.base_name qid) + | Not_direct_use -> qid + in + let id : Typedtree.var = + { var_id = Ident.of_qual_ident qid; loc_ = id.loc_ } + in + let kind : Typedtree.value_kind = + match kind with + | Normal -> Normal + | Prim prim -> Prim prim + | Const _ -> assert false + in + if Tvar_env.is_empty ty_params_ then + Texpr_ident { id; kind; ty = typ; ty_args_ = [||]; arity_; loc_ } + else + let ty, ty_args_ = + Poly_type.instantiate_value ~cenv ~loc:loc_ ty_params_ typ + in + Texpr_ident { id; kind; ty; ty_args_; arity_; loc_ }) + | Pexpr_if { cond; ifso; ifnot; loc_ } -> ( + let cond = check_go env cond expect_bool in + let ifso_env = + Typeutil.add_pat_binders env (Typedtree_util.pat_binders_of_cond cond) + in + match ifnot with + | None -> + let ifso = check_go ifso_env ifso Ignored in + Texpr_if { cond; ifso; ifnot = None; ty = Stype.unit; loc_ } + | Some ifnot -> + let ifso = infer_go ifso_env ifso in + let ty = Typedtree_util.type_of_typed_expr ifso in + let ifnot = check_go env ifnot (Expect_type ty) in + Texpr_if { cond; ifso; ifnot = Some ifnot; ty; loc_ }) + | Pexpr_guard { cond; otherwise; body; loc_ } -> + let cond = check_go env cond expect_bool in + let guard_env = + Typeutil.add_pat_binders env (Typedtree_util.pat_binders_of_cond cond) + in + let body = infer_go guard_env body in + let ty = Typedtree_util.type_of_typed_expr body in + let otherwise = + match otherwise with + | None -> None + | Some e2 -> Some (check_go env e2 (Expect_type ty)) + in + Texpr_guard { cond; otherwise; body; ty; loc_ } + | Pexpr_guard_let { pat; expr; otherwise; body; loc_ } -> + Local_diagnostics.add_warning diagnostics + { + kind = + Deprecated_syntax + { + old_usage = "guard let"; + purpose = "shorthand of pattern match"; + new_usage = Some "guard with is-expression"; + }; + loc = Syntax.loc_of_pattern pat; + }; + let pat_binders, pat, rhs = + typing_let env pat expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let body = infer_go (Typeutil.add_pat_binders env pat_binders) body in + let ty = Typedtree_util.type_of_typed_expr body in + let otherwise = + match otherwise with + | None -> None + | Some cases -> + Some + (check_cases env cases + ~pat_ty:(Typedtree_util.type_of_typed_expr rhs) + ~action_ty:(Expect_type ty) ~tvar_env ~cenv ~global_env + ~diagnostics ~control_ctx) + in + if Check_match.irrefutable_pattern pat then + Local_diagnostics.add_warning diagnostics + { kind = Unused_guard; loc = Typedtree.loc_of_pat pat }; + Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; ty; loc_ } + | Pexpr_try + { + body; + catch; + catch_all; + try_else; + try_loc_; + catch_loc_; + else_loc_; + loc_; + } -> + let error_ctx = ref (Control_ctx.Open_ctx Empty_ctx) in + let new_ctx = Control_ctx.with_error_ctx ~error_ctx control_ctx in + let body = + infer_expr ~control_ctx:new_ctx ~tvar_env ~cenv ~global_env + ~diagnostics env body + in + let body_ty = Typedtree_util.type_of_typed_expr body in + let ty = + if try_else = None then body_ty else Stype.new_type_var Tvar_normal + in + let error_ty = Control_ctx.error_ctx_to_stype !error_ctx in + let catch = + check_cases env catch ~pat_ty:error_ty ~action_ty:(Expect_type ty) + ~tvar_env ~cenv ~global_env ~diagnostics ~control_ctx + in + let try_else = + match try_else with + | None -> None + | Some try_else -> + Some + (check_cases env try_else ~pat_ty:body_ty + ~action_ty:(Expect_type ty) ~tvar_env ~cenv ~global_env + ~diagnostics ~control_ctx) + in + if not !(new_ctx.may_has_error) then ( + Local_diagnostics.add_warning diagnostics + { kind = Useless_try; loc = try_loc_ }; + match Stype.type_repr error_ty with + | Tvar link -> link := Tlink Stype.unit + | _ -> ()); + if catch_all then ( + control_ctx.may_has_error := true; + match control_ctx.error_ctx with + | Some error_ctx -> + store_error ~diagnostics + (Control_ctx.check_error_in_ctx ~error_ty ~ctx:error_ctx + catch_loc_) + | None -> + add_error diagnostics + (Errors.invalid_raise ~kind:`Catchall ~loc:catch_loc_)); + Texpr_try + { + body; + catch; + catch_all; + try_else; + ty; + err_ty = error_ty; + catch_loc_; + else_loc_; + loc_; + } + | Pexpr_letrec { bindings = funs; body; loc_ } -> + let env_with_funs, tfuns = + typing_letrec env funs ~tvar_env ~cenv ~global_env ~diagnostics + in + let body = infer_go env_with_funs body in + Texpr_letrec + { + bindings = tfuns; + body; + ty = Typedtree_util.type_of_typed_expr body; + loc_; + } + | Pexpr_letfn { name; func; body; loc_ } -> ( + let env_with_funs, tfuns = + typing_letrec env + [ (name, func) ] + ~tvar_env ~cenv ~global_env ~diagnostics + in + let body = infer_go env_with_funs body in + match tfuns with + | (binder, fn) :: [] -> + Texpr_letfn + { + binder; + fn; + body; + ty = Typedtree_util.type_of_typed_expr body; + is_rec = Typedtree_util.is_rec binder fn; + loc_; + } + | _ -> assert false) + | Pexpr_let { pattern = p; expr = e1; body = e2; loc_; _ } -> + let pat_binders, tp, te1 = + typing_let env p e1 ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let body = infer_go (Typeutil.add_pat_binders env pat_binders) e2 in + Texpr_let + { + pat = tp; + rhs = te1; + body; + ty = Typedtree_util.type_of_typed_expr body; + pat_binders; + loc_; + } + | Pexpr_sequence { exprs; last_expr; loc_ } -> + let exprs = Lst.map exprs (fun expr -> check_go env expr Ignored) in + let last_expr = infer_go env last_expr in + let ty = Typedtree_util.type_of_typed_expr last_expr in + Texpr_sequence { exprs; last_expr; ty; loc_ } + | Pexpr_tuple { exprs; loc_ } -> + let tes = Lst.map exprs (infer_go env) in + Texpr_tuple + { + exprs = tes; + ty = + Builtin.type_product + (Lst.map tes Typedtree_util.type_of_typed_expr); + loc_; + } + | Pexpr_record { type_name; fields; loc_; trailing = _ } -> ( + let fallback type_name = + infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + [@@inline] + in + match type_name with + | Some type_name -> ( + match + typing_type_name ~global_env ~tvar_env type_name ~diagnostics + with + | Some + ( Tname_defined + { + ty_constr; + ty_desc = Record_type { has_private_field_ = true; _ }; + _; + }, + type_name ) + when Type_path_util.is_foreign ty_constr -> + let name = Type_path_util.name ty_constr in + add_error diagnostics + (Errors.cannot_create_struct_with_priv_field ~name ~loc:loc_); + fallback (Some type_name) + | Some + ( Tname_defined + ({ ty_desc = Record_type { fields = labels }; _ } as ty_decl), + type_name ) -> + Checked_attributes.check_alerts ~diagnostics ty_decl.ty_attrs + loc_; + Docstring.check_alerts ~diagnostics + (Docstring.pragmas ty_decl.ty_doc_) + loc_; + let expect_ty : Stype.t = + T_constr + { + type_constructor = ty_decl.ty_constr; + tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; + generic_ = false; + is_suberror_ = false; + } + in + let _, labels = + Poly_type.instantiate_record ~ty_record:(`Known expect_ty) + labels + in + type_guided_record_check fields labels expect_ty + ~type_name:(Some type_name) ~env ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics ~loc:loc_ + | Some + (Tname_local_type ({ kind = Struct labels; _ } as t), type_name) + -> + let expect_ty : Stype.t = + T_constr + { + type_constructor = + Type_path.local_type t.toplevel_id t.name; + tys = Tvar_env.get_types t.ty_params_; + generic_ = false; + is_suberror_ = false; + } + in + type_guided_record_check fields labels expect_ty + ~type_name:(Some type_name) ~env ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics ~loc:loc_ + | Some (_, tast_type_name) -> + add_error diagnostics + (Errors.not_a_record_type + ~name:(Longident.to_string type_name.name) + ~loc:type_name.loc_); + fallback (Some tast_type_name) + | None -> fallback None) + | None -> fallback None) + | Pexpr_record_update { type_name; record; fields; loc_ } -> + let type_name, expected_record = + match type_name with + | Some type_name -> ( + match + typing_type_name ~global_env ~tvar_env type_name ~diagnostics + with + | Some + ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), + type_name ) -> + let expect_ty : Stype.t = + T_constr + { + type_constructor = ty_decl.ty_constr; + tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; + generic_ = false; + is_suberror_ = false; + } + in + (Some type_name, check_go env record (Expect_type expect_ty)) + | Some (Tname_local_type ({ kind = Struct _; _ } as t), type_name) + -> + let expect_ty : Stype.t = + T_constr + { + type_constructor = + Type_path.local_type t.toplevel_id t.name; + tys = Tvar_env.get_types t.ty_params_; + generic_ = false; + is_suberror_ = false; + } + in + (Some type_name, check_go env record (Expect_type expect_ty)) + | Some (_, tast_type_name) -> + add_error diagnostics + (Errors.not_a_record_type + ~name:(Longident.to_string type_name.name) + ~loc:type_name.loc_); + (Some tast_type_name, infer_go env record) + | None -> (None, infer_go env record)) + | None -> (None, infer_go env record) + in + let expected_record_ty = + Typedtree_util.type_of_typed_expr expected_record + in + let typed_fields, all_fields = + match + Global_env.labels_of_record global_env ~loc:loc_ ~context:`Update + expected_record_ty + with + | Ok all_fields -> + let _, all_fields = + Poly_type.instantiate_record + ~ty_record:(`Known expected_record_ty) all_fields + in + ( type_guided_record_update_check env all_fields fields + expected_record_ty ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics, + all_fields ) + | Error e -> + add_error diagnostics e; + let pseudo_typed = + Lst.map fields (fun (Field_def { label; expr; _ }) -> + Typedtree.Field_def + { + label; + expr = infer_go env expr; + is_mut = false; + is_pun = false; + pos = 0; + }) + in + (pseudo_typed, []) + in + Texpr_record_update + { + type_name; + record = expected_record; + all_fields; + fields = typed_fields; + ty = expected_record_ty; + loc_; + } + | Pexpr_field + { + record = tuple; + accessor = Index { tuple_index = index } as accessor; + loc_; + } -> + let tuple = infer_go env tuple in + let src_ty = Stype.type_repr (Typedtree_util.type_of_typed_expr tuple) in + let tuple = deref_newtype ~global_env ~loc:loc_ tuple in + let ty_tuple = Typedtree_util.type_of_typed_expr tuple in + let ty = + match + Type.filter_product ~src_ty ~blame:Filtered_type ~arity:None ty_tuple + loc_ + with + | Ok tys -> ( + match Lst.nth_opt tys index with + | Some ty -> ty + | None -> + add_error diagnostics + (Errors.no_tuple_index ~required:index + ~actual:(List.length tys) ~loc:loc_); + Stype.new_type_var Tvar_error) + | Partial (_, errs) -> + Basic_lst.iter errs ~f:(add_error diagnostics); + Stype.new_type_var Tvar_error + in + Texpr_field { record = tuple; accessor; ty; pos = index; loc_ } + | Pexpr_field { record; accessor = Newtype; loc_ } -> ( + let record = infer_go env record in + let ty_record = Typedtree_util.type_of_typed_expr record in + match Global_env.get_newtype_info global_env ty_record with + | None -> + add_error diagnostics + (Errors.not_a_newtype + ~actual_ty:(Printer.type_to_string ty_record) + ~loc:loc_); + Texpr_field + { + record; + accessor = Newtype; + ty = Stype.new_type_var Tvar_error; + pos = Typeutil.unknown_pos; + loc_; + } + | Some info -> ( + let ty_res, ty_args = + Poly_type.instantiate_constr info.newtype_constr + in + Ctype.unify_exn ty_res ty_record; + match ty_args with + | ty :: [] -> + Texpr_field { record; accessor = Newtype; ty; pos = 0; loc_ } + | _ -> assert false)) + | Pexpr_field { record; accessor = Label label as accessor; loc_ } -> + let name = label.label_name in + let record = infer_go env record in + let ty_record = + Stype.type_repr (Typedtree_util.type_of_typed_expr record) + in + let may_be_method () = + match + Type_constraint.resolve_method_by_type ty_record name ~tvar_env + ~global_env ~src:Dot_src_direct ~loc:loc_ + with + | Ok _ -> true + | Error _ -> false + [@@inline] + in + let actual_record = deref_newtype ~global_env ~loc:loc_ record in + let ty_field, pos, _, _ = + resolve_field ~global_env actual_record label ~may_be_method + ~src_ty_record:ty_record ~diagnostics ~loc:loc_ + in + Texpr_field + { record = actual_record; accessor; ty = ty_field; pos; loc_ } + | Pexpr_method { type_name; method_name; loc_ } -> ( + let fallback type_name err = + (add_error diagnostics err; + Texpr_method { - id; - kind = Mutable; - ty = typ; + type_name; + meth = + { + var_id = Ident.fresh method_name.label_name; + loc_ = method_name.loc_; + }; ty_args_ = [||]; arity_ = None; + prim = None; + ty = Stype.new_type_var Tvar_error; loc_; } - | Toplevel_value - { id = qid; typ; ty_params_; arity_; kind; doc_; direct_use_loc_; _ } - -> - Docstring.check_alerts ~diagnostics (Docstring.pragmas doc_) loc_; - let qid = - match direct_use_loc_ with - | Explicit_import _ | Implicit_import_all _ -> - Basic_qual_ident.make_implicit_pkg - ~pkg:(Basic_qual_ident.get_pkg qid) - ~name:(Basic_qual_ident.base_name qid) - | Not_direct_use -> qid - in - let id : Typedtree.var = - { var_id = Ident.of_qual_ident qid; loc_ = id.loc_ } - in - let kind : Typedtree.value_kind = - match kind with - | Normal -> Normal - | Prim prim -> Prim prim - | Const _ -> assert false - in - if Tvar_env.is_empty ty_params_ then - Texpr_ident { id; kind; ty = typ; ty_args_ = [||]; arity_; loc_ } - else - let ty, ty_args_ = - Poly_type.instantiate_value ~cenv ~loc:loc_ ty_params_ typ - in - Texpr_ident { id; kind; ty; ty_args_; arity_; loc_ }) - | Pexpr_if { cond; ifso; ifnot; loc_ } -> ( - let cond = check_go env cond (Expect_type Stype.bool) in - match ifnot with - | None -> - let ifso = check_go env ifso Ignored in - Texpr_if { cond; ifso; ifnot = None; ty = Stype.unit; loc_ } - | Some ifnot -> - let ifso = infer_go env ifso in - let ty = Typedtree_util.type_of_typed_expr ifso in - let ifnot = check_go env ifnot (Expect_type ty) in - Texpr_if { cond; ifso; ifnot = Some ifnot; ty; loc_ }) - | Pexpr_guard { cond; otherwise; body; loc_ } -> - let cond = check_go env cond (Expect_type Stype.bool) in - let body = infer_go env body in - let ty = Typedtree_util.type_of_typed_expr body in - let otherwise = - match otherwise with - | None -> None - | Some e2 -> Some (check_go env e2 (Expect_type ty)) - in - Texpr_guard { cond; otherwise; body; ty; loc_ } - | Pexpr_guard_let { pat; expr; otherwise; body; loc_ } -> - let pat_binders, pat, rhs = - typing_let env pat expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let body = infer_go (Typeutil.add_pat_binders env pat_binders) body in - let ty = Typedtree_util.type_of_typed_expr body in - let check_cases cases pat_ty action_ty = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p pat_ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action (Expect_type action_ty) - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - [@@inline] - in - let otherwise = - match otherwise with - | None -> None - | Some cases -> - Some (check_cases cases (Typedtree_util.type_of_typed_expr rhs) ty) - in - Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; ty; loc_ } - | Pexpr_try - { - body; - catch; - catch_all; - try_else; - try_loc_; - catch_loc_; - else_loc_; - loc_; - } -> - let error_ctx = ref (Control_ctx.Open_ctx Empty_ctx) in - let new_ctx = Control_ctx.with_error_ctx ~error_ctx control_ctx in - let body = - infer_expr ~control_ctx:new_ctx ~tvar_env ~cenv ~global_env ~diagnostics - env body - in - let body_ty = Typedtree_util.type_of_typed_expr body in - let ty = - if try_else = None then body_ty else Stype.new_type_var Tvar_normal - in - let check_cases cases pat_ty action_ty = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p pat_ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action (Expect_type action_ty) - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - [@@inline] - in - let error_ty = Control_ctx.error_ctx_to_stype !error_ctx in - let catch = check_cases catch error_ty ty in - let try_else = - match try_else with - | None -> None - | Some try_else -> Some (check_cases try_else body_ty ty) - in - if not !(new_ctx.has_error) then ( - Local_diagnostics.add_warning diagnostics - { kind = Useless_try; loc = try_loc_ }; - match Stype.type_repr error_ty with - | Tvar link -> link := Tlink Stype.unit - | _ -> ()); - if catch_all then ( - control_ctx.has_error := true; - match control_ctx.error_ctx with - | Some error_ctx -> - Control_ctx.check_error_in_ctx ~error_ty ~ctx:error_ctx catch_loc_ - |> store_error ~diagnostics - | None -> - add_error diagnostics - (Errors.invalid_raise ~kind:`Catchall ~loc:catch_loc_)); - Texpr_try - { - body; - catch; - catch_all; - try_else; - ty; - err_ty = error_ty; - catch_loc_; - else_loc_; - loc_; - } - | Pexpr_letrec { bindings = funs; body; loc_ } -> - let env_with_funs, tfuns = - typing_letrec env funs ~tvar_env ~cenv ~global_env ~diagnostics - in - let body = infer_go env_with_funs body in - Texpr_letrec - { - bindings = tfuns; - body; - ty = Typedtree_util.type_of_typed_expr body; - loc_; - } - | Pexpr_letfn { name; func; body; loc_ } -> ( - let env_with_funs, tfuns = - typing_letrec env - [ (name, func) ] - ~tvar_env ~cenv ~global_env ~diagnostics - in - let body = infer_go env_with_funs body in - match tfuns with - | (binder, fn) :: [] -> - Texpr_letfn - { - binder; - fn; - body; - ty = Typedtree_util.type_of_typed_expr body; - is_rec = Typedtree_util.is_rec binder fn; - loc_; - } - | _ -> assert false) - | Pexpr_let { pattern = p; expr = e1; body = e2; loc_; _ } -> - let pat_binders, tp, te1 = - typing_let env p e1 ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let body = infer_go (Typeutil.add_pat_binders env pat_binders) e2 in - Texpr_let - { - pat = tp; - rhs = te1; - body; - ty = Typedtree_util.type_of_typed_expr body; - pat_binders; - loc_; - } - | Pexpr_sequence { expr1; expr2; loc_ } -> - let expr1 = check_go env expr1 Ignored in - let expr2 = infer_go env expr2 in - Texpr_sequence - { expr1; expr2; ty = Typedtree_util.type_of_typed_expr expr2; loc_ } - | Pexpr_tuple { exprs; loc_ } -> - let tes = Lst.map exprs (infer_go env) in - Texpr_tuple - { - exprs = tes; - ty = - Builtin.type_product (Lst.map tes Typedtree_util.type_of_typed_expr); - loc_; - } - | Pexpr_record { type_name; fields; loc_; trailing = _ } -> ( - let fallback type_name = - infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - [@@inline] - in - match type_name with - | Some type_name -> ( - match - typing_type_name ~global_env ~tvar_env type_name ~diagnostics + : Typedtree.expr) + [@@inline] + in + let resolve_by_typename (type_name : Typedtree.type_name) = + (match + Type_constraint.resolve_method_by_type_name type_name + method_name.label_name ~loc:loc_ ~tvar_env ~global_env with - | Some - ( Tname_defined - { - ty_constr; - ty_desc = Record_type { has_private_field_ = true; _ }; - _; - }, - type_name ) - when Type_path_util.is_foreign ty_constr -> - let name = Type_path_util.name ty_constr in - add_error diagnostics - (Errors.cannot_create_struct_with_priv_field ~name ~loc:loc_); - fallback (Some type_name) - | Some - ( Tname_defined - ({ ty_desc = Record_type { fields = labels }; _ } as ty_decl), - type_name ) -> + | Ok (Known_method method_info) -> + Checked_attributes.check_alerts ~diagnostics method_info.attrs + loc_; Docstring.check_alerts ~diagnostics - (Docstring.pragmas ty_decl.ty_doc_) + (Docstring.pragmas method_info.doc_) loc_; - let expect_ty : Stype.t = - T_constr - { - type_constructor = ty_decl.ty_constr; - tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } + let ty, ty_args_ = + Poly_type.instantiate_method ~cenv ~loc:loc_ method_info in - let _, labels = - Poly_type.instantiate_record ~ty_record:(`Known expect_ty) - labels - in - type_guided_record_check fields labels expect_ty - ~type_name:(Some type_name) ~env ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics ~loc:loc_ - | Some (_, tast_type_name) -> - add_error diagnostics - (Errors.not_a_record_type - ~name:(Longident.to_string type_name.name) - ~loc:type_name.loc_); - fallback (Some tast_type_name) - | None -> fallback None) - | None -> fallback None) - | Pexpr_record_update { type_name; record; fields; loc_ } -> - let type_name, expected_record = - match type_name with - | Some type_name -> ( - match - typing_type_name ~global_env ~tvar_env type_name ~diagnostics - with - | Some - ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), - type_name ) -> - let expect_ty : Stype.t = - T_constr - { - type_constructor = ty_decl.ty_constr; - tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - (Some type_name, check_go env record (Expect_type expect_ty)) - | Some (_, tast_type_name) -> - add_error diagnostics - (Errors.not_a_record_type - ~name:(Longident.to_string type_name.name) - ~loc:type_name.loc_); - (Some tast_type_name, infer_go env record) - | None -> (None, infer_go env record)) - | None -> (None, infer_go env record) - in - let expected_record_ty = - Typedtree_util.type_of_typed_expr expected_record - in - let typed_fields, all_fields = - match - Global_env.labels_of_record global_env ~loc:loc_ ~context:`Update - expected_record_ty - with - | Ok all_fields -> - let _, all_fields = - Poly_type.instantiate_record - ~ty_record:(`Known expected_record_ty) all_fields - in - ( type_guided_record_update_check env all_fields fields - expected_record_ty ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics, - all_fields ) - | Error e -> - add_error diagnostics e; - let pseudo_typed = - Lst.map fields (fun (Field_def { label; expr; _ }) -> - Typedtree.Field_def - { - label; - expr = infer_go env expr; - is_mut = false; - is_pun = false; - pos = 0; - }) - in - (pseudo_typed, []) - in - Texpr_record_update - { - type_name; - record = expected_record; - all_fields; - fields = typed_fields; - ty = expected_record_ty; - loc_; - } - | Pexpr_field - { - record = tuple; - accessor = Index { tuple_index = index } as accessor; - loc_; - } -> ( - let tuple = infer_go env tuple in - let ty_tuple = - Stype.type_repr (Typedtree_util.type_of_typed_expr tuple) - in - let newtype_info = Global_env.get_newtype_info global_env ty_tuple in - match newtype_info with - | Some info -> ( - if index <> 0 then - add_error diagnostics - (Errors.invalid_newtype_index ~loc:loc_ - ~ty:(Printer.type_to_string ty_tuple)) - else - Local_diagnostics.add_warning diagnostics - { - kind = - Deprecated_syntax + Texpr_method + { + type_name; + meth = { - old_usage = "`.0`"; - purpose = "accessing underlying type of new type"; - new_usage = Some "`._`"; + var_id = Ident.of_qual_ident method_info.id; + loc_ = method_name.loc_; }; - loc = loc_; - }; - let ty_res, ty_args = - Poly_type.instantiate_constr info.newtype_constr - in - Ctype.unify_exn ty_res ty_tuple; - match ty_args with - | ty :: [] -> - Texpr_field - { record = tuple; accessor = Newtype; ty; pos = 0; loc_ } - | _ -> assert false) - | None -> - let ty = - match - Type.filter_product ~blame:Filtered_type ~arity:None ty_tuple loc_ + prim = method_info.prim; + ty; + ty_args_; + arity_ = Some method_info.arity_; + loc_; + } + | Ok (Promised_method { method_id; method_ty; method_arity; prim }) -> + Texpr_method + { + type_name; + meth = { var_id = method_id; loc_ = method_name.loc_ }; + prim; + ty = method_ty; + ty_args_ = [||]; + arity_ = Some method_arity; + loc_; + } + | Error err -> fallback type_name err + : Typedtree.expr) + [@@inline] + in + match typing_type_name ~global_env ~tvar_env type_name ~diagnostics with + | Some (Tname_trait { name; vis_ = Vis_default; _ }, type_name) + when Type_path_util.is_foreign name -> + fallback type_name + (Errors.cannot_use_method_of_abstract_trait ~trait:name + ~method_name:method_name.label_name ~loc:method_name.loc_) + | Some (Tname_trait decl, type_name) -> ( + match + Trait_decl.find_method decl method_name.label_name ~loc:loc_ + with + | Error err -> fallback type_name err + | Ok meth_decl -> + let self_type = Stype.new_type_var Tvar_normal in + let ty = + Poly_type.instantiate_method_decl meth_decl ~self:self_type + in + Basic_lst.iter + ~f:(Poly_type.add_constraint cenv self_type) + (Trait_closure.compute_closure + ~types:(Global_env.get_all_types global_env) + [ { trait = decl.name; loc_; src_ = Direct } ]); + Texpr_unresolved_method + { + trait_name = type_name; + method_name = method_name.label_name; + self_type; + arity_ = Some meth_decl.method_arity; + ty; + loc_; + }) + | Some (_, type_name) -> resolve_by_typename type_name + | None -> + Texpr_hole + { ty = Stype.new_type_var Tvar_error; loc_; kind = Synthesized }) + | Pexpr_dot_apply { self; method_name; args; return_self; attr; loc_ } -> + let self = infer_go env self in + let ty_self = Typedtree_util.type_of_typed_expr self in + let method_expr = + typing_self_method ty_self method_name + ~src:Type_constraint.Dot_src_direct ~loc:method_name.loc_ ~tvar_env + ~cenv ~global_env ~diagnostics + in + typing_application env method_expr args ~self + ~kind:(if return_self then Dot_return_self else Dot) + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics + | Pexpr_as { expr; trait; loc_ } -> ( + let expr = infer_go env expr in + match typing_type_name trait ~tvar_env ~global_env ~diagnostics with + | Some + ((Tname_trait trait_decl | Tname_trait_object trait_decl), type_name) + -> + if not trait.is_object then + Local_diagnostics.add_warning diagnostics + { + loc = Typedtree.loc_of_type_name type_name; + kind = + Deprecated_syntax + { + old_usage = "`Trait`"; + purpose = "trait object type"; + new_usage = Some "`&Trait`"; + }; + }; + (match + Trait_decl.check_object_safety + ~name:(Type_path_util.name trait_decl.name) + ~loc:trait.loc_ trait_decl.object_safety_ with - | Ok tys -> ( - match List.nth_opt tys index with - | Some ty -> ty - | None -> - add_error diagnostics - (Errors.no_tuple_index ~required:index - ~actual:(List.length tys) ~loc:loc_); - Stype.new_type_var Tvar_error) - | Partial (_, errs) -> - List.iter (add_error diagnostics) errs; - Stype.new_type_var Tvar_error - in - Texpr_field { record = tuple; accessor; ty; pos = index; loc_ }) - | Pexpr_field { record; accessor = Newtype; loc_ } -> ( - let record = infer_go env record in - let ty_record = Typedtree_util.type_of_typed_expr record in - match Global_env.get_newtype_info global_env ty_record with - | None -> - add_error diagnostics - (Errors.not_a_newtype - ~actual_ty:(Printer.type_to_string ty_record) - ~loc:loc_); - Texpr_field - { - record; - accessor = Newtype; - ty = Stype.new_type_var Tvar_error; - pos = Typeutil.unknown_pos; - loc_; - } - | Some info -> ( - let ty_res, ty_args = - Poly_type.instantiate_constr info.newtype_constr - in - Ctype.unify_exn ty_res ty_record; - match ty_args with - | ty :: [] -> - Texpr_field { record; accessor = Newtype; ty; pos = 0; loc_ } - | _ -> assert false)) - | Pexpr_field { record; accessor = Label label as accessor; loc_ } -> - let name = label.label_name in - let record = infer_go env record in - let ty_record = - Stype.type_repr (Typedtree_util.type_of_typed_expr record) - in - let may_be_method () = - match - Type_constraint.resolve_method_by_type ty_record name ~tvar_env - ~global_env ~src:Dot_src_direct ~loc:loc_ - with - | Ok _ -> true - | Error _ -> false - [@@inline] - in - let actual_record = deref_newtype ~global_env ~loc:loc_ record in - let ty_field, pos, _, _ = - resolve_field ~global_env actual_record label ~may_be_method - ~src_ty_record:ty_record ~diagnostics ~loc:loc_ - in - Texpr_field { record = actual_record; accessor; ty = ty_field; pos; loc_ } - | Pexpr_method { type_name; method_name; loc_ } -> ( - let fallback type_name err : Typedtree.expr = - add_error diagnostics err; - Texpr_method - { - type_name; - meth = - { - var_id = Ident.fresh method_name.label_name; - loc_ = method_name.loc_; - }; - ty_args_ = [||]; - arity_ = None; - prim = None; - ty = Stype.new_type_var Tvar_error; - loc_; - } - [@@inline] - in - let resolve_by_typename ~is_trait (type_name : Typedtree.type_name) : - Typedtree.expr = - match - Type_constraint.resolve_method_by_type_name type_name - method_name.label_name ~is_trait ~loc:loc_ ~tvar_env ~global_env - with - | Ok (Known_method method_info) -> - Docstring.check_alerts ~diagnostics - (Docstring.pragmas method_info.doc_) - loc_; - let ty, ty_args_ = - Poly_type.instantiate_method ~cenv ~loc:loc_ method_info - in - Texpr_method - { - type_name; - meth = + | Some x -> add_error diagnostics x + | _ -> ()); + let closure = + Trait_closure.compute_closure + ~types:(Global_env.get_all_types global_env) + [ { trait = trait_decl.name; loc_; src_ = Direct } ] + in + Basic_lst.iter closure + ~f: + (Poly_type.add_constraint cenv + (Typedtree_util.type_of_typed_expr expr)); + Texpr_as + { + expr; + trait = type_name; + ty = T_trait trait_decl.name; + is_implicit = false; + loc_; + } + | Some (_, type_name) -> + add_error diagnostics + (Errors.not_a_trait + ~name:(Longident.to_string trait.name) + ~loc:trait.loc_); + Texpr_as + { + expr; + trait = type_name; + ty = Stype.new_type_var Tvar_error; + is_implicit = false; + loc_; + } + | None -> + let tpath = + match trait.name with + | Lident name -> + Type_path.toplevel_type ~pkg:!Basic_config.current_package name + | Ldot { pkg; id } -> Type_path.toplevel_type ~pkg id + in + Texpr_as + { + expr; + trait = + Tname_path { name = tpath; kind = Type; loc_ = trait.loc_ }; + ty = Stype.new_type_var Tvar_error; + is_implicit = false; + loc_; + }) + | Pexpr_mutate { record; accessor; field; augmented_by; loc_ } -> ( + match accessor with + | Label label -> + typing_mutate env record label field augmented_by loc_ ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics + | Index _ | Newtype -> + add_error diagnostics (Errors.tuple_not_mutable loc_); + Texpr_tuple { exprs = []; ty = Stype.unit; loc_ }) + | Pexpr_match { expr; cases; match_loc_; loc_ } -> + let expr = infer_go env expr in + let ty1 = Typedtree_util.type_of_typed_expr expr in + let ty2 = Stype.new_type_var Tvar_normal in + let trows = + check_cases ~tvar_env ~cenv ~global_env ~diagnostics ~control_ctx env + cases ~pat_ty:ty1 ~action_ty:(Expect_type ty2) + in + Texpr_match { expr; cases = trows; ty = ty2; match_loc_; loc_ } + | Pexpr_pipe { lhs; rhs; loc_ } -> + typing_pipe env lhs rhs ~loc:loc_ ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + | Pexpr_letmut { binder; ty; expr; body; loc_ } -> + let env, binder, expr, konstraint = + typing_letmut env binder ty expr ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + let body = infer_go env body in + let ty_body = Typedtree_util.type_of_typed_expr body in + Texpr_letmut { binder; konstraint; expr; body; ty = ty_body; loc_ } + | Pexpr_assign { var; expr; augmented_by; loc_ } -> ( + let check_rhs var ty_of_var = + (match augmented_by with + | None -> + let expr = check_go env expr (Expect_type ty_of_var) in + Texpr_assign + { var; expr; augmented_by = None; ty = Stype.unit; loc_ } + | Some op -> + let tlhs : Typedtree.expr = + Texpr_ident { - var_id = Ident.of_qual_ident method_info.id; - loc_ = method_name.loc_; - }; - prim = method_info.prim; - ty; - ty_args_; - arity_ = Some method_info.arity_; - loc_; - } - | Ok (Promised_method { method_id; method_ty; method_arity; prim }) -> - Texpr_method - { - type_name; - meth = { var_id = method_id; loc_ = method_name.loc_ }; - prim; - ty = method_ty; - ty_args_ = [||]; - arity_ = Some method_arity; - loc_; - } - | Error err -> fallback type_name err - [@@inline] - in - let type_name_loc = type_name.loc_ in - match typing_type_name ~global_env ~tvar_env type_name ~diagnostics with - | Some (Tname_trait { name; vis_ = Vis_default; _ }, type_name) - when Type_path_util.is_foreign name -> - fallback type_name - (Errors.cannot_use_method_of_abstract_trait ~trait:name - ~method_name:method_name.label_name ~loc:method_name.loc_) - | Some (Tname_trait decl, type_name) -> ( - match - Trait_decl.find_method decl method_name.label_name ~loc:loc_ - with - | Error _ -> resolve_by_typename ~is_trait:true type_name - | Ok meth_decl -> - let trait_name = decl.name in - let self_type = Stype.new_type_var Tvar_normal in - let ty = - Poly_type.instantiate_method_decl meth_decl ~self:self_type + id = var; + kind = Mutable; + ty = ty_of_var; + ty_args_ = [||]; + arity_ = None; + loc_ = var.loc_; + } + in + let infix_expr = + typing_infix_op env op tlhs expr ~loc:loc_ ~global_env ~cenv + ~tvar_env ~control_ctx ~diagnostics in - Trait_closure.compute_closure - ~types:(Global_env.get_all_types global_env) - [ { trait = decl.name; loc_; required_by_ = [] } ] - |> List.iter (Poly_type.add_constraint cenv self_type); - let trait_name : Typedtree.type_path_loc = - { name = trait_name; loc_ = type_name_loc } + let op_expr, expr = + match infix_expr with + | Texpr_apply + { func; args = [ _; { arg_value; _ } ]; ty = actual_ty; _ } + -> + unify_expr_and_store_error ~expect_ty:ty_of_var ~actual_ty + ~diagnostics loc_; + (func, arg_value) + | _ -> assert false in - Texpr_unresolved_method + Texpr_assign { - trait_name; - method_name = method_name.label_name; - self_type; - arity_ = Some meth_decl.method_arity; - ty; + var; + expr; + augmented_by = Some op_expr; + ty = Stype.unit; loc_; - }) - | Some (_, type_name) -> resolve_by_typename ~is_trait:false type_name - | None -> - Texpr_hole - { ty = Stype.new_type_var Tvar_error; loc_; kind = Synthesized }) - | Pexpr_dot_apply { self; method_name; args; return_self; attr; loc_ } -> - let self = infer_go env self in - let ty_self = Typedtree_util.type_of_typed_expr self in - let method_expr = - typing_self_method ty_self method_name - ~src:Type_constraint.Dot_src_direct ~loc:method_name.loc_ ~tvar_env - ~cenv ~global_env ~diagnostics - in - typing_application env method_expr args ~self - ~kind:(if return_self then Dot_return_self else Dot) - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics - | Pexpr_as { expr; trait; loc_ } -> ( - let expr = infer_go env expr in - match typing_type_name trait ~tvar_env ~global_env ~diagnostics with - | Some (Tname_trait trait_decl, type_name) -> - Trait_decl.check_object_safety - ~name:(Type_path_util.name trait_decl.name) - ~loc:trait.loc_ trait_decl.object_safety_ - |> Option.iter (add_error diagnostics); - let closure = - Trait_closure.compute_closure - ~types:(Global_env.get_all_types global_env) - [ { trait = trait_decl.name; loc_; required_by_ = [] } ] - in - List.iter - (Poly_type.add_constraint cenv - (Typedtree_util.type_of_typed_expr expr)) - closure; - Texpr_as - { - expr; - trait = type_name; - ty = T_trait trait_decl.name; - is_implicit = false; - loc_; - } - | Some (_, type_name) -> - add_error diagnostics - (Errors.not_a_trait - ~name:(Longident.to_string trait.name) - ~loc:trait.loc_); - Texpr_as - { - expr; - trait = type_name; - ty = Stype.new_type_var Tvar_error; - is_implicit = false; - loc_; - } - | None -> - let tpath = - match trait.name with - | Lident name -> - Type_path.toplevel_type ~pkg:!Basic_config.current_package name - | Ldot { pkg; id } -> Type_path.toplevel_type ~pkg id - in - Texpr_as - { - expr; - trait = - Tname_path { name = tpath; kind = Type; loc_ = trait.loc_ }; - ty = Stype.new_type_var Tvar_error; - is_implicit = false; - loc_; - }) - | Pexpr_mutate { record; accessor; field; augmented_by; loc_ } -> ( - match accessor with - | Label label -> - typing_mutate env record label field augmented_by loc_ ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics - | Index _ | Newtype -> - add_error diagnostics (Errors.tuple_not_mutable loc_); - Texpr_tuple { exprs = []; ty = Stype.unit; loc_ }) - | Pexpr_match { expr; cases; match_loc_; loc_ } -> - let expr = infer_go env expr in - let ty1 = Typedtree_util.type_of_typed_expr expr in - let ty2 = Stype.new_type_var Tvar_normal in - let trows = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p ty1 ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action (Expect_type ty2) - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - in - Texpr_match { expr; cases = trows; ty = ty2; match_loc_; loc_ } - | Pexpr_pipe { lhs; rhs; loc_ } -> - typing_pipe env lhs rhs ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - | Pexpr_letmut { binder; ty; expr; body; loc_ } -> - let env, binder, expr, konstraint = - typing_letmut env binder ty expr ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - let body = infer_go env body in - let ty_body = Typedtree_util.type_of_typed_expr body in - Texpr_letmut { binder; konstraint; expr; body; ty = ty_body; loc_ } - | Pexpr_assign { var; expr; augmented_by; loc_ } -> ( - let check_rhs var ty_of_var : Typedtree.expr = - match augmented_by with - | None -> - let expr = check_go env expr (Expect_type ty_of_var) in - Texpr_assign - { var; expr; augmented_by = None; ty = Stype.unit; loc_ } - | Some op -> - let tlhs : Typedtree.expr = - Texpr_ident - { - id = var; - kind = Mutable; - ty = ty_of_var; - ty_args_ = [||]; - arity_ = None; - loc_ = var.loc_; } - in - let infix_expr = - typing_infix_op env op tlhs expr ~loc:loc_ ~global_env ~cenv - ~tvar_env ~control_ctx ~diagnostics - in - let op_expr, expr = - match infix_expr with - | Texpr_apply - { func; args = [ _; { arg_value; _ } ]; ty = actual_ty; _ } -> - Ctype.unify_expr ~expect_ty:ty_of_var ~actual_ty loc_ - |> store_error ~diagnostics; - (func, arg_value) - | _ -> assert false - in - Texpr_assign - { var; expr; augmented_by = Some op_expr; ty = Stype.unit; loc_ } - [@@local] - in - let value_info = - find_value var.var_name ~env ~global_env ~diagnostics ~loc:loc_ - in - match value_info with - | Local_mut { id = var_id; typ } -> - let id : Typedtree.var = { var_id; loc_ = var.loc_ } in - check_rhs id typ - | Local_imm { id = var_id; typ } -> - let id : Typedtree.var = { var_id; loc_ = var.loc_ } in - add_error diagnostics - (Errors.not_mutable ~id:var.var_name ~loc:var.loc_); - check_rhs id typ - | Toplevel_value { id; _ } -> - add_error diagnostics - (Errors.not_mutable ~id:var.var_name ~loc:var.loc_); - let id : Typedtree.var = - { var_id = Ident.of_qual_ident id; loc_ = var.loc_ } - in - check_rhs id (Stype.new_type_var Tvar_error)) - | Pexpr_hole { kind; loc_ } -> - (match kind with - | Incomplete -> add_error diagnostics (Errors.found_hole loc_) - | Synthesized -> () - | Todo -> - Local_diagnostics.add_warning diagnostics { kind = Todo; loc = loc_ }); - Texpr_hole { ty = Stype.new_type_var Tvar_normal; loc_; kind } - | Pexpr_unit { loc_; _ } -> Texpr_unit { loc_ } - | Pexpr_break { arg; loc_ } -> - check_break env arg ~loc:loc_ - ~expect_ty:(Stype.new_type_var Tvar_normal) - ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - | Pexpr_continue { args; loc_; _ } -> - check_continue env args ~loc:loc_ - ~expect_ty:(Stype.new_type_var Tvar_normal) - ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - | Pexpr_loop { args; body; loop_loc_; loc_ } -> - check_loop ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics env args - body ~loc:loc_ ~loop_loc_ - ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) - | Pexpr_for { binders; condition; continue_block; body; loc_; for_else } -> - check_for ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) - env binders condition continue_block body for_else ~loc:loc_ - | Pexpr_foreach - { - binders; - expr = - Pexpr_infix - { - op = { var_name = Lident (("..<" | "..=") as op) }; - lhs; - rhs; - loc_ = operator_loc; - }; - body; - else_block; - loc_; - } -> - let inclusive = op = "..=" in - typing_range_for_in env binders lhs rhs body else_block ~inclusive - ~operator_loc ~loc:loc_ - ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) - ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - | Pexpr_foreach { binders; expr; body; else_block; loc_ } -> - typing_foreach ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) - env binders expr body else_block ~loc:loc_ - | Pexpr_return { return_value; loc_ } -> - let ty = Stype.new_type_var Tvar_normal in - check_return_value env return_value ty ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics ~loc:loc_ - | Pexpr_raise { err_value; loc_ } -> - let ty = Stype.new_type_var Tvar_normal in - typing_raise env err_value ty ~loc:loc_ ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - | Pexpr_map { elems; loc_ } -> - typing_map_expr env elems ~expect_ty:None ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics ~loc:loc_ - | Pexpr_static_assert { asserts; body } -> - typing_static_assert ~global_env ~tvar_env ~control_ctx ~cenv ~diagnostics - ~expect_ty:None env asserts body - | Pexpr_group _ -> assert false + : Typedtree.expr) + [@@local] + in + let value_info = + find_value var.var_name ~env ~global_env ~diagnostics ~loc:loc_ + in + match value_info with + | Local_mut { id = var_id; typ } -> + let id : Typedtree.var = { var_id; loc_ = var.loc_ } in + check_rhs id typ + | Local_imm { id = var_id; typ } -> + let id : Typedtree.var = { var_id; loc_ = var.loc_ } in + add_error diagnostics + (Errors.not_mutable ~id:var.var_name ~loc:var.loc_); + check_rhs id typ + | Toplevel_value { id; _ } -> + add_error diagnostics + (Errors.not_mutable ~id:var.var_name ~loc:var.loc_); + let id : Typedtree.var = + { var_id = Ident.of_qual_ident id; loc_ = var.loc_ } + in + check_rhs id (Stype.new_type_var Tvar_error)) + | Pexpr_hole { kind; loc_ } -> + (match kind with + | Incomplete -> add_error diagnostics (Errors.found_hole loc_) + | Synthesized -> () + | Todo -> + control_ctx.may_has_error := true; + Local_diagnostics.add_warning diagnostics { kind = Todo; loc = loc_ }); + Texpr_hole { ty = Stype.new_type_var Tvar_normal; loc_; kind } + | Pexpr_unit { loc_; _ } -> Texpr_unit { loc_ } + | Pexpr_break { arg; loc_; label } -> + check_break env arg ~loc:loc_ ~label + ~expect_ty:(Stype.new_type_var Tvar_normal) + ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + | Pexpr_continue { args; loc_; label } -> + check_continue env args ~loc:loc_ ~label + ~expect_ty:(Stype.new_type_var Tvar_normal) + ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + | Pexpr_loop { args; body; label; loop_loc_; loc_ } -> + check_loop ~label ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + env args body ~loc:loc_ ~loop_loc_ + ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) + | Pexpr_for + { binders; condition; continue_block; body; label; loc_; for_else } -> + check_for ~label ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) + env binders condition continue_block body for_else ~loc:loc_ + | Pexpr_foreach + { + binders; + expr = + Pexpr_infix + { + op = { var_name = Lident (("..<" | "..=") as op) }; + lhs; + rhs; + loc_ = operator_loc; + }; + body; + else_block; + label; + loc_; + } -> + let inclusive = op = "..=" in + typing_range_for_in env binders lhs rhs body else_block ~label ~inclusive + ~operator_loc ~loc:loc_ + ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) + ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + | Pexpr_foreach { binders; expr; body; else_block; label; loc_ } -> + typing_foreach ~label ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics + ~expect_ty:(Expect_type (Stype.new_type_var Tvar_normal)) + env binders expr body else_block ~loc:loc_ + | Pexpr_return { return_value; loc_ } -> + let ty = Stype.new_type_var Tvar_normal in + check_return_value env return_value ty ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics ~loc:loc_ + | Pexpr_raise { err_value; loc_ } -> + let ty = Stype.new_type_var Tvar_normal in + typing_raise env err_value ty ~loc:loc_ ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + | Pexpr_map { elems; loc_ } -> + typing_map_expr env elems ~expect_ty:None ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics ~loc:loc_ + | Pexpr_static_assert { asserts; body } -> + typing_static_assert ~global_env ~tvar_env ~control_ctx ~diagnostics + ~expect_ty:None env asserts body + | Pexpr_group _ -> assert false + : Typedtree.expr) + +and check_cases (env : Local_env.t) ~tvar_env ~cenv ~global_env ~diagnostics + ~control_ctx (cases : Syntax.case list) ~pat_ty ~action_ty = + (Lst.map cases (fun { pattern = p; guard; body = action } -> + let pat_binders, tpat = + Pattern_typer.check_pat p pat_ty ~tvar_env ~cenv ~global_env + ~diagnostics + in + let env1 = Typeutil.add_pat_binders env pat_binders in + let guard, env2 = + match guard with + | None -> (None, env1) + | Some guard -> + let guard = + check_expr env1 guard (Expect_type Stype.bool) ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics + in + ( Some guard, + Typeutil.add_pat_binders env1 + (Typedtree_util.pat_binders_of_cond guard) ) + in + let taction = + check_expr env2 action action_ty ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + ({ pat = tpat; action = taction; pat_binders; guard } + : Typedtree.match_case)) + : Typedtree.match_case list) and check_return_value (env : Local_env.t) (return_value : Syntax.expr option) (expected_ty : Stype.t) ~loc ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics : Typedtree.expr = - match control_ctx.return with - | Some ret_ty -> - let return_value = - match return_value with - | Some ret_value -> - Some - (check_expr env ret_value (Expect_type ret_ty) ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics) - | None -> - Ctype.unify_expr ~expect_ty:ret_ty ~actual_ty:Stype.unit loc - |> store_error ~diagnostics; - None - in - Texpr_return { return_value; ty = expected_ty; loc_ = loc } - | None -> ( - add_error diagnostics (Errors.invalid_return loc); - match return_value with - | Some ret_value -> - infer_expr env ret_value ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - | None -> Texpr_unit { loc_ = loc }) + ~diagnostics = + (match control_ctx.return with + | Some ret_ty -> + let return_value = + match return_value with + | Some ret_value -> + Some + (check_expr env ret_value (Expect_type ret_ty) ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics) + | None -> + unify_expr_and_store_error ~expect_ty:ret_ty ~actual_ty:Stype.unit + ~diagnostics loc; + None + in + Texpr_return { return_value; ty = expected_ty; loc_ = loc } + | None -> ( + add_error diagnostics (Errors.invalid_return loc); + match return_value with + | Some ret_value -> + infer_expr env ret_value ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + | None -> Texpr_unit { loc_ = loc }) + : Typedtree.expr) and typing_raise (env : Local_env.t) (err_value : Syntax.expr) (expect_ty : Stype.t) ~loc ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics : Typedtree.expr = - let loc_ = loc in - let make_raise error_value : Typedtree.expr = - Texpr_raise { error_value; ty = expect_ty; loc_ } - [@@local] - in - control_ctx.has_error := true; - match control_ctx.error_ctx with - | Some error_ctx -> - let error_value = - infer_expr env err_value ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let actual_ty = Typedtree_util.type_of_typed_expr error_value in - Poly_type.add_constraint cenv actual_ty - { - trait = Type_path.Builtin.type_path_error; - loc_ = loc; - required_by_ = []; - }; - Control_ctx.check_error_in_ctx ~error_ty:actual_ty ~ctx:error_ctx loc_ - |> store_error ~diagnostics; - make_raise error_value - | None -> - add_error diagnostics (Errors.invalid_raise ~kind:`Raise ~loc); - let error_value = - infer_expr env err_value ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - Poly_type.add_constraint cenv - (Typedtree_util.type_of_typed_expr error_value) - { - trait = Type_path.Builtin.type_path_error; - loc_ = loc; - required_by_ = []; - }; - Texpr_raise { error_value; ty = expect_ty; loc_ } + ~diagnostics = + (let loc_ = loc in + let make_raise error_value = + (Texpr_raise { error_value; ty = expect_ty; loc_ } : Typedtree.expr) + [@@local] + in + control_ctx.may_has_error := true; + match control_ctx.error_ctx with + | Some error_ctx -> + let error_value = + infer_expr env err_value ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let actual_ty = Typedtree_util.type_of_typed_expr error_value in + Poly_type.add_constraint cenv actual_ty + { + trait = Type_path.Builtin.type_path_error; + loc_ = loc; + src_ = Direct; + }; + store_error ~diagnostics + (Control_ctx.check_error_in_ctx ~error_ty:actual_ty ~ctx:error_ctx loc_); + make_raise error_value + | None -> + add_error diagnostics (Errors.invalid_raise ~kind:`Raise ~loc); + let error_value = + infer_expr env err_value ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + Poly_type.add_constraint cenv + (Typedtree_util.type_of_typed_expr error_value) + { + trait = Type_path.Builtin.type_path_error; + loc_ = loc; + src_ = Direct; + }; + Texpr_raise { error_value; ty = expect_ty; loc_ } + : Typedtree.expr) and typing_infix_op (env : Local_env.t) (op : Syntax.var) (lhs : Typedtree.expr) (rhs : Syntax.expr) ~loc ~global_env ~cenv ~tvar_env ~control_ctx - ~diagnostics : Typedtree.expr = - let op_name = - match op with { var_name = Lident name; _ } -> name | _ -> assert false - in - let op_info = Operators.find_exn op_name in - let ty_lhs = Typedtree_util.type_of_typed_expr lhs in - let op_expr, rhs = - match - ( Specialize_operator.try_specialize_op ~op_info ~ty_lhs ~loc:op.loc_, - op_info ) - with - | Some tmethod, _ -> (tmethod, Not_yet rhs) - | None, { impl = Regular_function; method_name; _ } -> - let op_expr = - infer_expr env - (Pexpr_ident - { - id = { op with var_name = Lident method_name }; - loc_ = op.loc_; - }) - ~global_env ~cenv ~tvar_env ~control_ctx ~diagnostics - in - (op_expr, Not_yet rhs) - | None, { impl = Trait_method trait; method_name; _ } -> - let op : Typedtree.expr = - match Global_env.find_trait_by_path global_env trait with - | None -> - add_error diagnostics - (Errors.pkg_not_imported ~name:(Type_path.get_pkg trait) - ~action:("use operator `" ^ op_name ^ "`" : Stdlib.String.t) - ~loc:op.loc_); - Texpr_hole + ~diagnostics = + (let op_name = + match op with { var_name = Lident name; _ } -> name | _ -> assert false + in + let op_info = Operators.find_exn op_name in + let ty_lhs = Typedtree_util.type_of_typed_expr lhs in + let op_expr, rhs = + match + ( Specialize_operator.try_specialize_op ~op_info ~ty_lhs ~loc:op.loc_, + op_info ) + with + | Some tmethod, _ -> (tmethod, Not_yet rhs) + | None, { impl = Regular_function; method_name; _ } -> + let op_expr = + infer_expr env + (Pexpr_ident { - ty = Stype.new_type_var Tvar_error; - kind = Synthesized; + id = { op with var_name = Lident method_name }; loc_ = op.loc_; - } - | Some trait_decl -> ( - match - Trait_decl.find_method trait_decl method_name ~loc:op.loc_ - with - | Error err -> - add_error diagnostics err; - Texpr_hole - { - ty = Stype.new_type_var Tvar_error; - kind = Synthesized; - loc_ = op.loc_; - } - | Ok meth_decl -> - let trait_name = trait_decl.name in - let self_type = Stype.new_type_var Tvar_normal in - let ty = - Poly_type.instantiate_method_decl meth_decl ~self:self_type - in - Trait_closure.compute_closure - ~types:(Global_env.get_all_types global_env) - [ - { trait = trait_name; loc_ = op.loc_; required_by_ = [] }; - ] - |> List.iter (Poly_type.add_constraint cenv self_type); - let trait_name : Typedtree.type_path_loc = - { name = trait_name; loc_ = Rloc.no_location } - in - Texpr_unresolved_method - { - trait_name; - method_name; - self_type; - arity_ = Some meth_decl.method_arity; - ty; - loc_ = op.loc_; - }) - in - (op, Not_yet rhs) - | None, { impl = Method | Method_with_default _; _ } -> - let ty_self, rhs_maybe_typed = - if not (Typeutil.is_tvar ty_lhs) then (ty_lhs, Not_yet rhs) - else - let trhs = - infer_expr env rhs ~global_env ~cenv ~tvar_env ~control_ctx - ~diagnostics - in - let ty_rhs = Typedtree_util.type_of_typed_expr trhs in - if not (Typeutil.is_tvar ty_rhs) then (ty_rhs, Typechecked trhs) - else - match op_info.impl with - | Method_with_default - (( T_unit | T_bool | T_byte | T_char | T_int | T_int64 - | T_uint | T_uint64 | T_float | T_double | T_string ) as - default) -> - let self_ty : Stype.t = - T_constr - { - type_constructor = default; - tys = []; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - (self_ty, Typechecked trhs) - | Method_with_default - ( T_option | T_result | T_error_value_result | T_fixedarray - | T_bytes | T_ref | T_error | Toplevel _ | Tuple _ | Constr _ - ) -> - assert false - | Method | Regular_function | Trait_method _ -> - (ty_lhs, Typechecked trhs) - in - let label : Syntax.label = - { label_name = op_info.method_name; loc_ = op.loc_ } - in - let tmethod = - typing_self_method ty_self label ~global_env ~tvar_env ~cenv - ~src:(Type_constraint.Dot_src_infix op_info) - ~loc:(Rloc.merge (Typedtree.loc_of_typed_expr lhs) op.loc_) - ~diagnostics - in - (tmethod, rhs_maybe_typed) - in - match[@warning "-fragile-match"] - Type.filter_arrow ~blame:Filtered_type ~has_error:false 2 - (Typedtree_util.type_of_typed_expr op_expr) - loc - |> take_info_partial ~diagnostics - with - | [ ty_param1; ty_param2 ], ty_res, ty_err -> - (match ty_err with - | None -> () - | Some err_ty -> - let err_ty_str = Printer.type_to_string err_ty in - let err = Errors.unhandled_error ~err_ty:err_ty_str ~loc in - add_error diagnostics err); - let tlhs = - unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty:ty_param1 - ~actual_ty:(Typedtree_util.type_of_typed_expr lhs) - (Typedtree.loc_of_typed_expr lhs) - |> handle_unify_result ~diagnostics ~expr:lhs - in - let trhs = - maybe_check env rhs ty_param2 ~tvar_env ~control_ctx ~cenv ~global_env - ~diagnostics - in - Texpr_apply - { - func = op_expr; - args = - [ - { arg_value = tlhs; arg_kind = Positional }; - { arg_value = trhs; arg_kind = Positional }; - ]; - ty = ty_res; - kind_ = Infix; - loc_ = loc; - } - | _ -> assert false + }) + ~global_env ~cenv ~tvar_env ~control_ctx ~diagnostics + in + (op_expr, Not_yet rhs) + | None, { impl = Trait_method trait; method_name; _ } -> + let op : Typedtree.expr = + match Global_env.find_trait_by_path global_env trait with + | None -> + add_error diagnostics + (Errors.pkg_not_imported ~name:(Type_path.get_pkg trait) + ~action: + (("use operator `" ^ op_name ^ "`" + : Stdlib.String.t) + [@merlin.hide]) + ~loc:op.loc_); + Texpr_hole + { + ty = Stype.new_type_var Tvar_error; + kind = Synthesized; + loc_ = op.loc_; + } + | Some trait_decl -> ( + match + Trait_decl.find_method trait_decl method_name ~loc:op.loc_ + with + | Error err -> + add_error diagnostics err; + Texpr_hole + { + ty = Stype.new_type_var Tvar_error; + kind = Synthesized; + loc_ = op.loc_; + } + | Ok meth_decl -> + let trait_name = trait_decl.name in + let self_type = Stype.new_type_var Tvar_normal in + let ty = + Poly_type.instantiate_method_decl meth_decl ~self:self_type + in + Basic_lst.iter + ~f:(Poly_type.add_constraint cenv self_type) + (Trait_closure.compute_closure + ~types:(Global_env.get_all_types global_env) + [ + { trait = trait_name; loc_ = op.loc_; src_ = Direct }; + ]); + let trait_name : Typedtree.type_name = + Tname_path + { + name = trait_name; + kind = Trait; + loc_ = Rloc.no_location; + } + in + Texpr_unresolved_method + { + trait_name; + method_name; + self_type; + arity_ = Some meth_decl.method_arity; + ty; + loc_ = op.loc_; + }) + in + (op, Not_yet rhs) + | None, { impl = Method | Method_with_default _; _ } -> + let ty_self, rhs_maybe_typed = + if not (Typeutil.is_tvar ty_lhs) then (ty_lhs, Not_yet rhs) + else + let trhs = + infer_expr env rhs ~global_env ~cenv ~tvar_env ~control_ctx + ~diagnostics + in + let ty_rhs = Typedtree_util.type_of_typed_expr trhs in + if not (Typeutil.is_tvar ty_rhs) then (ty_rhs, Typechecked trhs) + else + match op_info.impl with + | Method_with_default + (( T_unit | T_bool | T_byte | T_int16 | T_uint16 | T_char + | T_int | T_int64 | T_uint | T_uint64 | T_float | T_double + | T_string ) as default) -> + let self_ty : Stype.t = + T_constr + { + type_constructor = default; + tys = []; + generic_ = false; + is_suberror_ = false; + } + in + (self_ty, Typechecked trhs) + | Method_with_default + ( T_option | T_result | T_error_value_result | T_fixedarray + | T_bytes | T_ref | T_error | Toplevel _ | Tuple _ | Constr _ + | T_local _ ) -> + assert false + | Method | Regular_function | Trait_method _ -> + (ty_lhs, Typechecked trhs) + in + let label : Syntax.label = + { label_name = op_info.method_name; loc_ = op.loc_ } + in + let tmethod = + typing_self_method ty_self label ~global_env ~tvar_env ~cenv + ~src:(Type_constraint.Dot_src_infix op_info) + ~loc:(Rloc.merge (Typedtree.loc_of_typed_expr lhs) op.loc_) + ~diagnostics + in + (tmethod, rhs_maybe_typed) + in + match[@warning "-fragile-match"] + take_info_partial ~diagnostics + (Type.filter_arrow ~blame:Filtered_type ~has_error:false ~is_async:false + 2 + (Typedtree_util.type_of_typed_expr op_expr) + loc) + with + | [ ty_param1; ty_param2 ], ty_res, ty_err -> + (match ty_err with + | None -> () + | Some err_ty -> + let err_ty_str = Printer.type_to_string err_ty in + let err = Errors.unhandled_error ~err_ty:err_ty_str ~loc in + add_error diagnostics err); + let tlhs = + handle_unify_result ~diagnostics ~expr:lhs + (unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty:ty_param1 + ~actual_ty:(Typedtree_util.type_of_typed_expr lhs) + (Typedtree.loc_of_typed_expr lhs)) + in + let trhs = + maybe_check env rhs ty_param2 ~tvar_env ~control_ctx ~cenv ~global_env + ~diagnostics + in + Texpr_apply + { + func = op_expr; + args = + [ + { arg_value = tlhs; arg_kind = Positional }; + { arg_value = trhs; arg_kind = Positional }; + ]; + ty = ty_res; + kind_ = Infix; + loc_ = loc; + } + | _ -> assert false + : Typedtree.expr) and typing_application ?(expect_ty : Stype.t option) ?(self : Typedtree.expr option) (env : Local_env.t) (func : Typedtree.expr) (args : Syntax.argument list) ~(kind : Typedtree.apply_kind) ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~(attr : Syntax.apply_attr) - ~diagnostics : Typedtree.expr = - let n = List.length args + match self with None -> 0 | _ -> 1 in - let func_ty = Stype.type_repr (Typedtree_util.type_of_typed_expr func) in - let err_ty = Stype.new_type_var Tvar_normal in - let check_error_type actual_err_type = - match attr with - | Question -> ( - match actual_err_type with - | None -> - add_error diagnostics - (Errors.invalid_apply_attr ~kind:`NoErrorType ~loc) - | Some actual_err_ty -> Ctype.unify_exn err_ty actual_err_ty) - | Exclamation -> ( - control_ctx.has_error := true; - match actual_err_type with - | None -> - add_error diagnostics - (Errors.invalid_apply_attr ~kind:`NoErrorType ~loc) - | Some actual_err_type -> ( - match control_ctx.error_ctx with - | None -> - let error = Errors.invalid_raise ~kind:`Rethrow ~loc in - add_error diagnostics error - | Some error_ctx -> - Control_ctx.check_error_in_ctx ~error_ty:actual_err_type - ~ctx:error_ctx loc - |> store_error ~diagnostics)) - | No_attr -> ( - match actual_err_type with - | None -> () - | Some actual_err_type -> - let err_ty = Printer.type_to_string actual_err_type in - add_error diagnostics (Errors.unhandled_error ~err_ty ~loc)) - in - let delayed_error_type_check = ref None in - let ty_params, ty_res, should_report_error = - match func_ty with - | Tarrow { params_ty; ret_ty; err_ty } -> - (match err_ty with - | Some t when Typeutil.is_tvar t -> - delayed_error_type_check := Some (fun () -> check_error_type err_ty) - | _ -> check_error_type err_ty); - (params_ty, ret_ty, true) - | Tvar ({ contents = Tnolink tvar_kind } as link) -> - let params_ty = Type.type_var_list n tvar_kind in - let ret_ty = Stype.new_type_var tvar_kind in - link := - Tlink (Tarrow { params_ty; ret_ty; err_ty = None; generic_ = false }); - if attr <> No_attr then - add_error diagnostics - (Errors.invalid_apply_attr ~kind:`UnknownType ~loc); - if - tvar_kind = Tvar_normal - && Lst.exists args (fun a -> a.arg_kind <> Positional) - then - add_error diagnostics - (Errors.nontoplevel_func_cannot_have_labelled_arg ~loc); - (params_ty, ret_ty, false) - | _ -> - let params_ty = Type.type_var_list n Tvar_error in - let ret_ty = Stype.new_type_var Tvar_error in - (if func_ty <> T_blackhole then - let expected, actual = - ("function type", Printer.type_to_string func_ty) - in - add_error diagnostics (Errors.type_mismatch ~expected ~actual ~loc)); - (params_ty, ret_ty, false) - in - let ty_res_application = - match kind with - | Dot_return_self -> - if not (Ctype.try_unify Stype.unit ty_res) then - add_error diagnostics - (Errors.cascade_type_mismatch - ~actual:(Printer.type_to_string ty_res) - ~loc); - Typedtree_util.type_of_typed_expr (Option.get self) - | Infix | Dot | Normal -> ty_res - in - let ty_res_with_attr = - if attr = Question then - Stype.make_result_ty ~ok_ty:ty_res_application ~err_ty - else ty_res_application - in - (match expect_ty with - | Some expect_ty -> - Ctype.unify_expr ~expect_ty ~actual_ty:ty_res_with_attr loc - |> store_error ~diagnostics - | None -> ()); - let arity, error_kind = - match func with - | Texpr_ident { arity_ = Some arity; _ } -> (arity, "function") - | Texpr_method { arity_ = Some arity; _ } -> (arity, "method") - | Texpr_unresolved_method { arity_ = Some arity; _ } -> (arity, "method") - | Texpr_constr { arity_ = arity; _ } -> (arity, "constructor") - | _ -> (Fn_arity.simple (List.length ty_params), "function") - in - let typ_of_args = - Fn_arity.to_hashtbl arity ty_params (fun param_kind ty -> (param_kind, ty)) - in - let seen_labels = Basic_hash_string.create 17 in - let last_positional_index = ref (-1) in - let lookup_positional_arg () = - incr last_positional_index; - match - Fn_arity.Hash.find_opt typ_of_args (Positional !last_positional_index) - with - | Some (_, typ) -> typ - | None -> Stype.new_type_var Tvar_error - in - let lookup_labelled_arg (label : Syntax.label) = - (match Basic_hash_string.find_opt seen_labels label.label_name with - | Some _first_loc -> + ~diagnostics = + (let n = List.length args + match self with None -> 0 | _ -> 1 in + let func_ty = Stype.type_repr (Typedtree_util.type_of_typed_expr func) in + let err_ty = Stype.new_type_var Tvar_normal in + let check_effect actual_err_type ~is_async = + match attr with + | (Question | Exclamation | No_attr) when is_async -> + add_error diagnostics (Errors.async_call_not_marked loc) + | Question -> ( + match actual_err_type with + | None -> + add_error diagnostics + (Errors.invalid_apply_attr ~kind:`NoErrorType + ~attr:(Syntax.string_of_apply_attr attr) + ~loc) + | Some actual_err_ty -> Ctype.unify_exn err_ty actual_err_ty) + | Exclamation -> ( + control_ctx.may_has_error := true; + match actual_err_type with + | None -> + add_error diagnostics + (Errors.invalid_apply_attr ~kind:`NoErrorType + ~attr:(Syntax.string_of_apply_attr attr) + ~loc) + | Some actual_err_type -> ( + match control_ctx.error_ctx with + | None -> + let error = Errors.invalid_raise ~kind:(`Rethrow "!") ~loc in + add_error diagnostics error + | Some error_ctx -> + store_error ~diagnostics + (Control_ctx.check_error_in_ctx ~error_ty:actual_err_type + ~ctx:error_ctx loc))) + | Double_exclamation -> ( + control_ctx.may_has_error := true; + if is_async then + store_error ~diagnostics + (Control_ctx.async_is_allowed control_ctx ~loc) + else add_error diagnostics (Errors.double_excl_not_async_call loc); + match actual_err_type with + | None -> () + | Some actual_err_type -> ( + match control_ctx.error_ctx with + | None -> + let error = Errors.invalid_raise ~kind:(`Rethrow "!!") ~loc in + add_error diagnostics error + | Some error_ctx -> + store_error ~diagnostics + (Control_ctx.check_error_in_ctx ~error_ty:actual_err_type + ~ctx:error_ctx loc))) + | No_attr -> ( + match actual_err_type with + | None -> () + | Some actual_err_type -> + let err_ty = Printer.type_to_string actual_err_type in + add_error diagnostics (Errors.unhandled_error ~err_ty ~loc)) + in + let delayed_error_type_check = ref None in + let ty_params, ty_res, ty_err, should_report_error = + match func_ty with + | Tarrow { params_ty; ret_ty; err_ty; is_async } -> + (match err_ty with + | Some t when Typeutil.is_tvar t -> + delayed_error_type_check := + Some (fun () -> check_effect err_ty ~is_async) + | _ -> check_effect err_ty ~is_async); + if is_async then + store_error ~diagnostics + (Control_ctx.async_is_allowed control_ctx ~loc); + (params_ty, ret_ty, err_ty, true) + | Tvar ({ contents = Tnolink tvar_kind } as link) -> + let params_ty = Type.type_var_list n tvar_kind in + let ret_ty = Stype.new_type_var tvar_kind in + link := + Tlink + (Tarrow + { + params_ty; + ret_ty; + err_ty = None; + is_async = false; + generic_ = false; + }); + if tvar_kind = Tvar_normal && attr <> No_attr then + add_error diagnostics + (Errors.invalid_apply_attr ~kind:`UnknownType + ~attr:(Syntax.string_of_apply_attr attr) + ~loc); + if + tvar_kind = Tvar_normal + && Lst.exists args (fun a -> a.arg_kind <> Positional) + then + add_error diagnostics + (Errors.nontoplevel_func_cannot_have_labelled_arg ~loc); + (params_ty, ret_ty, None, false) + | _ -> + let params_ty = Type.type_var_list n Tvar_error in + let ret_ty = Stype.new_type_var Tvar_error in + (if func_ty <> T_blackhole then + let expected, actual = + ("function type", Printer.type_to_string func_ty) + in + add_error diagnostics (Errors.type_mismatch ~expected ~actual ~loc)); + (params_ty, ret_ty, None, false) + in + let ty_res_application = + match kind with + | Dot_return_self -> + if not (Ctype.try_unify Stype.unit ty_res) then + add_error diagnostics + (Errors.cascade_type_mismatch + ~actual:(Printer.type_to_string ty_res) + ~loc); + Typedtree_util.type_of_typed_expr (Option.get self) + | Infix | Dot | Normal -> ty_res + in + let ty_res_with_attr = + if attr = Question then + Stype.make_result_ty ~ok_ty:ty_res_application ~err_ty + else ty_res_application + in + (match expect_ty with + | Some expect_ty -> + unify_expr_and_store_error ~expect_ty ~actual_ty:ty_res_with_attr + ~diagnostics loc + | None -> ()); + let arity, error_kind = + match func with + | Texpr_ident { arity_ = Some arity; _ } -> (arity, "function") + | Texpr_method { arity_ = Some arity; _ } -> (arity, "method") + | Texpr_unresolved_method { arity_ = Some arity; _ } -> (arity, "method") + | Texpr_constr { arity_ = arity; _ } -> (arity, "constructor") + | _ -> (Fn_arity.simple (List.length ty_params), "function") + in + let typ_of_args = + Fn_arity.to_hashtbl arity ty_params (fun param_kind -> + fun ty -> (param_kind, ty)) + in + let seen_labels = Basic_hash_string.create 17 in + let last_positional_index = ref (-1) in + let lookup_positional_arg () = + incr last_positional_index; + match + Fn_arity.Hash.find_opt typ_of_args (Positional !last_positional_index) + with + | Some (_, typ) -> typ + | None -> Stype.new_type_var Tvar_error + in + let lookup_labelled_arg (label : Syntax.label) = + (match Basic_hash_string.find_opt seen_labels label.label_name with + | Some _first_loc -> + add_error diagnostics + (Errors.duplicated_fn_label ~label:label.label_name + ~second_loc:label.loc_) + | None -> Basic_hash_string.add seen_labels label.label_name label.loc_); + match Fn_arity.Hash.find_opt typ_of_args (Labelled label.label_name) with + | Some _ as result -> result + | None -> + if should_report_error then + add_error diagnostics + (Errors.superfluous_arg_label ~label:label.label_name + ~kind:error_kind ~loc:label.loc_); + None + in + let check_arg (arg : Syntax.argument) = + (let ty = + match arg.arg_kind with + | Positional -> lookup_positional_arg () + | Labelled_option { label; question_loc } + | Labelled_option_pun { label; question_loc } -> ( + match lookup_labelled_arg label with + | None -> Stype.new_type_var Tvar_error + | Some (param_kind, ty) -> + (match param_kind with + | Question_optional _ -> () + | _ -> + add_error diagnostics + (Errors.invalid_question_arg_application + ~label:label.label_name ~loc:question_loc)); + Builtin.type_option ty) + | Labelled label | Labelled_pun label -> ( + match lookup_labelled_arg label with + | None -> Stype.new_type_var Tvar_error + | Some (_, ty) -> ty) + in + { + arg_value = + check_expr env arg.arg_value (Expect_type ty) ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics; + arg_kind = arg.arg_kind; + } + : Typedtree.argument) + in + let targs : Typedtree.argument list = + match self with + | Some self -> + let actual_ty_self = Typedtree_util.type_of_typed_expr self in + let expected_ty_self = lookup_positional_arg () in + unify_expr_and_store_error ~expect_ty:expected_ty_self + ~actual_ty:actual_ty_self ~diagnostics + (Typedtree.loc_of_typed_expr self); + { arg_value = self; arg_kind = Positional } :: Lst.map args check_arg + | None -> Lst.map args check_arg + in + (match !delayed_error_type_check with None -> () | Some check -> check ()); + (if should_report_error then + let actual = !last_positional_index + 1 in + let expected = Fn_arity.count_positional arity in + if actual <> expected then add_error diagnostics - (Errors.duplicated_fn_label ~label:label.label_name - ~second_loc:label.loc_) - | None -> Basic_hash_string.add seen_labels label.label_name label.loc_); - match Fn_arity.Hash.find_opt typ_of_args (Labelled label.label_name) with - | Some _ as result -> result - | None -> - if should_report_error then - add_error diagnostics - (Errors.superfluous_arg_label ~label:label.label_name - ~kind:error_kind ~loc:label.loc_); - None - in - let check_arg (arg : Syntax.argument) : Typedtree.argument = - let ty = - match arg.arg_kind with - | Positional -> lookup_positional_arg () - | Labelled_option { label; question_loc } - | Labelled_option_pun { label; question_loc } -> ( - match lookup_labelled_arg label with - | None -> Stype.new_type_var Tvar_error - | Some (param_kind, ty) -> - (match param_kind with - | Question_optional _ -> () - | _ -> - add_error diagnostics - (Errors.invalid_question_arg_application - ~label:label.label_name ~loc:question_loc)); - Builtin.type_option ty) - | Labelled label | Labelled_pun label -> ( - match lookup_labelled_arg label with - | None -> Stype.new_type_var Tvar_error - | Some (_, ty) -> ty) - in - { - arg_value = - check_expr env arg.arg_value (Expect_type ty) ~control_ctx ~tvar_env - ~cenv ~global_env ~diagnostics; - arg_kind = arg.arg_kind; - } - in - let targs : Typedtree.argument list = - match self with - | Some self -> - let actual_ty_self = Typedtree_util.type_of_typed_expr self in - let expected_ty_self = lookup_positional_arg () in - Ctype.unify_expr ~actual_ty:actual_ty_self ~expect_ty:expected_ty_self - (Typedtree.loc_of_typed_expr self) - |> store_error ~diagnostics; - { arg_value = self; arg_kind = Positional } :: Lst.map args check_arg - | None -> Lst.map args check_arg - in - (match !delayed_error_type_check with None -> () | Some check -> check ()); - (if should_report_error then - let actual = !last_positional_index + 1 in - let expected = Fn_arity.count_positional arity in - if actual <> expected then + (Errors.fn_arity_mismatch + ~func_ty: + (Printer.toplevel_function_type_to_string ~arity + (Typedtree_util.type_of_typed_expr func)) + ~expected ~actual + ~has_label: + ((not (Fn_arity.is_simple arity)) + || Lst.exists args (fun arg -> + match arg.arg_kind with + | Positional -> false + | Labelled _ | Labelled_pun _ | Labelled_option _ + | Labelled_option_pun _ -> + true)) + ~loc)); + if should_report_error then ( + let missing = Vec.empty () in + Fn_arity.iter arity (fun param_kind -> + match param_kind with + | Positional _ | Optional _ | Autofill _ | Question_optional _ -> () + | Labelled { label; _ } -> + if not (Basic_hash_string.mem seen_labels label) then + Vec.push missing label); + if not (Vec.is_empty missing) then add_error diagnostics - (Errors.fn_arity_mismatch - ~func_ty: - (Printer.toplevel_function_type_to_string ~arity - (Typedtree_util.type_of_typed_expr func)) - ~expected ~actual - ~has_label: - ((not (Fn_arity.is_simple arity)) - || Lst.exists args (fun arg -> - match arg.arg_kind with - | Positional -> false - | Labelled _ | Labelled_pun _ | Labelled_option _ - | Labelled_option_pun _ -> - true)) - ~loc)); - if should_report_error then ( - let missing = Vec.empty () in - Fn_arity.iter arity (fun param_kind -> - match param_kind with - | Positional _ | Optional _ | Autofill _ | Question_optional _ -> () - | Labelled { label; _ } -> - if not (Basic_hash_string.mem seen_labels label) then - Vec.push missing label); - if not (Vec.is_empty missing) then - add_error diagnostics - (Errors.missing_fn_label ~labels:(Vec.to_list missing) ~loc)); - let apply : Typedtree.expr = - Texpr_apply - { func; args = targs; ty = ty_res_application; kind_ = kind; loc_ = loc } - in - match attr with - | Exclamation -> - Texpr_exclamation - { - expr = apply; - loc_ = loc; - ty = ty_res_with_attr; - convert_to_result = false; - } - | Question -> - if kind = Dot_return_self then - add_error diagnostics (Errors.double_exclamation_with_cascade loc); - Texpr_exclamation - { - expr = apply; - loc_ = loc; - ty = ty_res_with_attr; - convert_to_result = true; - } - | No_attr -> apply + (Errors.missing_fn_label ~labels:(Vec.to_list missing) ~loc)); + let apply : Typedtree.expr = + Texpr_apply + { func; args = targs; ty = ty_res_application; kind_ = kind; loc_ = loc } + in + match attr with + | Exclamation -> + Texpr_exclamation + { + expr = apply; + loc_ = loc; + ty = ty_res_with_attr; + convert_to_result = false; + } + | Question -> + if kind = Dot_return_self then + add_error diagnostics (Errors.double_exclamation_with_cascade loc); + Texpr_exclamation + { + expr = apply; + loc_ = loc; + ty = ty_res_with_attr; + convert_to_result = true; + } + | Double_exclamation -> ( + match ty_err with + | Some _ -> + Texpr_exclamation + { + expr = apply; + loc_ = loc; + ty = ty_res_with_attr; + convert_to_result = false; + } + | None -> apply) + | No_attr -> apply + : Typedtree.expr) and typing_pipe ?(expect_ty : Stype.t option) (env : Local_env.t) (lhs : Syntax.expr) (rhs : Syntax.expr) ~loc ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics : Typedtree.expr = - let infer_go = - infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let rhs_loc = Syntax.loc_of_expression rhs in - let from_typed_apply (tapply : Typedtree.expr) : Typedtree.expr = - match tapply with - | Texpr_apply { func; args = { arg_value = tlhs; _ } :: args; ty; _ } -> - Texpr_pipe - { - lhs = tlhs; - rhs = Pipe_partial_apply { func; args; loc_ = rhs_loc }; - ty; - loc_ = loc; - } - | Texpr_exclamation - { - expr = - Texpr_apply { func; args = { arg_value = tlhs; _ } :: args; ty; _ }; - loc_; - ty = outer_ty; - convert_to_result; - } -> - Texpr_exclamation + ~global_env ~diagnostics = + (let infer_go = + infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let rhs_loc = Syntax.loc_of_expression rhs in + let from_typed_apply (tapply : Typedtree.expr) = + (match tapply with + | Texpr_apply { func; args = { arg_value = tlhs; _ } :: args; ty; _ } -> + Texpr_pipe + { + lhs = tlhs; + rhs = Pipe_partial_apply { func; args; loc_ = rhs_loc }; + ty; + loc_ = loc; + } + | Texpr_exclamation { expr = - Texpr_pipe - { - lhs = tlhs; - rhs = Pipe_partial_apply { func; args; loc_ = rhs_loc }; - ty; - loc_ = loc; - }; + Texpr_apply + { func; args = { arg_value = tlhs; _ } :: args; ty; _ }; loc_; ty = outer_ty; convert_to_result; - } - | _ -> assert false - [@@inline] - in - let fn_go func args ~attr = - let func = infer_go env func in - typing_application ?expect_ty env func - ({ arg_value = lhs; arg_kind = Positional } :: args) - ~kind:Normal ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~attr - ~diagnostics - |> from_typed_apply - [@@inline] - in - let constr_go constr args : Typedtree.expr = - typing_constr_or_constant constr - (Some ({ arg_value = lhs; arg_kind = Positional } :: args)) - ~expect_ty ~env ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - |> from_typed_apply - [@@inline] - in - match rhs with - | Pexpr_apply { func = (Pexpr_ident _ | Pexpr_method _) as func; args; attr } - -> - fn_go func args ~attr - | Pexpr_ident _ | Pexpr_method _ -> fn_go rhs [] ~attr:No_attr - | Pexpr_constr { constr } -> constr_go constr [] - | Pexpr_apply { func = Pexpr_constr { constr }; attr; args } -> - (if attr <> No_attr then - let error = Errors.invalid_apply_attr ~kind:`Constructor ~loc in - add_error diagnostics error); - constr_go constr args - | _ -> - let lhs = infer_go env lhs in - add_error diagnostics (Errors.unsupported_pipe_expr rhs_loc); - let trhs = infer_go env rhs in - Texpr_pipe - { - lhs; - rhs = - Pipe_invalid - { - expr = trhs; - ty = Typedtree_util.type_of_typed_expr trhs; - loc_ = rhs_loc; - }; - ty = - (match expect_ty with - | Some ty -> ty - | None -> Stype.new_type_var Tvar_error); - loc_ = loc; - } + } -> + Texpr_exclamation + { + expr = + Texpr_pipe + { + lhs = tlhs; + rhs = Pipe_partial_apply { func; args; loc_ = rhs_loc }; + ty; + loc_ = loc; + }; + loc_; + ty = outer_ty; + convert_to_result; + } + | _ -> assert false + : Typedtree.expr) + [@@inline] + in + let fn_go func args ~attr = + let func = infer_go env func in + from_typed_apply + (typing_application ?expect_ty env func + ({ arg_value = lhs; arg_kind = Positional } :: args) + ~kind:Normal ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~attr + ~diagnostics) + [@@inline] + in + let constr_go constr args = + (from_typed_apply + (typing_constr_or_constant constr + (Some ({ arg_value = lhs; arg_kind = Positional } :: args)) + ~expect_ty ~env ~loc ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics) + : Typedtree.expr) + [@@inline] + in + match rhs with + | Pexpr_apply { func = (Pexpr_ident _ | Pexpr_method _) as func; args; attr } + -> + fn_go func args ~attr + | Pexpr_ident _ | Pexpr_method _ -> fn_go rhs [] ~attr:No_attr + | Pexpr_constr { constr } -> constr_go constr [] + | Pexpr_apply { func = Pexpr_constr { constr }; attr; args } -> + (if attr <> No_attr then + let error = + Errors.invalid_apply_attr ~kind:`Constructor + ~attr:(Syntax.string_of_apply_attr attr) + ~loc + in + add_error diagnostics error); + constr_go constr args + | _ -> + let lhs = infer_go env lhs in + add_error diagnostics (Errors.unsupported_pipe_expr rhs_loc); + let trhs = infer_go env rhs in + Texpr_pipe + { + lhs; + rhs = + Pipe_invalid + { + expr = trhs; + ty = Typedtree_util.type_of_typed_expr trhs; + loc_ = rhs_loc; + }; + ty = + (match expect_ty with + | Some ty -> ty + | None -> Stype.new_type_var Tvar_error); + loc_ = loc; + } + : Typedtree.expr) and typing_self_method (ty_self : Stype.t) (method_name : Syntax.label) ~src - ~loc ~global_env ~tvar_env ~cenv ~diagnostics : Typedtree.expr = - let name = method_name.label_name in - match - Type_constraint.resolve_method_by_type ty_self name ~tvar_env ~global_env - ~src ~loc - with - | Ok (Known_method method_info) -> - Docstring.check_alerts ~diagnostics - (Docstring.pragmas method_info.doc_) - loc; - let ty_method, ty_args_ = - Poly_type.instantiate_method ~cenv ~loc method_info - in - Ctype.unify_exn ty_self ty_self; - Texpr_ident - { - id = - { - var_id = Ident.of_qual_ident method_info.id; - loc_ = method_name.loc_; - }; - ty_args_; - arity_ = Some method_info.arity_; - kind = - (match method_info.prim with None -> Normal | Some p -> Prim p); - ty = ty_method; - loc_ = method_name.loc_; - } - | Ok (Promised_method { method_id; method_ty; method_arity; prim }) -> - Texpr_ident - { - id = { var_id = method_id; loc_ = method_name.loc_ }; - ty_args_ = [||]; - arity_ = Some method_arity; - kind = (match prim with None -> Normal | Some p -> Prim p); - ty = method_ty; - loc_ = method_name.loc_; - } - | Error err -> - add_error diagnostics err; - Texpr_ident - { - id = { var_id = Ident.fresh name; loc_ = method_name.loc_ }; - ty_args_ = [||]; - arity_ = None; - kind = Normal; - ty = Stype.new_type_var Tvar_error; - loc_ = method_name.loc_; - } + ~loc ~global_env ~tvar_env ~cenv ~diagnostics = + (let name = method_name.label_name in + match + Type_constraint.resolve_method_by_type ty_self name ~tvar_env ~global_env + ~src ~loc + with + | Ok (Known_method method_info) -> + Checked_attributes.check_alerts ~diagnostics method_info.attrs loc; + Docstring.check_alerts ~diagnostics + (Docstring.pragmas method_info.doc_) + loc; + let ty_method, ty_args_ = + Poly_type.instantiate_method ~cenv ~loc method_info + in + Ctype.unify_exn ty_self ty_self; + Texpr_ident + { + id = + { + var_id = Ident.of_qual_ident method_info.id; + loc_ = method_name.loc_; + }; + ty_args_; + arity_ = Some method_info.arity_; + kind = + (match method_info.prim with None -> Normal | Some p -> Prim p); + ty = ty_method; + loc_ = method_name.loc_; + } + | Ok (Promised_method { method_id; method_ty; method_arity; prim }) -> + Texpr_ident + { + id = { var_id = method_id; loc_ = method_name.loc_ }; + ty_args_ = [||]; + arity_ = Some method_arity; + kind = (match prim with None -> Normal | Some p -> Prim p); + ty = method_ty; + loc_ = method_name.loc_; + } + | Error err -> + add_error diagnostics err; + Texpr_ident + { + id = { var_id = Ident.fresh name; loc_ = method_name.loc_ }; + ty_args_ = [||]; + arity_ = None; + kind = Normal; + ty = Stype.new_type_var Tvar_error; + loc_ = method_name.loc_; + } + : Typedtree.expr) and typing_constr_or_constant (constr : Syntax.constructor) (args : Syntax.argument list option) ~(expect_ty : Stype.t option) ~env ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics = let name = constr.constr_name.name in - let check_args ~expect_ty (constr_expr : Typedtree.expr) ~ty_constr ~ty_res = - match args with - | None -> - (match expect_ty with - | None -> () - | Some expect_ty -> - Ctype.unify_constr name ~expect_ty ~actual_ty:ty_constr loc - |> store_error ~diagnostics); - constr_expr - | Some args -> - (match expect_ty with - | None -> () - | Some expect_ty -> - Ctype.unify_constr name ~expect_ty ~actual_ty:ty_res loc - |> store_error ~diagnostics); - typing_application ?expect_ty:None env constr_expr args ~kind:Normal - ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~attr:No_attr - ~diagnostics - [@@inline] + let infer_args func (args : Syntax.argument list) = + (let args = + Lst.map args (fun arg -> + ({ + arg_value = + infer_expr env arg.arg_value ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics; + arg_kind = arg.arg_kind; + } + : Typedtree.argument)) + in + let ty = Typedtree_util.type_of_typed_expr func in + Texpr_apply { func; args; kind_ = Normal; ty; loc_ = loc } + : Typedtree.expr) + [@@local] in match - Global_env.resolve_constr_or_constant global_env ~expect_ty ~constr - ~creating_value:true + Typeutil.resolve_constr_or_constant ~global_env ~tvar_env ~expect_ty ~constr + ~creating_value:true ~diagnostics with - | Ok (`Constr constr_desc) -> + | Some (`Constr constr_desc), type_name -> ( let ty_res, ty_args = Poly_type.instantiate_constr constr_desc in let ty_constr = match ty_args with | [] -> ty_res - | _ -> Builtin.type_arrow ty_args ty_res ~err_ty:None + | _ -> Builtin.type_arrow ty_args ty_res ~err_ty:None ~is_async:false in let constr_expr : Typedtree.expr = Texpr_constr { - constr; + type_name; + constr = constr.constr_name; tag = constr_desc.cs_tag; ty = ty_constr; arity_ = constr_desc.cs_arity_; loc_ = constr.loc_; } in - check_args ~expect_ty constr_expr ~ty_constr ~ty_res - | Ok (`Constant { id; kind; typ; _ }) -> + match (ty_args, args) with + | _, None -> + (match expect_ty with + | None -> () + | Some expect_ty -> + store_error ~diagnostics + (Ctype.unify_constr name ~expect_ty ~actual_ty:ty_constr loc)); + constr_expr + | [], Some args -> + Local_diagnostics.add_error diagnostics + (Errors.constant_constr_cannot_have_args ~name ~loc:constr.loc_); + infer_args constr_expr args + | _ :: _, Some args -> + (match expect_ty with + | None -> () + | Some expect_ty -> + store_error ~diagnostics + (Ctype.unify_constr name ~expect_ty ~actual_ty:ty_res loc)); + typing_application ?expect_ty:None env constr_expr args ~kind:Normal + ~loc ~control_ctx ~tvar_env ~cenv ~global_env ~attr:No_attr + ~diagnostics) + | Some (`Constant { id; kind; typ; _ }), _ -> ( let constant_expr : Typedtree.expr = match kind with | Const c -> @@ -1781,17 +1922,35 @@ and typing_constr_or_constant (constr : Syntax.constructor) { c; ty = typ; - name_ = - Some { var_id = Ident.of_qual_ident id; loc_ = constr.loc_ }; + name_ = Some { var_id = Ident.of_qual_ident id; loc_ = loc }; loc_ = constr.loc_; } | Prim _ | Normal -> Texpr_hole { ty = typ; loc_ = constr.loc_; kind = Synthesized } in - check_args ~expect_ty constant_expr ~ty_constr:typ ~ty_res:typ - | Error err -> - add_error diagnostics err; - let ty = Stype.new_type_var Tvar_error in + match args with + | None -> + (match expect_ty with + | Some expect_ty -> + unify_expr_and_store_error ~expect_ty ~actual_ty:typ constr.loc_ + ~diagnostics + | _ -> ()); + constant_expr + | Some args -> + (match Stype.type_repr typ with + | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> () + | typ -> + Local_diagnostics.add_error diagnostics + (Errors.type_mismatch ~expected:"function type" + ~actual:(Printer.type_to_string typ) + ~loc)); + infer_args constant_expr args) + | None, type_name -> ( + let ty = + match expect_ty with + | Some expect_ty -> expect_ty + | None -> Stype.new_type_var Tvar_error + in let constr_expr : Typedtree.expr = let arity_ = match args with @@ -1799,1292 +1958,1562 @@ and typing_constr_or_constant (constr : Syntax.constructor) | Some args -> Fn_arity.simple (List.length args) in Texpr_constr - { constr; tag = Typeutil.unknown_tag; ty; arity_; loc_ = loc } + { + type_name; + constr = constr.constr_name; + tag = Typeutil.unknown_tag; + ty; + arity_; + loc_ = loc; + } in - check_args ~expect_ty constr_expr ~ty_constr:ty ~ty_res:T_blackhole + match args with + | None -> constr_expr + | Some args -> infer_args constr_expr args) and typing_array_spread (env : Local_env.t) - (elems : Syntax.spreadable_elem list) ~(loc : Rloc.t) + (elems : Syntax.spreadable_elem list) + ~(kind : [ `Array | `String | `Bytes ]) ~(loc : Rloc.t) ~(expect_ty : Stype.t option) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let ty_elem = Stype.new_type_var Tvar_normal in - let ty = Builtin.type_array ty_elem in - (match expect_ty with - | Some expect_ty -> - Ctype.unify_expr ~expect_ty ~actual_ty:ty loc |> store_error ~diagnostics - | None -> ()); - let self : Typedtree.expr = - Texpr_array - { exprs = []; ty; is_fixed_array = false; loc_ = Rloc.no_location } - in - let push : Typedtree.expr = - typing_self_method ty - { label_name = "push"; loc_ = Rloc.no_location } - ~src:Dot_src_direct ~loc:Rloc.no_location ~global_env ~tvar_env ~cenv - ~diagnostics - in - Ctype.unify_exn - (Typedtree_util.type_of_typed_expr push) - (Builtin.type_arrow [ ty; ty_elem ] Stype.unit ~err_ty:None); - let push_iter : Typedtree.expr = - typing_self_method ty - { label_name = "push_iter"; loc_ = Rloc.no_location } - ~src:Dot_src_direct ~loc:Rloc.no_location ~global_env ~tvar_env ~cenv - ~diagnostics - in - let ty_elem_iter = Builtin.type_iter ty_elem in - Ctype.unify_exn - (Typedtree_util.type_of_typed_expr push_iter) - (Builtin.type_arrow [ ty; ty_elem_iter ] Stype.unit ~err_ty:None); - Lst.fold_left elems self (fun self elem -> - match elem with - | Elem_regular expr -> - let texpr = - check_expr env expr (Expect_type ty_elem) ~control_ctx ~tvar_env - ~cenv ~global_env ~diagnostics - in - Texpr_apply - { - func = push; - args = - [ - { arg_value = self; arg_kind = Positional }; - { arg_value = texpr; arg_kind = Positional }; - ]; - kind_ = Dot_return_self; - ty; - loc_ = Rloc.no_location; - } - | Elem_spread { expr; loc_ } -> - let iter_expr : Syntax.expr = - Pexpr_dot_apply - { - self = expr; - method_name = { label_name = "iter"; loc_ }; - args = []; - return_self = false; - attr = No_attr; - loc_; - } - in - let texpr = - check_expr env iter_expr (Expect_type ty_elem_iter) ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics - in - Texpr_apply - { - func = push_iter; - args = - [ - { arg_value = self; arg_kind = Positional }; - { arg_value = texpr; arg_kind = Positional }; - ]; - kind_ = Dot_return_self; - ty; - loc_ = Rloc.no_location; - }) + ~(diagnostics : Local_diagnostics.t) = + (let check_go = + check_expr env ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let infer_go = + infer_expr env ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let ty_elem, ty_elem_iter, self, push, push_iter = + let loc_ = Rloc.no_location in + let typing_self_method ty name = + typing_self_method ty + { label_name = name; loc_ } + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv ~diagnostics + [@@inline] + in + match kind with + | `Array -> + let ty_elem = Stype.new_type_var Tvar_normal in + let ty = Builtin.type_array ty_elem in + (match expect_ty with + | Some expect_ty -> + unify_expr_and_store_error ~expect_ty ~actual_ty:ty ~diagnostics + loc + | None -> ()); + let self : Typedtree.expr = + Texpr_array + { exprs = []; ty; is_fixed_array = false; loc_ = Rloc.no_location } + in + let push : Typedtree.expr = typing_self_method ty "push" in + Ctype.unify_exn + (Typedtree_util.type_of_typed_expr push) + (Builtin.type_arrow [ ty; ty_elem ] Stype.unit ~err_ty:None + ~is_async:false); + let push_iter : Typedtree.expr = typing_self_method ty "push_iter" in + let ty_elem_iter = Builtin.type_iter ty_elem in + Ctype.unify_exn + (Typedtree_util.type_of_typed_expr push_iter) + (Builtin.type_arrow [ ty; ty_elem_iter ] Stype.unit ~err_ty:None + ~is_async:false); + (ty_elem, ty_elem_iter, self, push, push_iter) + | `String -> + let func : Syntax.expr = + Pexpr_method + { + type_name = + { name = Lident "StringBuilder"; is_object = false; loc_ }; + method_name = { label_name = "new"; loc_ }; + loc_; + } + in + let self : Typedtree.expr = + infer_go (Pexpr_apply { func; args = []; attr = No_attr; loc_ }) + in + let sb_ty = Typedtree_util.type_of_typed_expr self in + let push = typing_self_method sb_ty "write_char" in + let push_iter = typing_self_method sb_ty "write_iter" in + (Stype.char, Builtin.type_iter Stype.char, self, push, push_iter) + | `Bytes -> + let func : Syntax.expr = + Pexpr_ident + { + id = { var_name = Ldot { pkg = "buffer"; id = "new" }; loc_ }; + loc_; + } + in + let self : Typedtree.expr = + infer_go (Pexpr_apply { func; args = []; attr = No_attr; loc_ }) + in + let bf_ty = Typedtree_util.type_of_typed_expr self in + let push = typing_self_method bf_ty "write_byte" in + let push_iter = typing_self_method bf_ty "write_iter" in + (Stype.byte, Builtin.type_iter Stype.byte, self, push, push_iter) + in + let self_ty = Typedtree_util.type_of_typed_expr self in + Lst.fold_left elems self (fun self -> + fun elem -> + let self_dotdot_apply func arg = + (Texpr_apply + { + func; + args = + [ + { arg_value = self; arg_kind = Positional }; + { arg_value = arg; arg_kind = Positional }; + ]; + kind_ = Dot_return_self; + ty = self_ty; + loc_ = Rloc.no_location; + } + : Typedtree.expr) + [@@inline] + in + match elem with + | Elem_regular expr -> + let texpr = check_go expr (Expect_type ty_elem) in + self_dotdot_apply push texpr + | Elem_spread { expr; loc_ } -> + let iter_expr : Syntax.expr = + Pexpr_dot_apply + { + self = expr; + method_name = { label_name = "iter"; loc_ }; + args = []; + return_self = false; + attr = No_attr; + loc_; + } + in + let texpr = check_go iter_expr (Expect_type ty_elem_iter) in + self_dotdot_apply push_iter texpr) + : Typedtree.expr) and typing_map_expr (env : Local_env.t) (elems : Syntax.map_expr_elem list) ~(loc : Rloc.t) ~(expect_ty : Stype.t option) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let map_tpath = - Type_path.toplevel_type ~pkg:Basic_config.builtin_package "Map" - in - match - Global_env.find_regular_method global_env ~type_name:map_tpath - ~method_name:"from_array" - with - | None -> - add_error diagnostics - (Errors.pkg_not_imported ~name:Basic_config.builtin_package - ~action: - ("create value of type " ^ Type_path_util.name map_tpath - : Stdlib.String.t) - ~loc); - Texpr_hole - { ty = Stype.new_type_var Tvar_error; loc_ = loc; kind = Synthesized } - | Some method_info -> - let ty, ty_args_ = Poly_type.instantiate_method ~cenv ~loc method_info in - let map_from_array : Typedtree.expr = - Texpr_ident - { - id = - { - var_id = Ident.of_qual_ident method_info.id; - loc_ = Rloc.no_location; - }; - kind = Normal; - arity_ = Some method_info.arity_; - ty_args_; - ty; - loc_ = Rloc.no_location; - } - in - let elems_array : Syntax.expr = - Pexpr_array - { - exprs = - Lst.map elems - (fun (Map_expr_elem { key; expr; key_loc_; loc_ }) -> - let key_expr : Syntax.expr = - Pexpr_constant { c = key; loc_ = key_loc_ } - in - Syntax.Pexpr_tuple { exprs = [ key_expr; expr ]; loc_ }); - loc_ = Rloc.no_location; - } - in - let is_json, expect_ty = - match expect_ty with - | Some expect_ty when Type.same_type expect_ty Stype.json -> - (true, Some (Builtin.type_map Stype.string Stype.json)) - | _ -> (false, expect_ty) - in - let result = - typing_application env map_from_array - [ { arg_value = elems_array; arg_kind = Positional } ] - ?expect_ty ~kind:Normal ~loc ~control_ctx ~tvar_env ~cenv ~global_env - ~attr:No_attr ~diagnostics - in - if is_json then - Json_literal.make_json_expr ~global_env ~diagnostics ~loc - Json_literal.object_ result - else result + ~(diagnostics : Local_diagnostics.t) = + (let map_tpath = + Type_path.toplevel_type ~pkg:Basic_config.builtin_package "Map" + in + match + Global_env.find_regular_method global_env ~type_name:map_tpath + ~method_name:"from_array" + with + | None -> + add_error diagnostics + (Errors.pkg_not_imported ~name:Basic_config.builtin_package + ~action: + (("create value of type " ^ Type_path_util.name map_tpath + : Stdlib.String.t) + [@merlin.hide]) + ~loc); + Texpr_hole + { ty = Stype.new_type_var Tvar_error; loc_ = loc; kind = Synthesized } + | Some method_info -> + let ty, ty_args_ = Poly_type.instantiate_method ~cenv ~loc method_info in + let map_from_array : Typedtree.expr = + Texpr_ident + { + id = + { + var_id = Ident.of_qual_ident method_info.id; + loc_ = Rloc.no_location; + }; + kind = Normal; + arity_ = Some method_info.arity_; + ty_args_; + ty; + loc_ = Rloc.no_location; + } + in + let elems_array : Syntax.expr = + Pexpr_array + { + exprs = + Lst.map elems + (fun (Map_expr_elem { key; expr; key_loc_; loc_ }) -> + let key_expr : Syntax.expr = + Pexpr_constant { c = key; loc_ = key_loc_ } + in + Syntax.Pexpr_tuple { exprs = [ key_expr; expr ]; loc_ }); + loc_ = Rloc.no_location; + } + in + let is_json, expect_ty = + match expect_ty with + | Some expect_ty when Type.same_type expect_ty Stype.json -> + (true, Some (Builtin.type_map Stype.string Stype.json)) + | _ -> (false, expect_ty) + in + let result = + typing_application env map_from_array + [ { arg_value = elems_array; arg_kind = Positional } ] + ?expect_ty ~kind:Normal ~loc ~control_ctx ~tvar_env ~cenv ~global_env + ~attr:No_attr ~diagnostics + in + if is_json then + Json_literal.make_json_expr ~global_env ~diagnostics ~loc + Json_literal.object_ result + else result + : Typedtree.expr) -and typing_static_assert ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics +and typing_static_assert ~global_env ~tvar_env ~diagnostics ~control_ctx ~expect_ty env asserts body = - let has_error = ref false in - Lst.iter asserts (fun { assert_type; assert_trait; assert_loc; assert_msg } -> + let assert_cenv = Poly_type.make () in + Lst.iter asserts + ~f:(fun { assert_type; assert_trait; assert_loc; assert_msg } -> let aux_diagnostics = Local_diagnostics.make ~base:Loc.no_location in let type_ = - typing_type ~diagnostics:aux_diagnostics ~tvar_env ~global_env - assert_type - |> Typedtree_util.stype_of_typ + Typedtree_util.stype_of_typ + (typing_type ~diagnostics:aux_diagnostics ~tvar_env ~global_env + assert_type) in - if Local_diagnostics.has_fatal_errors aux_diagnostics then - has_error := true - else - match - Global_env.All_types.find_trait - (Global_env.get_all_types global_env) - assert_trait ~loc:assert_loc - with - | Error _ -> has_error := true - | Ok trait -> - let aux_cenv = Poly_type.make () in - Poly_type.add_constraint aux_cenv type_ - { trait = trait.name; required_by_ = []; loc_ = Rloc.no_location }; - Type_constraint.solve_constraints aux_cenv ~tvar_env ~global_env - ~diagnostics:aux_diagnostics; - if Local_diagnostics.has_fatal_errors aux_diagnostics then ( - add_error diagnostics - (Errors.static_assert_failure - ~type_:(Printer.type_to_string type_) - ~trait:(Type_path_util.name trait.name) - ~required_by:assert_msg ~loc:assert_loc); - has_error := true)); - if !has_error then + match + Global_env.All_types.find_trait + (Global_env.get_all_types global_env) + assert_trait ~loc:assert_loc + with + | Error _ -> () + | Ok trait -> + Poly_type.add_constraint assert_cenv type_ + { + trait = trait.name; + src_ = Static_assert assert_msg; + loc_ = assert_loc; + }); + let assert_diagnostics = Local_diagnostics.make ~base:Loc.no_location in + Type_constraint.solve_constraints assert_cenv ~tvar_env ~global_env + ~diagnostics:assert_diagnostics; + Local_diagnostics.merge assert_diagnostics ~into:diagnostics; + if Local_diagnostics.has_fatal_errors assert_diagnostics then Texpr_hole { + kind = Synthesized; ty = Stype.new_type_var Tvar_error; loc_ = Rloc.no_location; - kind = Synthesized; } else + let aux_cenv = Poly_type.make () in match expect_ty with | None -> - infer_expr env body ~global_env ~tvar_env ~control_ctx ~cenv + infer_expr env body ~global_env ~tvar_env ~control_ctx ~cenv:aux_cenv ~diagnostics | Some expect_ty -> - check_expr env body expect_ty ~global_env ~tvar_env ~control_ctx ~cenv - ~diagnostics + check_expr env body expect_ty ~global_env ~tvar_env ~control_ctx + ~cenv:aux_cenv ~diagnostics and check_expr (env : Local_env.t) (expr : Syntax.expr) (expect_ty : expect_ty) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let check_go = - check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let fallback expect_ty = - check_expr_no_cast env expr expect_ty ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - [@@inline] - in - match (expect_ty, expr) with - | Expect_type expect_ty, _ when Typeutil.is_trait expect_ty -> - let expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let actual_ty = Typedtree_util.type_of_typed_expr expr in - let loc_ = Typedtree.loc_of_typed_expr expr in - unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty ~actual_ty loc_ - |> handle_unify_result ~diagnostics ~expr - | _, Pexpr_sequence { expr1; expr2; loc_ } -> - let expr1 = check_go env expr1 Ignored in - let expr2 = check_go env expr2 expect_ty in - Texpr_sequence - { expr1; expr2; ty = Typedtree_util.type_of_typed_expr expr2; loc_ } - | _, Pexpr_let { pattern = p; expr = e; body; loc_; _ } -> - let pat_binders, tp, te1 = - typing_let env p e ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let body = - check_go (Typeutil.add_pat_binders env pat_binders) body expect_ty - in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_let { pat = tp; rhs = te1; body; ty; pat_binders; loc_ } - | _, Pexpr_letfn { name; func; body; loc_ } -> ( - match[@warning "-fragile-match"] - typing_letrec env - [ (name, func) ] - ~tvar_env ~cenv ~global_env ~diagnostics - with - | env_with_funs, (binder, fn) :: [] -> - let body = check_go env_with_funs body expect_ty in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_letfn - { - binder; - fn; - body; - ty; - loc_; - is_rec = Typedtree_util.is_rec binder fn; - } - | _ -> assert false) - | _, Pexpr_letrec { bindings = funs; body; loc_ } -> - let env_with_funs, bindings = - typing_letrec env funs ~tvar_env ~cenv ~global_env ~diagnostics - in - let body = check_go env_with_funs body expect_ty in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_letrec { bindings; body; ty; loc_ } - | _, Pexpr_letmut { binder; ty; expr; body; loc_ } -> - let env, binder, expr, konstraint = - typing_letmut env binder ty expr ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - let body = check_go env body expect_ty in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_letmut { binder; konstraint; expr; body; ty; loc_ } - | _, Pexpr_if { cond; ifso; ifnot = None; loc_ } -> - let cond = check_go env cond (Expect_type Stype.bool) in - let ifso = check_go env ifso Ignored in - (match expect_ty with - | Ignored -> () - | Expect_type expect_ty -> - Ctype.unify_expr ~expect_ty ~actual_ty:Stype.unit loc_ - |> store_error ~diagnostics); - Texpr_if { cond; ifso; ifnot = None; ty = Stype.unit; loc_ } - | _, Pexpr_if { cond; ifso; ifnot = Some ifnot; loc_ } -> - let cond = check_go env cond (Expect_type Stype.bool) in - let ifso = check_go env ifso expect_ty in - let ifnot = check_go env ifnot expect_ty in - let ty = Typedtree_util.type_of_typed_expr ifso in - Texpr_if { cond; ifso; ifnot = Some ifnot; ty; loc_ } - | _, Pexpr_guard { cond; otherwise; body; loc_ } -> - let cond = check_go env cond (Expect_type Stype.bool) in - let otherwise = - match otherwise with - | None -> None - | Some otherwise -> Some (check_go env otherwise expect_ty) - in - let body = check_go env body expect_ty in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_guard { cond; otherwise; body; ty; loc_ } - | _, Pexpr_guard_let { pat; expr; otherwise; body; loc_ } -> - let pat_binders, pat, rhs = - typing_let env pat expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let check_cases cases pat_ty action_ty = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p pat_ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action action_ty - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - [@@inline] - in - let otherwise = - match otherwise with - | None -> None - | Some otherwise -> - Some - (check_cases otherwise - (Typedtree_util.type_of_typed_expr rhs) - expect_ty) - in - let body = - check_go (Typeutil.add_pat_binders env pat_binders) body expect_ty - in - let ty = Typedtree_util.type_of_typed_expr body in - Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; ty; loc_ } - | ( _, - Pexpr_try - { - body; - catch; - catch_all; - try_else; - try_loc_; - catch_loc_; - else_loc_; - loc_; - } ) -> - let error_ctx = ref (Control_ctx.Open_ctx Empty_ctx) in - let new_ctx = Control_ctx.with_error_ctx ~error_ctx control_ctx in - let body_expect_ty = - if try_else = None then expect_ty - else Expect_type (Stype.new_type_var Tvar_normal) - in - let body = - check_expr ~control_ctx:new_ctx ~tvar_env ~cenv ~global_env ~diagnostics - env body body_expect_ty - in - let check_cases cases pat_ty action_ty = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p pat_ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action action_ty - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - [@@inline] - in - let error_ty = Control_ctx.error_ctx_to_stype !error_ctx in - let catch = check_cases catch error_ty expect_ty in - let try_else = - match try_else with - | None -> None - | Some try_else -> - Some - (check_cases try_else - (Typedtree_util.type_of_typed_expr body) - expect_ty) - in - if not !(new_ctx.has_error) then ( - Local_diagnostics.add_warning diagnostics - { kind = Useless_try; loc = try_loc_ }; - match Stype.type_repr error_ty with - | Tvar link -> link := Tlink Stype.unit - | _ -> ()); - if catch_all then ( - control_ctx.has_error := true; - match control_ctx.error_ctx with - | Some error_ctx -> - Control_ctx.check_error_in_ctx ~error_ty ~ctx:error_ctx catch_loc_ - |> store_error ~diagnostics - | None -> - add_error diagnostics - (Errors.invalid_raise ~kind:`Catchall ~loc:catch_loc_)); - let ty = - match try_else with - | None -> Typedtree_util.type_of_typed_expr body - | Some ({ action; _ } :: _) -> Typedtree_util.type_of_typed_expr action - | Some [] -> ( - match expect_ty with Ignored -> Stype.unit | Expect_type ty -> ty) - in - Texpr_try - { - body; - catch; - catch_all; - try_else; - ty; - err_ty = error_ty; - catch_loc_; - else_loc_; - loc_; - } - | _, Pexpr_match { expr; cases; match_loc_; loc_ } -> - let expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let ty = Typedtree_util.type_of_typed_expr expr in - let cases = - Lst.map cases (fun (p, action) -> - let pat_binders, tpat = - Pattern_typer.check_pat p ty ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_go - (Typeutil.add_pat_binders env pat_binders) - action expect_ty - in - ({ pat = tpat; action = taction; pat_binders } - : Typedtree.match_case)) - in - let ty = - match expect_ty with Ignored -> Stype.unit | Expect_type ty -> ty - in - Texpr_match { expr; cases; ty; match_loc_; loc_ } - | _, Pexpr_loop { args; body; loop_loc_; loc_ } -> - check_loop ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics env args - body ~loc:loc_ ~loop_loc_ ~expect_ty - | _, Pexpr_for { binders; condition; continue_block; body; for_else; loc_ } -> - check_for ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics ~expect_ty - env binders condition continue_block body for_else ~loc:loc_ - | ( _, - Pexpr_foreach - { - binders; - expr = - Pexpr_infix - { - op = { var_name = Lident (("..<" | "..=") as op) }; - lhs; - rhs; - loc_ = operator_loc; - }; - body; - else_block; - loc_; - } ) -> - let inclusive = op = "..=" in - typing_range_for_in env binders lhs rhs body else_block ~inclusive - ~operator_loc ~loc:loc_ ~expect_ty ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - | _, Pexpr_foreach { binders; expr; body; else_block; loc_ } -> - typing_foreach ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - ~expect_ty env binders expr body else_block ~loc:loc_ - | _, Pexpr_while { loop_cond; loop_body; loc_; while_else } -> - check_while env loop_cond loop_body while_else ~expect_ty ~loc:loc_ - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | _, Pexpr_static_assert { asserts; body } -> - typing_static_assert ~global_env ~tvar_env ~control_ctx ~cenv ~diagnostics - ~expect_ty:(Some expect_ty) env asserts body - | Ignored, _ -> - let expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let actual_ty = Typedtree_util.type_of_typed_expr expr in - let loc_ = Typedtree.loc_of_typed_expr expr in - if not (Ctype.try_unify Stype.unit actual_ty) then - add_error diagnostics - (Errors.non_unit_cannot_be_ignored - ~ty:(Printer.type_to_string actual_ty) - ~loc:loc_); - expr - | Expect_type expect_ty, _ when Type.is_super_error expect_ty -> - let error_value = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let error_value_ty = Typedtree_util.type_of_typed_expr error_value in - let loc_ = Typedtree.loc_of_typed_expr error_value in - if Typeutil.is_tvar error_value_ty then - Ctype.unify_exn error_value_ty expect_ty - else if - not - (Type.is_suberror error_value_ty || Type.is_super_error error_value_ty) - then - add_error diagnostics - (Errors.not_error_subtype - (Printer.type_to_string error_value_ty) - loc_); - error_value - | Expect_type expect_ty, _ -> ( - match Global_env.get_newtype_info global_env expect_ty with - | Some { newtype_constr; underlying_typ = _; recursive = _ } -> ( - match expr with - | Pexpr_array_get _ | Pexpr_array_get_slice _ | Pexpr_array_set _ - | Pexpr_array_augmented_set _ | Pexpr_unary _ | Pexpr_group _ -> - assert false - | Pexpr_constr { constr } - | Pexpr_apply { func = Pexpr_constr { constr }; args = _; attr = _ } - when newtype_constr.constr_name = constr.constr_name.name -> - fallback expect_ty - | Pexpr_array _ | Pexpr_array_spread _ | Pexpr_constr _ - | Pexpr_apply { func = Pexpr_constr _; args = _; attr = _ } - | Pexpr_tuple _ | Pexpr_constant _ | Pexpr_interp _ | Pexpr_function _ - | Pexpr_record _ | Pexpr_record_update _ | Pexpr_map _ -> ( - let loc = Syntax.loc_of_expression expr in - match[@warning "-fragile-match"] - Poly_type.instantiate_constr newtype_constr - with - | expect_ty', underlying_typ :: [] -> - Ctype.unify_exn expect_ty' expect_ty; - wrap_newtype_constr newtype_constr (fallback underlying_typ) - expect_ty loc - | _ -> assert false) - | Pexpr_apply _ | Pexpr_dot_apply _ | Pexpr_pipe _ - | Pexpr_constraint _ | Pexpr_field _ | Pexpr_method _ | Pexpr_infix _ - | Pexpr_ident _ | Pexpr_assign _ | Pexpr_as _ -> ( - let inferred_expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - let inferred_ty = - Typedtree_util.type_of_typed_expr inferred_expr - in - let loc = Syntax.loc_of_expression expr in - match Ctype.unify_expr ~expect_ty ~actual_ty:inferred_ty loc with - | None -> inferred_expr - | Some err1 -> ( - match[@warning "-fragile-match"] - Poly_type.instantiate_constr newtype_constr - with - | expect_ty', underlying_typ :: [] -> ( - Ctype.unify_exn expect_ty' expect_ty; - match - Ctype.unify_expr ~expect_ty:underlying_typ - ~actual_ty:inferred_ty loc - with - | None -> - wrap_newtype_constr newtype_constr inferred_expr - expect_ty loc - | Some _err -> - add_error diagnostics err1; - inferred_expr) - | _ -> assert false)) - | Pexpr_while _ | Pexpr_if _ | Pexpr_try _ | Pexpr_letfn _ - | Pexpr_letrec _ | Pexpr_let _ | Pexpr_sequence _ | Pexpr_mutate _ - | Pexpr_match _ | Pexpr_letmut _ | Pexpr_hole _ | Pexpr_return _ - | Pexpr_raise _ | Pexpr_unit _ | Pexpr_break _ | Pexpr_continue _ - | Pexpr_loop _ | Pexpr_foreach _ | Pexpr_static_assert _ - | Pexpr_guard _ | Pexpr_guard_let _ | Pexpr_for _ - | Pexpr_multiline_string _ -> - fallback expect_ty) - | None -> fallback expect_ty) + ~(diagnostics : Local_diagnostics.t) = + (let check_go = + check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let fallback expect_ty = + check_expr_no_cast env expr expect_ty ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + [@@inline] + in + match (expect_ty, expr) with + | Expect_type expect_ty, _ when Typeutil.is_trait expect_ty -> + let expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let actual_ty = Typedtree_util.type_of_typed_expr expr in + let loc_ = Typedtree.loc_of_typed_expr expr in + handle_unify_result ~diagnostics ~expr + (unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty ~actual_ty + loc_) + | _, Pexpr_sequence { exprs; last_expr; loc_ } -> + let exprs = Lst.map exprs (fun expr -> check_go env expr Ignored) in + let last_expr = check_go env last_expr expect_ty in + let ty = Typedtree_util.type_of_typed_expr last_expr in + Texpr_sequence { exprs; last_expr; ty; loc_ } + | _, Pexpr_let { pattern = p; expr = e; body; loc_; _ } -> + let pat_binders, tp, te1 = + typing_let env p e ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let body = + check_go (Typeutil.add_pat_binders env pat_binders) body expect_ty + in + let ty = Typedtree_util.type_of_typed_expr body in + Texpr_let { pat = tp; rhs = te1; body; ty; pat_binders; loc_ } + | _, Pexpr_letfn { name; func; body; loc_ } -> ( + match[@warning "-fragile-match"] + typing_letrec env + [ (name, func) ] + ~tvar_env ~cenv ~global_env ~diagnostics + with + | env_with_funs, (binder, fn) :: [] -> + let body = check_go env_with_funs body expect_ty in + let ty = Typedtree_util.type_of_typed_expr body in + Texpr_letfn + { + binder; + fn; + body; + ty; + loc_; + is_rec = Typedtree_util.is_rec binder fn; + } + | _ -> assert false) + | _, Pexpr_letrec { bindings = funs; body; loc_ } -> + let env_with_funs, bindings = + typing_letrec env funs ~tvar_env ~cenv ~global_env ~diagnostics + in + let body = check_go env_with_funs body expect_ty in + let ty = Typedtree_util.type_of_typed_expr body in + Texpr_letrec { bindings; body; ty; loc_ } + | _, Pexpr_letmut { binder; ty; expr; body; loc_ } -> + let env, binder, expr, konstraint = + typing_letmut env binder ty expr ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + let body = check_go env body expect_ty in + let ty = Typedtree_util.type_of_typed_expr body in + Texpr_letmut { binder; konstraint; expr; body; ty; loc_ } + | _, Pexpr_if { cond; ifso; ifnot = None; loc_ } -> + let cond = check_go env cond expect_bool in + let ifso_env = + Typeutil.add_pat_binders env (Typedtree_util.pat_binders_of_cond cond) + in + let ifso = check_go ifso_env ifso Ignored in + (match expect_ty with + | Ignored -> () + | Expect_type expect_ty -> + unify_expr_and_store_error ~expect_ty ~actual_ty:Stype.unit + ~diagnostics loc_); + Texpr_if { cond; ifso; ifnot = None; ty = Stype.unit; loc_ } + | _, Pexpr_if { cond; ifso; ifnot = Some ifnot; loc_ } -> + let cond = check_go env cond expect_bool in + let ifso_env = + Typeutil.add_pat_binders env (Typedtree_util.pat_binders_of_cond cond) + in + let ifso = check_go ifso_env ifso expect_ty in + let ifnot = check_go env ifnot expect_ty in + let ty = Typedtree_util.type_of_typed_expr ifso in + Texpr_if { cond; ifso; ifnot = Some ifnot; ty; loc_ } + | _, Pexpr_guard { cond; otherwise; body; loc_ } -> + let cond = check_go env cond expect_bool in + let guard_env = + Typeutil.add_pat_binders env (Typedtree_util.pat_binders_of_cond cond) + in + let otherwise = + match otherwise with + | None -> None + | Some otherwise -> Some (check_go env otherwise expect_ty) + in + let body = check_go guard_env body expect_ty in + let ty = Typedtree_util.type_of_typed_expr body in + Texpr_guard { cond; otherwise; body; ty; loc_ } + | _, Pexpr_guard_let { pat; expr; otherwise; body; loc_ } -> + Local_diagnostics.add_warning diagnostics + { + kind = + Deprecated_syntax + { + old_usage = "guard let"; + purpose = "shorthand of pattern match"; + new_usage = Some "guard with is-expression"; + }; + loc = Syntax.loc_of_pattern pat; + }; + let pat_binders, pat, rhs = + typing_let env pat expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let otherwise = + match otherwise with + | None -> None + | Some otherwise -> + Some + (check_cases env otherwise + ~pat_ty:(Typedtree_util.type_of_typed_expr rhs) + ~action_ty:expect_ty ~tvar_env ~cenv ~global_env ~diagnostics + ~control_ctx) + in + let body = + check_go (Typeutil.add_pat_binders env pat_binders) body expect_ty + in + let ty = Typedtree_util.type_of_typed_expr body in + if Check_match.irrefutable_pattern pat then + Local_diagnostics.add_warning diagnostics + { kind = Unused_guard; loc = Typedtree.loc_of_pat pat }; + Texpr_guard_let { pat; rhs; pat_binders; otherwise; body; ty; loc_ } + | ( _, + Pexpr_try + { + body; + catch; + catch_all; + try_else; + try_loc_; + catch_loc_; + else_loc_; + loc_; + } ) -> + let error_ctx = ref (Control_ctx.Open_ctx Empty_ctx) in + let new_ctx = Control_ctx.with_error_ctx ~error_ctx control_ctx in + let body_expect_ty = + if try_else = None then expect_ty + else Expect_type (Stype.new_type_var Tvar_normal) + in + let body = + check_expr ~control_ctx:new_ctx ~tvar_env ~cenv ~global_env + ~diagnostics env body body_expect_ty + in + let error_ty = Control_ctx.error_ctx_to_stype !error_ctx in + let catch = + check_cases env catch ~pat_ty:error_ty ~action_ty:expect_ty ~tvar_env + ~cenv ~global_env ~diagnostics ~control_ctx + in + let try_else = + match try_else with + | None -> None + | Some try_else -> + Some + (check_cases env try_else + ~pat_ty:(Typedtree_util.type_of_typed_expr body) + ~action_ty:expect_ty ~tvar_env ~cenv ~global_env ~diagnostics + ~control_ctx) + in + if not !(new_ctx.may_has_error) then ( + Local_diagnostics.add_warning diagnostics + { kind = Useless_try; loc = try_loc_ }; + match Stype.type_repr error_ty with + | Tvar link -> link := Tlink Stype.unit + | _ -> ()); + if catch_all then ( + control_ctx.may_has_error := true; + match control_ctx.error_ctx with + | Some error_ctx -> + store_error ~diagnostics + (Control_ctx.check_error_in_ctx ~error_ty ~ctx:error_ctx + catch_loc_) + | None -> + add_error diagnostics + (Errors.invalid_raise ~kind:`Catchall ~loc:catch_loc_)); + let ty = + match try_else with + | None -> Typedtree_util.type_of_typed_expr body + | Some ({ action; _ } :: _) -> Typedtree_util.type_of_typed_expr action + | Some [] -> ( + match expect_ty with Ignored -> Stype.unit | Expect_type ty -> ty) + in + Texpr_try + { + body; + catch; + catch_all; + try_else; + ty; + err_ty = error_ty; + catch_loc_; + else_loc_; + loc_; + } + | _, Pexpr_match { expr; cases; match_loc_; loc_ } -> + let expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let ty = Typedtree_util.type_of_typed_expr expr in + let cases = + check_cases env cases ~pat_ty:ty ~action_ty:expect_ty ~tvar_env ~cenv + ~global_env ~diagnostics ~control_ctx + in + let ty = + match expect_ty with Ignored -> Stype.unit | Expect_type ty -> ty + in + Texpr_match { expr; cases; ty; match_loc_; loc_ } + | _, Pexpr_loop { args; body; label; loop_loc_; loc_ } -> + check_loop ~label ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + env args body ~loc:loc_ ~loop_loc_ ~expect_ty + | ( _, + Pexpr_for + { binders; condition; continue_block; body; label; for_else; loc_ } ) + -> + check_for ~label ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + ~expect_ty env binders condition continue_block body for_else ~loc:loc_ + | ( _, + Pexpr_foreach + { + binders; + expr = + Pexpr_infix + { + op = { var_name = Lident (("..<" | "..=") as op) }; + lhs; + rhs; + loc_ = operator_loc; + }; + body; + else_block; + label; + loc_; + } ) -> + let inclusive = op = "..=" in + typing_range_for_in env binders lhs rhs body else_block ~label ~inclusive + ~operator_loc ~loc:loc_ ~expect_ty ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics + | _, Pexpr_foreach { binders; expr; body; else_block; label; loc_ } -> + typing_foreach ~label ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics ~expect_ty env binders expr body else_block ~loc:loc_ + | _, Pexpr_while { loop_cond; loop_body; label; loc_; while_else } -> + check_while ~label env loop_cond loop_body while_else ~expect_ty + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | _, Pexpr_static_assert { asserts; body } -> + typing_static_assert ~global_env ~tvar_env ~control_ctx ~diagnostics + ~expect_ty:(Some expect_ty) env asserts body + | Ignored, _ -> + let expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let actual_ty = Typedtree_util.type_of_typed_expr expr in + let loc_ = Typedtree.loc_of_typed_expr expr in + if not (Ctype.try_unify Stype.unit actual_ty) then + add_error diagnostics + (Errors.non_unit_cannot_be_ignored + ~ty:(Printer.type_to_string actual_ty) + ~loc:loc_); + expr + | Expect_type expect_ty, _ when Type.is_super_error expect_ty -> + let error_value = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let error_value_ty = Typedtree_util.type_of_typed_expr error_value in + let loc_ = Typedtree.loc_of_typed_expr error_value in + if Typeutil.is_tvar error_value_ty then + Ctype.unify_exn error_value_ty expect_ty + else if + not + (Type.is_suberror error_value_ty + || Type.is_super_error error_value_ty) + then + add_error diagnostics + (Errors.not_error_subtype + (Printer.type_to_string error_value_ty) + loc_); + error_value + | Expect_type expect_ty, _ -> ( + match Global_env.get_newtype_info global_env expect_ty with + | Some { newtype_constr; underlying_typ = _; recursive = _ } -> ( + match expr with + | Pexpr_array_get _ | Pexpr_array_set _ | Pexpr_array_augmented_set _ + | Pexpr_unary _ | Pexpr_group _ -> + assert false + | Pexpr_constr { constr } + | Pexpr_apply { func = Pexpr_constr { constr }; args = _; attr = _ } + when newtype_constr.constr_name = constr.constr_name.name -> + fallback expect_ty + | Pexpr_array _ | Pexpr_array_spread _ | Pexpr_constr _ + | Pexpr_apply { func = Pexpr_constr _; args = _; attr = _ } + | Pexpr_tuple _ | Pexpr_constant _ | Pexpr_interp _ + | Pexpr_function _ | Pexpr_record _ | Pexpr_record_update _ + | Pexpr_map _ | Pexpr_is _ -> ( + let loc = Syntax.loc_of_expression expr in + match[@warning "-fragile-match"] + Poly_type.instantiate_constr newtype_constr + with + | expect_ty', underlying_typ :: [] -> + Ctype.unify_exn expect_ty' expect_ty; + wrap_newtype_constr newtype_constr (fallback underlying_typ) + expect_ty loc ~diagnostics + | _ -> assert false) + | Pexpr_apply _ | Pexpr_dot_apply _ | Pexpr_pipe _ + | Pexpr_constraint _ | Pexpr_field _ | Pexpr_method _ | Pexpr_infix _ + | Pexpr_ident _ | Pexpr_array_get_slice _ | Pexpr_assign _ + | Pexpr_mutate _ | Pexpr_unit _ | Pexpr_as _ -> ( + let inferred_expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + let inferred_ty = + Typedtree_util.type_of_typed_expr inferred_expr + in + let loc = Syntax.loc_of_expression expr in + if Ctype.try_unify expect_ty inferred_ty then inferred_expr + else + match[@warning "-fragile-match"] + Poly_type.instantiate_constr newtype_constr + with + | expect_ty', underlying_typ :: [] -> + Ctype.unify_exn expect_ty' expect_ty; + if Ctype.try_unify underlying_typ inferred_ty then + wrap_newtype_constr newtype_constr inferred_expr + expect_ty loc ~diagnostics + else + let expected, actual = + Printer.type_pair_to_string expect_ty inferred_ty + in + add_error diagnostics + (Errors.expr_unify ~expected ~actual ~loc); + inferred_expr + | _ -> assert false) + | Pexpr_while _ | Pexpr_if _ | Pexpr_try _ | Pexpr_letfn _ + | Pexpr_letrec _ | Pexpr_let _ | Pexpr_sequence _ | Pexpr_match _ + | Pexpr_letmut _ | Pexpr_hole _ | Pexpr_return _ | Pexpr_raise _ + | Pexpr_break _ | Pexpr_continue _ | Pexpr_loop _ | Pexpr_foreach _ + | Pexpr_static_assert _ | Pexpr_guard _ | Pexpr_guard_let _ + | Pexpr_for _ | Pexpr_multiline_string _ -> + fallback expect_ty) + | None -> ( + let expect_ty = Stype.type_repr expect_ty in + match (expect_ty, expr) with + | ( T_constr { type_constructor = p; tys = actual_func_ty :: [] }, + Pexpr_function _ ) + when Type_path.equal p Type_path.Builtin.type_path_func_ref -> ( + let fn = fallback actual_func_ty in + let free_vars = Typedtree_util.free_vars fn in + match[@warning "-fragile-match"] fn with + | Texpr_function { func; ty = _; loc_ } -> + (if Ident.Hashset.length free_vars > 0 then + let captures = + Lst.map + (Ident.Hashset.to_list free_vars) + Ident.base_name + in + add_error diagnostics + (Errors.func_ref_no_capture ~captures ~loc:loc_)); + Texpr_function { func; ty = expect_ty; is_raw_ = true; loc_ } + | _ -> assert false) + | _ -> fallback expect_ty)) + : Typedtree.expr) and check_expr_no_cast (env : Local_env.t) (expr : Syntax.expr) (expect_ty : Stype.t) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let check_go = - check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let infer_go = - infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - match expr with - | Pexpr_array_get _ | Pexpr_array_get_slice _ | Pexpr_array_set _ - | Pexpr_array_augmented_set _ | Pexpr_unary _ -> - assert false - | Pexpr_let _ | Pexpr_letfn _ | Pexpr_letrec _ | Pexpr_letmut _ - | Pexpr_sequence _ | Pexpr_guard _ | Pexpr_guard_let _ | Pexpr_match _ - | Pexpr_if _ | Pexpr_try _ | Pexpr_for _ | Pexpr_while _ | Pexpr_foreach _ - | Pexpr_loop _ | Pexpr_static_assert _ -> - assert false - | Pexpr_constr { constr; loc_ } -> - typing_constr_or_constant constr None ~expect_ty:(Some expect_ty) ~env - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_apply { func = Pexpr_constr { constr }; args; attr; loc_ } -> - (if attr <> No_attr then - let error = Errors.invalid_apply_attr ~kind:`Constructor ~loc:loc_ in - add_error diagnostics error); - typing_constr_or_constant constr (Some args) ~expect_ty:(Some expect_ty) - ~env ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - | Pexpr_record { type_name; fields; loc_; trailing = _ } -> ( - let type_name, expect_ty = - match type_name with - | None -> (None, expect_ty) - | Some type_name -> ( - match - typing_type_name ~global_env ~tvar_env type_name ~diagnostics - with - | Some - ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), - type_name ) -> - let another_expect_ty : Stype.t = - T_constr - { - type_constructor = ty_decl.ty_constr; - tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - Ctype.unify_expr ~expect_ty ~actual_ty:another_expect_ty loc_ - |> Option.iter (add_error diagnostics); - (Some type_name, another_expect_ty) - | Some (_, tast_type_name) -> - add_error diagnostics - (Errors.not_a_record_type - ~name:(Longident.to_string type_name.name) - ~loc:type_name.loc_); - (Some tast_type_name, expect_ty) - | None -> (None, expect_ty)) - in - if Typeutil.is_tvar expect_ty then ( - let typed_record = - infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - Ctype.unify_expr ~expect_ty - ~actual_ty:(Typedtree_util.type_of_typed_expr typed_record) - loc_ - |> store_error ~diagnostics; - typed_record) - else - match - Global_env.labels_of_record global_env expect_ty ~loc:loc_ - ~context:`Create - with - | Ok labels -> - let _, labels = - Poly_type.instantiate_record ~ty_record:(`Known expect_ty) labels - in - type_guided_record_check fields labels expect_ty ~type_name ~env - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics ~loc:loc_ - | Error error -> - add_error diagnostics error; - infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics) - | Pexpr_record_update { type_name; record; fields; loc_ } -> ( - let type_name, expect_ty = - match type_name with - | None -> (None, expect_ty) - | Some type_name -> ( - match - typing_type_name ~global_env ~tvar_env type_name ~diagnostics - with - | Some - ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), - type_name ) -> - let another_expect_ty : Stype.t = - T_constr - { - type_constructor = ty_decl.ty_constr; - tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; - generic_ = false; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - Ctype.unify_expr ~expect_ty ~actual_ty:another_expect_ty loc_ - |> Option.iter (add_error diagnostics); - (Some type_name, another_expect_ty) - | Some (_, tast_type_name) -> - add_error diagnostics - (Errors.not_a_record_type - ~name:(Longident.to_string type_name.name) - ~loc:type_name.loc_); - (Some tast_type_name, expect_ty) - | None -> (None, expect_ty)) - in - let typed_old_record = check_go env record (Expect_type expect_ty) in - match - Global_env.labels_of_record global_env expect_ty ~loc:loc_ - ~context:`Update - with - | Ok all_fields -> - let _, all_fields = - Poly_type.instantiate_record ~ty_record:(`Known expect_ty) - all_fields - in - let typed_fields, all_fields = - ( type_guided_record_update_check env all_fields fields expect_ty - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics, - all_fields ) + ~(diagnostics : Local_diagnostics.t) = + (let check_go = + check_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let infer_go = + infer_expr ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + match expr with + | Pexpr_array_augmented_set _ -> assert false + | Pexpr_array_get _ -> assert false + | Pexpr_array_set _ -> assert false + | Pexpr_unary _ -> assert false + | Pexpr_loop _ -> assert false + | Pexpr_while _ -> assert false + | Pexpr_try _ -> assert false + | Pexpr_match _ -> assert false + | Pexpr_guard _ -> assert false + | Pexpr_letmut _ -> assert false + | Pexpr_letfn _ -> assert false + | Pexpr_let _ -> assert false + | Pexpr_letrec _ -> assert false + | Pexpr_sequence _ -> assert false + | Pexpr_guard_let _ -> assert false + | Pexpr_if _ -> assert false + | Pexpr_for _ -> assert false + | Pexpr_foreach _ -> assert false + | Pexpr_static_assert _ -> assert false + | Pexpr_constr { constr; loc_ } -> + typing_constr_or_constant constr None ~expect_ty:(Some expect_ty) ~env + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_apply { func = Pexpr_constr { constr }; args; attr; loc_ } -> + (if attr <> No_attr then + let error = + Errors.invalid_apply_attr ~kind:`Constructor + ~attr:(Syntax.string_of_apply_attr attr) + ~loc:loc_ in - Texpr_record_update - { - type_name; - record = typed_old_record; - all_fields; - fields = typed_fields; - ty = expect_ty; - loc_; - } - | Error e -> - add_error diagnostics e; - infer_go env expr) - | Pexpr_function { func = Match _ } -> assert false - | Pexpr_function - { - func = - Lambda - { parameters; params_loc_; body; return_type; kind_; has_error }; - loc_; - } -> - let n = List.length parameters in - let check_param_annotation (p : Syntax.parameter) expect_param_ty = - match p.param_annot with - | None -> (expect_param_ty, None) - | Some syntax_ty -> - let typedtree_ty = - typing_type syntax_ty ~tvar_env ~global_env ~diagnostics - in - let sty = Typedtree_util.stype_of_typ typedtree_ty in - Ctype.unify_param p.param_binder.binder_name - ~expect_ty:expect_param_ty ~actual_ty:sty p.param_binder.loc_ - |> store_error ~diagnostics; - (sty, Some typedtree_ty) - in - let check_return_annotation expect_return_ty expect_err_ty = - match return_type with - | None -> - ( expect_return_ty, - expect_err_ty, - Toplevel_typer.No_error_type_annotated ) - | Some (syntax_ty, syntax_err_ty) -> - let loc = Syntax.loc_of_type_expression syntax_ty in - let unify expect_ty actual_ty = - Ctype.unify_expr ~expect_ty ~actual_ty loc - |> store_error ~diagnostics - [@@inline] - in - let unify_err expect_ty actual_ty = - match (expect_ty, actual_ty) with - | Some expect_ty, Some actual_ty -> unify expect_ty actual_ty - | None, Some actual_ty -> - let err = - Errors.error_type_mismatch ~loc ~expected_ty:"no error" - ~actual_ty:(Printer.type_to_string actual_ty) - in - add_error diagnostics err - | Some _expect_ty, None -> - let err = Errors.anonymous_missing_error_annotation loc in - add_error diagnostics err - | None, None -> () - [@@inline] - in - let ty = typing_type syntax_ty ~tvar_env ~global_env ~diagnostics in - let ret_ty = Typedtree_util.stype_of_typ ty in - unify expect_return_ty ret_ty; - let err_sty, err_typ = - match syntax_err_ty with - | Error_typ { ty = err_ty } -> - let typ = - typing_type ~global_env ~tvar_env err_ty ~diagnostics - in - let sty = Typedtree_util.stype_of_typ typ in - (Some sty, Typedtree.Error_typ { ty = typ }) - | Default_error_typ { loc_ } -> - (Some Typeutil.default_err_type, Default_error_typ { loc_ }) - | No_error_typ -> - ( (if has_error then Some Typeutil.default_err_type else None), - No_error_typ ) - in - unify_err expect_err_ty err_sty; - (ret_ty, err_sty, Annotated (ty, err_typ)) - in - let ({ params_ty; ret_ty; err_ty; ret_annotation } - : Toplevel_typer.typed_fn_annotation) = - match Stype.type_repr expect_ty with - | Tarrow - { - params_ty = expect_params_ty; - ret_ty = expect_ret_ty; - err_ty = expect_err_ty; - } as expect_ty -> - let n_expect = List.length expect_params_ty in - if n_expect = n then - let params_ty = - Lst.map2 parameters expect_params_ty check_param_annotation - in - let ret_ty, err_ty, ret_annotation = - check_return_annotation expect_ret_ty expect_err_ty - in - { params_ty; ret_ty; err_ty; ret_annotation } - else - let ty = Printer.type_to_string expect_ty in - let err = - Errors.func_param_num_mismatch ~loc:loc_ ~expected:n_expect - ~actual:n ~ty - in - add_error diagnostics err; - let expect_params_ty = - if n > n_expect then - expect_params_ty - @ Type.type_var_list (n - n_expect) Tvar_error - else Lst.take n expect_params_ty - in - let params_ty = - Lst.map2 parameters expect_params_ty check_param_annotation - in - let ret_ty, err_ty, ret_annotation = - check_return_annotation expect_ret_ty expect_err_ty - in - { params_ty; ret_ty; err_ty; ret_annotation } - | Tvar ({ contents = Tnolink _ } as link) -> - let typed_fn_annotation = - typing_function_annotation parameters return_type ~has_error - ~tvar_env ~global_env ~diagnostics - in - let params_ty = Lst.map typed_fn_annotation.params_ty fst in - let ret_ty = typed_fn_annotation.ret_ty in - let err_ty = typed_fn_annotation.err_ty in - let arrow_ty = - Stype.Tarrow { params_ty; ret_ty; err_ty; generic_ = false } - in - link := Tlink arrow_ty; - typed_fn_annotation - | expect_ty -> - (if expect_ty <> T_blackhole then - let expected, actual = - (Printer.type_to_string expect_ty, "function type") + add_error diagnostics error); + typing_constr_or_constant constr (Some args) ~expect_ty:(Some expect_ty) + ~env ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + | Pexpr_record { type_name; fields; loc_; trailing = _ } -> ( + let type_name, expect_ty = + match type_name with + | None -> (None, expect_ty) + | Some type_name -> ( + match + typing_type_name ~global_env ~tvar_env type_name ~diagnostics + with + | Some + ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), + type_name ) -> + let another_expect_ty : Stype.t = + T_constr + { + type_constructor = ty_decl.ty_constr; + tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; + generic_ = false; + is_suberror_ = false; + } + in + unify_expr_and_store_error ~expect_ty + ~actual_ty:another_expect_ty ~diagnostics loc_; + (Some type_name, another_expect_ty) + | Some (Tname_local_type ({ kind = Struct _; _ } as t), type_name) + -> + let another_expect_ty : Stype.t = + T_constr + { + type_constructor = + Type_path.local_type t.toplevel_id t.name; + tys = Tvar_env.get_types t.ty_params_; + generic_ = false; + is_suberror_ = false; + } + in + unify_expr_and_store_error ~expect_ty + ~actual_ty:another_expect_ty ~diagnostics loc_; + (Some type_name, another_expect_ty) + | Some (_, tast_type_name) -> + add_error diagnostics + (Errors.not_a_record_type + ~name:(Longident.to_string type_name.name) + ~loc:type_name.loc_); + (Some tast_type_name, expect_ty) + | None -> (None, expect_ty)) + in + if Typeutil.is_tvar expect_ty then ( + let typed_record = + infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + unify_expr_and_store_error ~expect_ty + ~actual_ty:(Typedtree_util.type_of_typed_expr typed_record) + ~diagnostics loc_; + typed_record) + else + match + Global_env.labels_of_record global_env expect_ty ~loc:loc_ + ~context:`Create + with + | Ok labels -> + let _, labels = + Poly_type.instantiate_record ~ty_record:(`Known expect_ty) labels + in + type_guided_record_check fields labels expect_ty ~type_name ~env + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics ~loc:loc_ + | Error error -> + add_error diagnostics error; + infer_record env fields loc_ ~type_name ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics) + | Pexpr_record_update { type_name; record; fields; loc_ } -> ( + let type_name, expect_ty = + match type_name with + | None -> (None, expect_ty) + | Some type_name -> ( + match + typing_type_name ~global_env ~tvar_env type_name ~diagnostics + with + | Some + ( Tname_defined ({ ty_desc = Record_type _; _ } as ty_decl), + type_name ) -> + let another_expect_ty : Stype.t = + T_constr + { + type_constructor = ty_decl.ty_constr; + tys = Type.type_var_list ty_decl.ty_arity Tvar_normal; + generic_ = false; + is_suberror_ = false; + } + in + unify_expr_and_store_error ~expect_ty + ~actual_ty:another_expect_ty ~diagnostics loc_; + (Some type_name, another_expect_ty) + | Some (_, tast_type_name) -> + add_error diagnostics + (Errors.not_a_record_type + ~name:(Longident.to_string type_name.name) + ~loc:type_name.loc_); + (Some tast_type_name, expect_ty) + | None -> (None, expect_ty)) + in + let typed_old_record = check_go env record (Expect_type expect_ty) in + match + Global_env.labels_of_record global_env expect_ty ~loc:loc_ + ~context:`Update + with + | Ok all_fields -> + let _, all_fields = + Poly_type.instantiate_record ~ty_record:(`Known expect_ty) + all_fields + in + let typed_fields, all_fields = + ( type_guided_record_update_check env all_fields fields expect_ty + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics, + all_fields ) + in + Texpr_record_update + { + type_name; + record = typed_old_record; + all_fields; + fields = typed_fields; + ty = expect_ty; + loc_; + } + | Error e -> + add_error diagnostics e; + infer_go env expr) + | Pexpr_function { func = Match _ } -> assert false + | Pexpr_function + { + func = + Lambda + { + parameters; + params_loc_; + body; + return_type; + kind_; + has_error; + is_async; + }; + loc_; + } -> + let n = List.length parameters in + let check_param_annotation (p : Syntax.parameter) expect_param_ty = + match Syntax.ty_of_param p with + | None -> (expect_param_ty, None) + | Some syntax_ty -> + let typedtree_ty = + typing_type syntax_ty ~tvar_env ~global_env ~diagnostics + in + let sty = Typedtree_util.stype_of_typ typedtree_ty in + let binder_name = Syntax.binder_name_of_param p in + let loc = Syntax.loc_of_param_binder p in + store_error ~diagnostics + (Ctype.unify_param binder_name ~expect_ty:expect_param_ty + ~actual_ty:sty loc); + (sty, Some typedtree_ty) + in + let check_return_annotation expect_return_ty expect_err_ty = + let unify_ret expect_ty actual_ty + (annotation : Typeutil.ret_annotation) = + match annotation with + | Annotated (ret_ty, _) -> + let loc = Typedtree.loc_of_typ ret_ty in + unify_expr_and_store_error ~expect_ty ~actual_ty ~diagnostics loc + | Has_super_error _ | No_annotation -> + Ctype.unify_exn expect_ty actual_ty + [@@inline] + in + let unify_err expect_ty (annotation : Typeutil.ret_annotation) = + let do_unify ~actual_ty loc = + match expect_ty with + | Some expect_ty -> + unify_expr_and_store_error ~expect_ty ~actual_ty ~diagnostics + loc + | None -> + let err = + Errors.error_type_mismatch ~loc ~expected_ty:"no error" + ~actual_ty:(Printer.type_to_string actual_ty) + in + add_error diagnostics err + [@@inline] + in + let check_missing_error loc_ = + match expect_ty with + | Some _expect_ty -> + add_error diagnostics + (Errors.anonymous_missing_error_annotation loc_) + | None -> () + [@@inline] + in + match annotation with + | Annotated (_, Error_typ { ty }) -> + let err_sty = Typedtree_util.stype_of_typ ty in + do_unify ~actual_ty:err_sty (Typedtree.loc_of_typ ty); + Some err_sty + | Annotated (_, Default_error_typ { loc_ }) | Has_super_error loc_ -> + let err_sty = Typeutil.default_err_type in + do_unify ~actual_ty:err_sty loc_; + Some err_sty + | No_annotation -> expect_ty + | Annotated (ret_ty, No_error_typ) -> + check_missing_error (Typedtree.loc_of_typ ret_ty); + None + [@@inline] + in + let ({ ret_sty; err_sty = _; annotation } : Typeutil.ret_info) = + Typeutil.handle_return_annotation return_type ~has_error + ~typing_type:(typing_type ~tvar_env ~global_env ~diagnostics) + in + unify_ret expect_return_ty ret_sty annotation; + let err_sty = unify_err expect_err_ty annotation in + (ret_sty, err_sty, annotation) + in + let ({ params_ty; ret_ty; err_ty; is_async; ret_annotation } + : Local_typing_worklist.typed_fn_annotation) = + match Stype.type_repr expect_ty with + | Tarrow + { + params_ty = expect_params_ty; + ret_ty = expect_ret_ty; + err_ty = expect_err_ty; + is_async = expect_async; + } as expect_ty -> + let is_async = + if is_async && not expect_async then ( + add_error diagnostics + (Errors.generic_type_mismatch ~header:"Type Mismatch" + ~expected:(Printer.type_to_string expect_ty) + ~actual:"async function type" ~loc:loc_); + true) + else expect_async + in + let n_expect = List.length expect_params_ty in + if n_expect = n then + let params_ty = + Lst.map2 parameters expect_params_ty check_param_annotation in - add_error diagnostics - (Errors.type_mismatch ~expected ~actual ~loc:loc_)); - typing_function_annotation parameters return_type ~has_error - ~tvar_env ~global_env ~diagnostics - in - let env, params = - check_function_params env parameters params_ty ~is_global:false - ~tvar_env ~cenv ~global_env ~diagnostics - in - let error_ctx = - match err_ty with - | None -> None - | Some t -> - let ctx : Control_ctx.error_ctx = - match Stype.type_repr t with - | T_constr { type_constructor = Basic_type_path.T_error; _ } -> - Fixed_ctx Supererror - | T_constr { type_constructor = p; is_suberror_ = true; _ } -> - Fixed_ctx (Suberror p) - | Tparam { index; name_ } -> Fixed_ctx (Tparam { index; name_ }) - | Tvar { contents = Tnolink _ } as t -> - Ctype.unify_exn t Stype.error; - Open_ctx Empty_ctx - | _ -> Open_ctx Empty_ctx - in - Some (ref ctx) - in - let control_ctx = Control_ctx.make_fn ~return:ret_ty ~error_ctx in - let body = - check_expr env body (Expect_type ret_ty) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - (if not !(control_ctx.has_error) then + let ret_ty, err_ty, ret_annotation = + check_return_annotation expect_ret_ty expect_err_ty + in + { params_ty; ret_ty; err_ty; is_async; ret_annotation } + else + let ty = Printer.type_to_string expect_ty in + let err = + Errors.func_param_num_mismatch ~loc:loc_ ~expected:n_expect + ~actual:n ~ty + in + add_error diagnostics err; + let expect_params_ty = + if n > n_expect then + expect_params_ty + @ Type.type_var_list (n - n_expect) Tvar_error + else Lst.take expect_params_ty n + in + let params_ty = + Lst.map2 parameters expect_params_ty check_param_annotation + in + let ret_ty, err_ty, ret_annotation = + check_return_annotation expect_ret_ty expect_err_ty + in + { params_ty; ret_ty; err_ty; is_async = false; ret_annotation } + | Tvar ({ contents = Tnolink _ } as link) -> + let typed_fn_annotation = + typing_function_annotation parameters return_type ~has_error + ~is_async ~tvar_env ~global_env ~diagnostics + in + let params_ty = Lst.map typed_fn_annotation.params_ty fst in + let ret_ty = typed_fn_annotation.ret_ty in + let err_ty = typed_fn_annotation.err_ty in + let arrow_ty = + Stype.Tarrow + { params_ty; ret_ty; err_ty; is_async; generic_ = false } + in + link := Tlink arrow_ty; + typed_fn_annotation + | expect_ty -> + (if expect_ty <> T_blackhole then + let expected, actual = + (Printer.type_to_string expect_ty, "function type") + in + add_error diagnostics + (Errors.type_mismatch ~expected ~actual ~loc:loc_)); + typing_function_annotation parameters return_type ~has_error + ~is_async ~tvar_env ~global_env ~diagnostics + in + let env, params = + check_function_params env parameters params_ty ~is_global:false + ~tvar_env ~cenv ~global_env ~diagnostics + in + let error_ctx = + match err_ty with + | None -> None + | Some t -> + let ctx : Control_ctx.error_ctx = + match Stype.type_repr t with + | T_constr { type_constructor = Basic_type_path.T_error; _ } -> + Fixed_ctx Supererror + | T_constr { type_constructor = p; is_suberror_ = true; _ } -> + Fixed_ctx (Suberror p) + | Tparam { index; name_ } -> Fixed_ctx (Tparam { index; name_ }) + | Tvar { contents = Tnolink _ } as t -> + Ctype.unify_exn t Stype.error; + Open_ctx Empty_ctx + | _ -> Open_ctx Empty_ctx + in + Some (ref ctx) + in + let control_ctx = + Control_ctx.make_fn ~return:ret_ty ~error_ctx ~is_async + in + let body = + check_expr env body (Expect_type ret_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + if not !(control_ctx.may_has_error) then + Typeutil.report_unused_error_annotation ret_annotation diagnostics; + let ret_constraint = match ret_annotation with - | Annotated (_, Error_typ { ty }) -> - let loc = Typedtree.loc_of_typ ty in - Local_diagnostics.add_warning diagnostics - { kind = Useless_error_type; loc } - | Annotated (_, Default_error_typ { loc_ = loc }) | Has_error_type loc - -> - Local_diagnostics.add_warning diagnostics - { kind = Useless_error_type; loc } - | Annotated (_, No_error_typ) | No_error_type_annotated -> ()); - let ret_constraint = - match ret_annotation with - | Annotated r -> Some r - | Has_error_type _ | No_error_type_annotated -> None - in - Texpr_function - { - func = - { params; params_loc_; body; ty = expect_ty; ret_constraint; kind_ }; - ty = expect_ty; - loc_; - } - | Pexpr_array { exprs; loc_ } -> ( - match Stype.type_repr expect_ty with - | T_constr { type_constructor; tys = ty_elem :: [] } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_fixedarray -> - let texprs = - Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) - in - Texpr_array - { exprs = texprs; ty = expect_ty; is_fixed_array = true; loc_ } - | T_constr { type_constructor; tys = ty_elem :: [] } - when Type_path.equal type_constructor Type_path.Builtin.type_path_array - -> - let texprs = - Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) - in - Texpr_array - { exprs = texprs; ty = expect_ty; is_fixed_array = false; loc_ } - | expect_ty when Type.same_type expect_ty Stype.json -> - let texprs = - Lst.map exprs (fun e -> check_go env e (Expect_type Stype.json)) - in - Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ - Json_literal.array - (Texpr_array + | Annotated r -> Some r + | Has_super_error _ | No_annotation -> None + in + Texpr_function + { + func = + { + params; + params_loc_; + body; + ty = expect_ty; + ret_constraint; + kind_; + }; + ty = expect_ty; + is_raw_ = false; + loc_; + } + | Pexpr_array { exprs; loc_ } -> ( + match Stype.type_repr expect_ty with + | T_constr { type_constructor; tys = ty_elem :: [] } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_fixedarray -> + let texprs = + Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) + in + Texpr_array + { exprs = texprs; ty = expect_ty; is_fixed_array = true; loc_ } + | T_constr { type_constructor; tys = ty_elem :: [] } + when Type_path.equal type_constructor Type_path.Builtin.type_path_array + -> + let texprs = + Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) + in + Texpr_array + { exprs = texprs; ty = expect_ty; is_fixed_array = false; loc_ } + | expect_ty when Type.same_type expect_ty Stype.json -> + let texprs = + Lst.map exprs (fun e -> check_go env e (Expect_type Stype.json)) + in + Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ + Json_literal.array + (Texpr_array + { + exprs = texprs; + ty = Builtin.type_array Stype.json; + is_fixed_array = false; + loc_; + }) + | T_builtin T_bytes -> ( + let exception Not_all_literal in + let buf = Buffer.create 16 in + let rec try_combine_byte_literal (elem : Syntax.expr list) = + match elem with + | [] -> Buffer.contents buf + | Pexpr_constant { c = Const_byte b } :: rest -> + Buffer.add_int8 buf b.byte_val; + try_combine_byte_literal rest + | Pexpr_constant { c = Const_int i } :: rest -> + (match Int32.of_string_opt i with + | Some v when v >= 0l && v <= 255l -> + Buffer.add_int8 buf (Int32.to_int v) + | _ -> raise_notrace Not_all_literal); + try_combine_byte_literal rest + | _ -> raise_notrace Not_all_literal + in + try + let bs = try_combine_byte_literal exprs in + Texpr_constant { - exprs = texprs; - ty = Builtin.type_array Stype.json; - is_fixed_array = false; + c = C_bytes { v = bs; repr = None }; + ty = expect_ty; + name_ = None; + loc_; + } + with Not_all_literal -> + let texprs = + Lst.map exprs (fun e -> check_go env e (Expect_type Stype.byte)) + in + Texpr_array + { exprs = texprs; ty = expect_ty; is_fixed_array = true; loc_ }) + | T_builtin T_string -> ( + let exception Not_all_literal in + let vec = Basic_vec_int.empty () in + let rec try_combine_char_literal (elem : Syntax.expr list) = + match elem with + | [] -> Basic_utf8.string_of_vec vec ~offset:0 ~len:vec.len + | Pexpr_constant { c = Const_char c } :: rest -> + Basic_vec_int.push vec (Uchar.to_int c.char_val); + try_combine_char_literal rest + | _ -> raise_notrace Not_all_literal + in + try + let s = try_combine_char_literal exprs in + Texpr_constant + { c = C_string s; ty = expect_ty; name_ = None; loc_ } + with Not_all_literal -> + let func : Syntax.expr = + Pexpr_method + { + type_name = + { name = Lident "StringBuilder"; is_object = false; loc_ }; + method_name = { label_name = "new"; loc_ }; + loc_; + } + in + let self : Typedtree.expr = + infer_go env + (Pexpr_apply { func; args = []; attr = No_attr; loc_ }) + in + let sb_ty = Typedtree_util.type_of_typed_expr self in + let push = + typing_self_method sb_ty + { label_name = "write_char"; loc_ = Rloc.no_location } + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv + ~diagnostics + in + let sb_expr = + Lst.fold_left exprs self (fun self -> + fun elem -> + let self_dotdot_apply func arg = + (Texpr_apply + { + func; + args = + [ + { arg_value = self; arg_kind = Positional }; + { arg_value = arg; arg_kind = Positional }; + ]; + kind_ = Dot_return_self; + ty = sb_ty; + loc_ = Rloc.no_location; + } + : Typedtree.expr) + [@@inline] + in + let texpr = check_go env elem (Expect_type Stype.char) in + self_dotdot_apply push texpr) + in + let sb_to_string = + typing_self_method + (Typedtree_util.type_of_typed_expr sb_expr) + ({ label_name = "to_string"; loc_ = Rloc.no_location } + : Syntax.label) + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv + ~diagnostics + in + Texpr_apply + { + func = sb_to_string; + args = [ { arg_value = sb_expr; arg_kind = Positional } ]; + kind_ = Normal; + ty = expect_ty; loc_; }) - | _ -> - let ty_elem = Stype.new_type_var Tvar_normal in - let texprs = - Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) - in - let ty = Builtin.type_array ty_elem in - Ctype.unify_expr ~expect_ty ~actual_ty:ty loc_ - |> store_error ~diagnostics; - Texpr_array { exprs = texprs; ty; is_fixed_array = false; loc_ }) - | Pexpr_array_spread { elems; loc_ } -> ( - match Stype.type_repr expect_ty with - | expect_ty when Type.same_type expect_ty Stype.json -> - typing_array_spread env elems ~loc:loc_ - ~expect_ty:(Some (Builtin.type_array Stype.json)) - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - |> Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ - Json_literal.array - | T_constr { type_constructor; tys = elem_ty :: [] } - when Type_path.equal type_constructor Type_path.Builtin.type_path_iter - -> - let array_ty = Builtin.type_array elem_ty in - let array_iter = - typing_self_method array_ty - ({ label_name = "iter"; loc_ = Rloc.no_location } : Syntax.label) - ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv - ~diagnostics - in - Ctype.unify_exn - (Typedtree_util.type_of_typed_expr array_iter) - (Builtin.type_arrow [ array_ty ] expect_ty ~err_ty:None); - let array_expr = - typing_array_spread env elems ~loc:loc_ ~expect_ty:(Some array_ty) - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - Texpr_apply - { - func = array_iter; - args = [ { arg_value = array_expr; arg_kind = Positional } ]; - kind_ = Normal; - ty = expect_ty; - loc_; - } - | expect_ty -> - typing_array_spread env elems ~loc:loc_ ~expect_ty:(Some expect_ty) - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics) - | Pexpr_tuple { exprs; loc_ } -> - let arity = List.length exprs in - let tys = - Type.filter_product ~blame:Filter_itself ~arity:(Some arity) expect_ty - loc_ - |> take_info_partial ~diagnostics - in - let texprs = - List.map2 (fun e ty -> check_go env e (Expect_type ty)) exprs tys - in - Texpr_tuple { exprs = texprs; ty = expect_ty; loc_ } - | Pexpr_pipe { lhs; rhs; loc_ } -> - typing_pipe env lhs rhs ~expect_ty ~loc:loc_ ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - | Pexpr_constant { c = Const_bool b; loc_ } - when Type.same_type expect_ty Stype.json -> - Json_literal.make_json_const_expr ~global_env ~diagnostics ~loc:loc_ - (if b then Json_literal.true_ else Json_literal.false_) - | Pexpr_constant { c = Const_int rep | Const_double rep; loc_ } - when Type.same_type expect_ty Stype.json -> - let _, c = - Typeutil.typing_constant (Const_double rep) ~expect_ty:None ~loc:loc_ - |> take_info_partial ~diagnostics - in - Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ - Json_literal.number - (Texpr_constant { c; ty = Stype.double; name_ = None; loc_ }) - | Pexpr_constant { c = Const_string { string_val; string_repr = _ }; loc_ } - when Type.same_type expect_ty Stype.json -> - Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ - Json_literal.string - (Texpr_constant - { c = C_string string_val; ty = Stype.string; name_ = None; loc_ }) - | Pexpr_interp { elems; loc_ } when Type.same_type expect_ty Stype.json -> - Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ - Json_literal.string - (typing_interp ~expect_ty:Stype.json ~control_ctx ~global_env - ~diagnostics ~tvar_env ~cenv env elems loc_) - | Pexpr_constant { c; loc_ } -> - let ty, c = - Typeutil.typing_constant ~expect_ty:(Some expect_ty) c ~loc:loc_ - |> take_info_partial ~diagnostics - in - Ctype.unify_expr ~expect_ty ~actual_ty:ty loc_ |> store_error ~diagnostics; - Texpr_constant { c; ty = expect_ty; name_ = None; loc_ } - | Pexpr_interp { elems; loc_ } -> - typing_interp ~expect_ty ~control_ctx ~global_env ~diagnostics ~tvar_env - ~cenv env elems loc_ - | Pexpr_constraint { expr; ty = ty_expr; loc_ } -> - let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in - let stype = Typedtree_util.stype_of_typ ty in - Ctype.unify_expr ~expect_ty ~actual_ty:stype loc_ - |> store_error ~diagnostics; - Texpr_constraint - { - expr = check_go env expr (Expect_type stype); - konstraint = ty; - ty = stype; - loc_; - } - | Pexpr_mutate { record; accessor; field; augmented_by; loc_ } -> ( - Ctype.unify_expr ~expect_ty ~actual_ty:Stype.unit loc_ - |> store_error ~diagnostics; - match accessor with - | Label label -> - typing_mutate env record label field augmented_by loc_ ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics - | Index _ | Newtype -> - add_error diagnostics (Errors.tuple_not_mutable loc_); - Texpr_tuple { exprs = []; ty = Stype.unit; loc_ }) - | Pexpr_return { return_value; loc_ } -> - check_return_value env return_value expect_ty ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics ~loc:loc_ - | Pexpr_raise { err_value; loc_ } -> - typing_raise env err_value expect_ty ~loc:loc_ ~control_ctx ~tvar_env - ~cenv ~global_env ~diagnostics - | Pexpr_apply { func; args; attr; loc_ } -> - typing_application env (infer_go env func) args ~expect_ty ~kind:Normal - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics - | Pexpr_unit { loc_; _ } -> - Ctype.unify_expr ~expect_ty ~actual_ty:Stype.unit loc_ - |> store_error ~diagnostics; - Texpr_unit { loc_ } - | Pexpr_dot_apply { self; method_name; args; return_self; attr; loc_ } -> - let self = infer_go env self in - let ty_self = Typedtree_util.type_of_typed_expr self in - let method_expr = - typing_self_method ty_self method_name - ~src:Type_constraint.Dot_src_direct ~loc:method_name.loc_ ~tvar_env - ~cenv ~global_env ~diagnostics - in - typing_application env method_expr args ~self ~expect_ty - ~kind:(if return_self then Dot_return_self else Dot) - ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics - | Pexpr_break { arg; loc_ } -> - check_break env arg ~loc:loc_ ~expect_ty ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - | Pexpr_continue { args; loc_ } -> - check_continue env args ~loc:loc_ ~expect_ty ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - | Pexpr_map { elems; loc_ } -> - typing_map_expr env elems ~expect_ty:(Some expect_ty) ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics ~loc:loc_ - | Pexpr_hole { kind; loc_ } -> - (match kind with - | Incomplete -> add_error diagnostics (Errors.found_hole loc_) - | Synthesized -> () - | Todo -> - Local_diagnostics.add_warning diagnostics { kind = Todo; loc = loc_ }); - Texpr_hole { ty = expect_ty; loc_; kind } - | Pexpr_multiline_string { elems; loc_ } -> - check_go env - (desugar_multiline_string ~loc_ elems) - (Expect_type expect_ty) - | Pexpr_field _ | Pexpr_method _ | Pexpr_infix _ | Pexpr_ident _ - | Pexpr_assign _ | Pexpr_as _ -> - let texpr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics - in - Ctype.unify_expr ~expect_ty - ~actual_ty:(Typedtree_util.type_of_typed_expr texpr) - (Syntax.loc_of_expression expr) - |> store_error ~diagnostics; - texpr - | Pexpr_group _ -> assert false + | _ -> + let ty_elem = Stype.new_type_var Tvar_normal in + let texprs = + Lst.map exprs (fun e -> check_go env e (Expect_type ty_elem)) + in + let ty = Builtin.type_array ty_elem in + unify_expr_and_store_error ~expect_ty ~actual_ty:ty ~diagnostics loc_; + Texpr_array { exprs = texprs; ty; is_fixed_array = false; loc_ }) + | Pexpr_array_spread { elems; loc_ } -> ( + match Stype.type_repr expect_ty with + | expect_ty when Type.same_type expect_ty Stype.json -> + Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ + Json_literal.array + (typing_array_spread env elems ~kind:`Array ~loc:loc_ + ~expect_ty:(Some (Builtin.type_array Stype.json)) + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics) + | T_constr { type_constructor; tys = elem_ty :: [] } + when Type_path.equal type_constructor Type_path.Builtin.type_path_iter + -> + let array_ty = Builtin.type_array elem_ty in + let array_iter = + typing_self_method array_ty + ({ label_name = "iter"; loc_ = Rloc.no_location } : Syntax.label) + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv + ~diagnostics + in + Ctype.unify_exn + (Typedtree_util.type_of_typed_expr array_iter) + (Builtin.type_arrow [ array_ty ] expect_ty ~err_ty:None + ~is_async:false); + let array_expr = + typing_array_spread env elems ~kind:`Array ~loc:loc_ + ~expect_ty:(Some array_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + Texpr_apply + { + func = array_iter; + args = [ { arg_value = array_expr; arg_kind = Positional } ]; + kind_ = Normal; + ty = expect_ty; + loc_; + } + | T_builtin T_string -> + let sb_expr = + typing_array_spread env elems ~kind:`String ~loc:loc_ + ~expect_ty:(Some expect_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + let sb_to_string = + typing_self_method + (Typedtree_util.type_of_typed_expr sb_expr) + ({ label_name = "to_string"; loc_ = Rloc.no_location } + : Syntax.label) + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv + ~diagnostics + in + Texpr_apply + { + func = sb_to_string; + args = [ { arg_value = sb_expr; arg_kind = Positional } ]; + kind_ = Normal; + ty = expect_ty; + loc_; + } + | T_builtin T_bytes -> + let buffer_expr = + typing_array_spread env elems ~kind:`Bytes ~loc:loc_ + ~expect_ty:(Some expect_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + let contents = + typing_self_method + (Typedtree_util.type_of_typed_expr buffer_expr) + ({ label_name = "contents"; loc_ = Rloc.no_location } + : Syntax.label) + ~src:Dot_src_direct ~loc:loc_ ~global_env ~tvar_env ~cenv + ~diagnostics + in + Texpr_apply + { + func = contents; + args = [ { arg_value = buffer_expr; arg_kind = Positional } ]; + kind_ = Normal; + ty = expect_ty; + loc_; + } + | expect_ty -> + typing_array_spread env elems ~kind:`Array ~loc:loc_ + ~expect_ty:(Some expect_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics) + | Pexpr_tuple { exprs; loc_ } -> + let arity = List.length exprs in + let tys = + take_info_partial ~diagnostics + (Type.filter_product ~blame:Filter_itself ~arity:(Some arity) + expect_ty loc_) + in + let texprs = + List.map2 + (fun e -> fun ty -> check_go env e (Expect_type ty)) + exprs tys + in + Texpr_tuple { exprs = texprs; ty = expect_ty; loc_ } + | Pexpr_pipe { lhs; rhs; loc_ } -> + typing_pipe env lhs rhs ~expect_ty ~loc:loc_ ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + | Pexpr_constant { c = Const_bool b; loc_ } + when Type.same_type expect_ty Stype.json -> + Json_literal.make_json_const_expr ~global_env ~diagnostics ~loc:loc_ + (if b then Json_literal.true_ else Json_literal.false_) + | Pexpr_constant { c = Const_int rep | Const_double rep; loc_ } + when Type.same_type expect_ty Stype.json -> + let _, c = + Typeutil.typing_constant (Const_double rep) ~expect_ty:None ~loc:loc_ + ~diagnostics + in + Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ + Json_literal.number + (Texpr_constant { c; ty = Stype.double; name_ = None; loc_ }) + | Pexpr_constant { c = Const_string { string_val; string_repr = _ }; loc_ } + when Type.same_type expect_ty Stype.json -> + Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ + Json_literal.string + (Texpr_constant + { c = C_string string_val; ty = Stype.string; name_ = None; loc_ }) + | Pexpr_interp { elems; loc_ } when Type.same_type expect_ty Stype.json -> + Json_literal.make_json_expr ~global_env ~diagnostics ~loc:loc_ + Json_literal.string + (typing_interp ~expect_ty:Stype.json ~control_ctx ~global_env + ~diagnostics ~tvar_env ~cenv env elems loc_) + | Pexpr_interp { elems = _; loc_ } when Type.same_type expect_ty Stype.bytes + -> + add_error diagnostics + (Errors.overloaded_string_interpolation_for_bytes ~loc:loc_); + Texpr_hole + { ty = Stype.new_type_var Tvar_error; loc_; kind = Synthesized } + | Pexpr_constant { c; loc_ } -> + let ty, c = + Typeutil.typing_constant ~expect_ty:(Some expect_ty) c ~loc:loc_ + ~diagnostics + in + unify_expr_and_store_error ~expect_ty ~actual_ty:ty ~diagnostics loc_; + Texpr_constant { c; ty = expect_ty; name_ = None; loc_ } + | Pexpr_interp { elems; loc_ } -> + typing_interp ~expect_ty ~control_ctx ~global_env ~diagnostics ~tvar_env + ~cenv env elems loc_ + | Pexpr_constraint { expr; ty = ty_expr; loc_ } -> + let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in + let stype = Typedtree_util.stype_of_typ ty in + unify_expr_and_store_error ~expect_ty ~actual_ty:stype ~diagnostics loc_; + Texpr_constraint + { + expr = check_go env expr (Expect_type stype); + konstraint = ty; + ty = stype; + loc_; + } + | Pexpr_mutate { record; accessor; field; augmented_by; loc_ } -> ( + unify_expr_and_store_error ~expect_ty ~actual_ty:Stype.unit ~diagnostics + loc_; + match accessor with + | Label label -> + typing_mutate env record label field augmented_by loc_ ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics + | Index _ | Newtype -> + add_error diagnostics (Errors.tuple_not_mutable loc_); + Texpr_tuple { exprs = []; ty = Stype.unit; loc_ }) + | Pexpr_return { return_value; loc_ } -> + check_return_value env return_value expect_ty ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics ~loc:loc_ + | Pexpr_raise { err_value; loc_ } -> + typing_raise env err_value expect_ty ~loc:loc_ ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics + | Pexpr_apply { func; args; attr; loc_ } -> + typing_application env (infer_go env func) args ~expect_ty ~kind:Normal + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics + | Pexpr_unit { loc_; _ } -> + unify_expr_and_store_error ~expect_ty ~actual_ty:Stype.unit ~diagnostics + loc_; + Texpr_unit { loc_ } + | Pexpr_dot_apply { self; method_name; args; return_self; attr; loc_ } -> + let self = infer_go env self in + let ty_self = Typedtree_util.type_of_typed_expr self in + let method_expr = + typing_self_method ty_self method_name + ~src:Type_constraint.Dot_src_direct ~loc:method_name.loc_ ~tvar_env + ~cenv ~global_env ~diagnostics + in + typing_application env method_expr args ~self ~expect_ty + ~kind:(if return_self then Dot_return_self else Dot) + ~loc:loc_ ~control_ctx ~tvar_env ~cenv ~global_env ~attr ~diagnostics + | Pexpr_break { arg; label; loc_ } -> + check_break env arg ~label ~loc:loc_ ~expect_ty ~global_env ~tvar_env + ~cenv ~control_ctx ~diagnostics + | Pexpr_continue { args; label; loc_ } -> + check_continue env args ~label ~loc:loc_ ~expect_ty ~global_env ~tvar_env + ~cenv ~control_ctx ~diagnostics + | Pexpr_map { elems; loc_ } -> + typing_map_expr env elems ~expect_ty:(Some expect_ty) ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics ~loc:loc_ + | Pexpr_hole { kind; loc_ } -> + (match kind with + | Incomplete -> add_error diagnostics (Errors.found_hole loc_) + | Synthesized -> () + | Todo -> + control_ctx.may_has_error := true; + Local_diagnostics.add_warning diagnostics { kind = Todo; loc = loc_ }); + Texpr_hole { ty = expect_ty; loc_; kind } + | Pexpr_multiline_string { elems; loc_ } -> + check_go env + (desugar_multiline_string ~loc_ elems) + (Expect_type expect_ty) + | Pexpr_array_get_slice _ | Pexpr_field _ | Pexpr_method _ | Pexpr_infix _ + | Pexpr_ident _ | Pexpr_assign _ | Pexpr_as _ | Pexpr_is _ -> + let texpr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + unify_expr_and_store_error ~expect_ty + ~actual_ty:(Typedtree_util.type_of_typed_expr texpr) + ~diagnostics + (Syntax.loc_of_expression expr); + texpr + | Pexpr_group _ -> assert false + : Typedtree.expr) and maybe_check (env : Local_env.t) (maybe : maybe_typed) (expect_ty : Stype.t) ~(control_ctx : Control_ctx.t) ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - match maybe with - | Typechecked texpr -> - unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty - ~actual_ty:(Typedtree_util.type_of_typed_expr texpr) - (Typedtree.loc_of_typed_expr texpr) - |> handle_unify_result ~diagnostics ~expr:texpr - | Not_yet expr -> - check_expr env expr (Expect_type expect_ty) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics + ~(diagnostics : Local_diagnostics.t) = + (match maybe with + | Typechecked texpr -> + handle_unify_result ~diagnostics ~expr:texpr + (unify_expr_allow_trait_upcast ~global_env ~cenv ~expect_ty + ~actual_ty:(Typedtree_util.type_of_typed_expr texpr) + (Typedtree.loc_of_typed_expr texpr)) + | Not_yet expr -> + check_expr env expr (Expect_type expect_ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + : Typedtree.expr) and type_guided_record_check ~(type_name : Typedtree.type_name option) (fields : Syntax.field_def list) labels record_ty ~env ~control_ctx - ~tvar_env ~cenv ~global_env ~diagnostics ~loc : Typedtree.expr = - let superfluous = - Typeutil.validate_record ~context:`Creation ~expected:labels - (Lst.map fields (fun (Field_def { label; _ }) -> label)) - ~record_ty ~is_strict:true ~loc - |> take_info_partial ~diagnostics - in - let check_label ty is_mut pos label_name = - Lst.fold_right fields [] (fun (Field_def { label; expr; is_pun; _ }) acc -> - if label.label_name = label_name then - let expr = - check_expr env expr (Expect_type ty) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - Typedtree.Field_def { label; expr; is_mut; is_pun; pos } :: acc - else acc) - [@@inline] - in - let check_superfluous label_name = - check_label - (Stype.new_type_var Tvar_error) - false Typeutil.unknown_pos label_name - [@@inline] - in - let fields = - Lst.flat_map_append labels - ~init:(Lst.concat_map superfluous check_superfluous) - ~f:(fun ({ field_name; _ } as field_info) -> - check_label field_info.ty_field field_info.mut field_info.pos field_name) - in - Texpr_record { type_name; fields; ty = record_ty; loc_ = loc } + ~tvar_env ~cenv ~global_env ~diagnostics ~loc = + (let superfluous = + Typeutil.validate_record ~context:`Creation ~expected:labels + (Lst.map fields (fun (Field_def { label; _ }) -> label)) + ~record_ty ~is_strict:true ~loc ~diagnostics + in + let check_label ty is_mut pos label_name = + Lst.fold_right fields [] (fun (Field_def { label; expr; is_pun; _ }) -> + fun acc -> + if label.label_name = label_name then + let expr = + check_expr env expr (Expect_type ty) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + Typedtree.Field_def { label; expr; is_mut; is_pun; pos } :: acc + else acc) + [@@inline] + in + let check_superfluous label_name = + check_label + (Stype.new_type_var Tvar_error) + false Typeutil.unknown_pos label_name + [@@inline] + in + let fields = + Lst.flat_map_append labels + ~init:(Lst.concat_map superfluous check_superfluous) + ~f:(fun ({ field_name; _ } as field_info) -> + check_label field_info.ty_field field_info.mut field_info.pos + field_name) + in + Texpr_record { type_name; fields; ty = record_ty; loc_ = loc } + : Typedtree.expr) and type_guided_record_update_check (env : Local_env.t) (old_fields : Typedecl_info.fields) (new_fields : Syntax.field_def list) (ty_record : Stype.t) ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - : Typedtree.field_def list = - let lookup_label (label : string) ~loc : - Typedecl_info.field Local_diagnostics.info = - match Lst.find_first old_fields (fun f -> f.field_name = label) with - | Some f -> Ok f - | None -> - Error - (Errors.field_not_found - ~ty:(Printer.type_to_string ty_record) - ~label ~loc) - in - let update (Field_def { label; expr; is_pun; loc_; _ } : Syntax.field_def) = - let old = lookup_label label.label_name ~loc:loc_ in - match old with - | Error e -> - add_error diagnostics e; - Typedtree.Field_def - { - label; - expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics; - is_mut = false; - is_pun = false; - pos = 0; - } - | Ok old -> - let new_expr = - check_expr env expr (Expect_type old.ty_field) ~control_ctx ~tvar_env - ~cenv ~global_env ~diagnostics - in - Typedtree.Field_def - { label; expr = new_expr; is_mut = old.mut; is_pun; pos = old.pos } - in - let is_dup = - Lst.check_duplicate_opt - (Lst.map new_fields (fun (Field_def { label; _ } : Syntax.field_def) -> - label)) - ~equal:Syntax.equal_label - in - (match is_dup with - | Some { label_name = label; loc_ = loc } -> - add_error diagnostics - (Errors.duplicate_record_field ~context:`Creation ~label ~loc) - | None -> ()); - Lst.map new_fields update + = + (let lookup_label (label : string) ~loc = + (match Lst.find_first old_fields (fun f -> f.field_name = label) with + | Some f -> Ok f + | None -> + Error + (Errors.field_not_found + ~ty:(Printer.type_to_string ty_record) + ~label ~loc) + : Typedecl_info.field Local_diagnostics.info) + in + let update (Field_def { label; expr; is_pun; loc_; _ } : Syntax.field_def) = + let old = lookup_label label.label_name ~loc:loc_ in + match old with + | Error e -> + add_error diagnostics e; + Typedtree.Field_def + { + label; + expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics; + is_mut = false; + is_pun = false; + pos = 0; + } + | Ok old -> + let new_expr = + check_expr env expr (Expect_type old.ty_field) ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics + in + Typedtree.Field_def + { label; expr = new_expr; is_mut = old.mut; is_pun; pos = old.pos } + in + let is_dup = + Basic_duplicate_check.check_duplicate_by new_fields (fun x -> + let (Syntax.Field_def { label; _ }) = x in + label.label_name) + in + (match is_dup with + | Some (Field_def { label = { label_name = label; loc_ = loc }; _ }) -> + add_error diagnostics + (Errors.duplicate_record_field ~context:`Creation ~label ~loc) + | None -> ()); + Lst.map new_fields update + : Typedtree.field_def list) and infer_record (env : Local_env.t) (fields : Syntax.field_def list) loc ~(type_name : Typedtree.type_name option) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics : Typedtree.expr = - let handle_error err : Typedtree.expr = - add_error diagnostics err; - let ty = Stype.new_type_var Tvar_error in - let fields = - Lst.map fields (fun (Field_def { label; expr; is_pun; _ }) -> - Typedtree.Field_def - { - label; - expr = - infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics; - is_mut = false; - is_pun; - pos = 0; - }) - in - Texpr_record { type_name; fields; ty; loc_ = loc } - in - if fields = [] then handle_error (Errors.record_type_missing loc) - else - let labels = Lst.map fields (fun (Field_def { label; _ }) -> label) in - match Lst.check_duplicate_opt labels ~equal:Syntax.equal_label with - | Some { label_name = label; loc_ = loc } -> - handle_error - (Errors.duplicate_record_field ~context:`Creation ~label ~loc) - | None -> ( - match Global_env.resolve_record global_env ~labels ~loc with - | Error err -> handle_error err - | Ok (ty_params, ty_record, labels) -> - let ty_record, labels = - Poly_type.instantiate_record - ~ty_record:(`Generic (ty_params, ty_record)) - labels - in - type_guided_record_check fields labels ty_record ~type_name ~env - ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics ~loc) + ~global_env ~diagnostics = + (let handle_error err = + (add_error diagnostics err; + let ty = Stype.new_type_var Tvar_error in + let fields = + Lst.map fields (fun (Field_def { label; expr; is_pun; _ }) -> + Typedtree.Field_def + { + label; + expr = + infer_expr env expr ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics; + is_mut = false; + is_pun; + pos = 0; + }) + in + Texpr_record { type_name; fields; ty; loc_ = loc } + : Typedtree.expr) + in + if fields = [] then handle_error (Errors.record_type_missing loc) + else + let labels = Lst.map fields (fun (Field_def { label; _ }) -> label) in + match + Basic_duplicate_check.check_duplicate_by labels (fun x -> x.label_name) + with + | Some { label_name = label; loc_ = loc } -> + handle_error + (Errors.duplicate_record_field ~context:`Creation ~label ~loc) + | None -> ( + match Global_env.resolve_record global_env ~labels ~loc with + | Error err -> handle_error err + | Ok (ty_params, ty_record, labels) -> + let ty_record, labels = + Poly_type.instantiate_record + ~ty_record:(`Generic (ty_params, ty_record)) + labels + in + type_guided_record_check fields labels ty_record ~type_name ~env + ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics ~loc) + : Typedtree.expr) and infer_function (env : Local_env.t) (params : Syntax.parameters) (params_loc_ : Rloc.t) (body : Syntax.expr) (return_type : (Syntax.typ * Syntax.error_typ) option) - ~(kind_ : Syntax.fn_kind) ~tvar_env ~cenv ~global_env ~has_error - ~diagnostics : Typedtree.fn * Stype.t = - let typed_fn_annotation = - typing_function_annotation params return_type ~tvar_env ~global_env - ~has_error ~diagnostics - in - check_function ~is_impl_method:false env params params_loc_ body - typed_fn_annotation ~kind_ ~is_global:false ~is_in_test:false ~tvar_env - ~cenv ~global_env ~diagnostics + ~(kind_ : Syntax.fn_kind) ~is_async ~tvar_env ~cenv ~global_env ~has_error + ~diagnostics = + (let typed_fn_annotation = + typing_function_annotation params return_type ~tvar_env ~global_env + ~has_error ~is_async ~diagnostics + in + check_function ~is_impl_method:false env params params_loc_ body + typed_fn_annotation ~kind_ ~is_global:false ~is_in_test:false ~tvar_env + ~cenv ~global_env ~diagnostics + : Typedtree.fn * Stype.t) and typing_function_annotation (params : Syntax.parameters) - (return_type : (Syntax.typ * Syntax.error_typ) option) ~(has_error : bool) - ~tvar_env ~global_env ~diagnostics : Toplevel_typer.typed_fn_annotation = - let typing_annotation ann_opt = - match ann_opt with - | Some ann -> - let ty = typing_type ann ~tvar_env ~global_env ~diagnostics in - let stype = Typedtree_util.stype_of_typ ty in - (stype, Some ty) - | None -> (Stype.new_type_var Tvar_normal, None) - in - let ret_sty, err_sty, annotation = - match return_type with - | None -> - ( Stype.new_type_var Tvar_normal, - (if has_error then Some Typeutil.default_err_type else None), - Toplevel_typer.No_error_type_annotated ) - | Some (res_ty, err_ty) -> - let typ = typing_type res_ty ~tvar_env ~global_env ~diagnostics in - let err_sty, err_typ = - match err_ty with - | Error_typ { ty = err_ty } -> - let typ = typing_type ~global_env ~tvar_env err_ty ~diagnostics in - ( Some (Typedtree_util.stype_of_typ typ), - Typedtree.Error_typ { ty = typ } ) - | Default_error_typ { loc_ } -> - (Some Typeutil.default_err_type, Default_error_typ { loc_ }) - | No_error_typ -> - ( (if has_error then Some Typeutil.default_err_type else None), - No_error_typ ) - in - (Typedtree_util.stype_of_typ typ, err_sty, Annotated (typ, err_typ)) - in - { - params_ty = - Lst.map params (fun (p : Syntax.parameter) -> - typing_annotation p.param_annot); - ret_ty = ret_sty; - err_ty = err_sty; - ret_annotation = annotation; - } + (return_type : (Syntax.typ * Syntax.error_typ) option) + ~(has_error : Rloc.t option) ~is_async ~tvar_env ~global_env ~diagnostics = + (let typing_annotation ann_opt = + match ann_opt with + | Some ann -> + let ty = typing_type ann ~tvar_env ~global_env ~diagnostics in + let stype = Typedtree_util.stype_of_typ ty in + (stype, Some ty) + | None -> (Stype.new_type_var Tvar_normal, None) + in + let ({ ret_sty; err_sty; annotation } : Typeutil.ret_info) = + Typeutil.handle_return_annotation return_type ~has_error + ~typing_type:(typing_type ~tvar_env ~global_env ~diagnostics) + in + { + params_ty = + Lst.map params (fun (p : Syntax.parameter) -> + typing_annotation (Syntax.ty_of_param p)); + ret_ty = ret_sty; + err_ty = err_sty; + is_async; + ret_annotation = annotation; + } + : Local_typing_worklist.typed_fn_annotation) and typing_interp ?expect_ty ~control_ctx ~global_env ~diagnostics ~tvar_env ~cenv env elems loc_ = @@ -3097,34 +3526,36 @@ and typing_interp ?expect_ty ~control_ctx ~global_env ~diagnostics ~tvar_env | Interp_lit { str; repr = _ } -> Typedtree.Interp_lit str | Interp_expr { expr; loc_ } -> let expr = infer_go env expr in - let to_string = - typing_self_method - (Typedtree_util.type_of_typed_expr expr) - ({ label_name = "to_string"; loc_ = Rloc.no_location } - : Syntax.label) - ~src:Type_constraint.Dot_src_direct ~loc:loc_ ~global_env - ~tvar_env ~cenv ~diagnostics + let self_type = Typedtree_util.type_of_typed_expr expr in + let to_string : Typedtree.expr = + Texpr_unresolved_method + { + trait_name = + Tname_path + { + name = Type_path.Builtin.trait_show; + kind = Trait; + loc_ = Rloc.no_location; + }; + method_name = "to_string"; + self_type; + arity_ = Some (Fn_arity.simple 1); + ty = + Builtin.type_arrow [ self_type ] Stype.string ~err_ty:None + ~is_async:false; + loc_ = Rloc.no_location; + } in - let self_ty = Typedtree_util.type_of_typed_expr expr in - let actual = Typedtree_util.type_of_typed_expr to_string in - (if - not - (Ctype.try_unify - (Builtin.type_arrow [ self_ty ] Stype.string ~err_ty:None) - actual) - then - let self_ty, actual = Printer.type_pair_to_string self_ty actual in - add_error diagnostics - (Errors.interp_to_string_incorrect_type ~self_ty ~actual - ~loc:loc_)); + Poly_type.add_constraint cenv self_type + { trait = Type_path.Builtin.trait_show; loc_; src_ = Direct }; Interp_expr { expr; to_string; loc_ }) in let ty = match expect_ty with | Some ty when Type.same_type ty Stype.json -> Stype.json | Some expect_ty -> - Ctype.unify_expr ~expect_ty ~actual_ty:Stype.string loc_ - |> store_error ~diagnostics; + unify_expr_and_store_error ~expect_ty ~actual_ty:Stype.string + ~diagnostics loc_; Stype.string | None -> Stype.string in @@ -3132,669 +3563,788 @@ and typing_interp ?expect_ty ~control_ctx ~global_env ~diagnostics ~tvar_env and check_function_params (env : Local_env.t) (params : Syntax.parameters) (param_types : (Stype.t * Typedtree.typ option) list) ~(is_global : bool) - ~tvar_env ~cenv ~global_env ~diagnostics : Local_env.t * Typedtree.params = - let env = ref env in - let params = - Lst.map2 params param_types (fun (p : Syntax.parameter) (stype, ty) -> - if (not is_global) && p.param_kind <> Positional then - add_error diagnostics - (Errors.no_local_labelled_function p.param_binder.loc_); - let kind : Typedtree.param_kind = - match p.param_kind with - | Positional -> Positional - | Labelled -> Labelled - | Optional { default = Pexpr_hole { kind = Incomplete; loc_ } } -> - if - Type.same_type stype Stype.type_sourceloc - || Type.same_type stype Stype.type_argsloc - then Autofill - else ( - add_error diagnostics - (Errors.unsupported_autofill - ~ty:(Printer.type_to_string stype) - ~loc:p.param_binder.loc_); - Optional (Texpr_hole { loc_; ty = stype; kind = Incomplete })) - | Optional { default } -> - Optional - (check_expr !env default (Expect_type stype) ~global_env - ~tvar_env ~cenv ~diagnostics ~control_ctx:Control_ctx.empty) - | Question_optional -> Question_optional - in - let param_ty = - match kind with - | Question_optional -> Builtin.type_option stype - | Positional | Labelled | Optional _ | Autofill -> stype - in - let binder = Typeutil.fresh_binder p.param_binder in - env := Typeutil.add_binder !env binder ~typ:param_ty ~mut:false; - Typedtree.Param { binder; ty = param_ty; konstraint = ty; kind }) - in - (!env, params) + ~tvar_env ~cenv ~global_env ~diagnostics = + (let env = ref env in + let params = + Lst.map2 params param_types (fun (p : Syntax.parameter) -> + fun (stype, ty) -> + if + (not is_global) + && + match p with + | Discard_positional _ | Positional _ -> false + | Labelled _ | Optional _ | Question_optional _ -> true + then + add_error diagnostics + (Errors.no_local_labelled_function (Syntax.loc_of_param_binder p)); + let kind : Typedtree.param_kind = + match p with + | Discard_positional _ | Positional _ -> Positional + | Labelled _ -> Labelled + | Optional { default = Pexpr_hole { kind = Incomplete; loc_ }; _ } + -> + if + Type.same_type stype Stype.type_sourceloc + || Type.same_type stype Stype.type_argsloc + then Autofill + else ( + add_error diagnostics + (Errors.unsupported_autofill + ~ty:(Printer.type_to_string stype) + ~loc:(Syntax.loc_of_param_binder p)); + Optional (Texpr_hole { loc_; ty = stype; kind = Incomplete })) + | Optional { default; _ } -> + Optional + (check_expr !env default (Expect_type stype) ~global_env + ~tvar_env ~cenv ~diagnostics ~control_ctx:Control_ctx.empty) + | Question_optional _ -> Question_optional + in + let param_ty = + match kind with + | Question_optional -> Builtin.type_option stype + | Positional | Labelled | Optional _ | Autofill -> stype + in + match p with + | Discard_positional _ -> + Typedtree.Discard_positional_param + { + ty = param_ty; + konstraint = ty; + loc_ = Syntax.loc_of_param_binder p; + } + | Positional { binder; _ } + | Labelled { binder; _ } + | Optional { binder; _ } + | Question_optional { binder; _ } -> + let binder = Typeutil.fresh_binder binder in + env := Typeutil.add_binder !env binder ~typ:param_ty ~mut:false; + Typedtree.Param { binder; ty = param_ty; konstraint = ty; kind }) + in + (!env, params) + : Local_env.t * Typedtree.params) and check_function (env : Local_env.t) (params : Syntax.parameters) (params_loc_ : Rloc.t) (body : Syntax.expr) - (typed_fn_annotation : Toplevel_typer.typed_fn_annotation) + (typed_fn_annotation : Local_typing_worklist.typed_fn_annotation) ~(kind_ : Syntax.fn_kind) ~(is_global : bool) ~tvar_env ~cenv ~global_env - ~is_in_test ~is_impl_method ~diagnostics : Typedtree.fn * Stype.t = - let ({ - params_ty = param_types; - ret_ty = return_type; - err_ty = error_type; - ret_annotation = annotation; - } - : Toplevel_typer.typed_fn_annotation) = - typed_fn_annotation - in - let env, params = - check_function_params env params param_types ~is_global ~tvar_env ~cenv - ~global_env ~diagnostics - in - let error_ctx = - match error_type with - | None -> None - | Some t -> - let ctx : Control_ctx.error_ctx = - match Stype.type_repr t with - | T_constr { type_constructor = Basic_type_path.T_error; _ } -> - Fixed_ctx Supererror - | T_constr { type_constructor = p; is_suberror_ = true; _ } -> - Fixed_ctx (Suberror p) - | Tparam { index; name_ } -> Fixed_ctx (Tparam { index; name_ }) - | _ -> Open_ctx Empty_ctx - in - Some (ref ctx) - in - let control_ctx = Control_ctx.make_fn ~return:return_type ~error_ctx in - let body = - check_expr env body (Expect_type return_type) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - (if (not !(control_ctx.has_error)) && (not is_in_test) && not is_impl_method - then + ~is_in_test ~is_impl_method ~diagnostics = + (let ({ + params_ty = param_types; + ret_ty = return_type; + err_ty = error_type; + is_async; + ret_annotation = annotation; + } + : Local_typing_worklist.typed_fn_annotation) = + typed_fn_annotation + in + let env, params = + check_function_params env params param_types ~is_global ~tvar_env ~cenv + ~global_env ~diagnostics + in + let error_ctx = + match error_type with + | None -> None + | Some t -> + let ctx : Control_ctx.error_ctx = + match Stype.type_repr t with + | T_constr { type_constructor = Basic_type_path.T_error; _ } -> + Fixed_ctx Supererror + | T_constr { type_constructor = p; is_suberror_ = true; _ } -> + Fixed_ctx (Suberror p) + | Tparam { index; name_ } -> Fixed_ctx (Tparam { index; name_ }) + | _ -> Open_ctx Empty_ctx + in + Some (ref ctx) + in + let control_ctx = + Control_ctx.make_fn ~return:return_type ~error_ctx ~is_async + in + let body = + check_expr env body (Expect_type return_type) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + if + (not !(control_ctx.may_has_error)) + && (not is_in_test) && not is_impl_method + then Typeutil.report_unused_error_annotation annotation diagnostics; + let ret_constraint = match annotation with - | Annotated (_, Error_typ { ty }) -> - let loc = Typedtree.loc_of_typ ty in - Local_diagnostics.add_warning diagnostics - { kind = Useless_error_type; loc } - | Annotated (_, Default_error_typ { loc_ = loc }) | Has_error_type loc -> - Local_diagnostics.add_warning diagnostics - { kind = Useless_error_type; loc } - | Annotated (_, No_error_typ) | No_error_type_annotated -> ()); - let ret_constraint = - match annotation with - | Annotated r -> Some r - | No_error_type_annotated | Has_error_type _ -> None - in - let func_typ = - Builtin.type_arrow (Lst.map param_types fst) return_type ~err_ty:error_type - in - ({ params; params_loc_; body; ty = func_typ; ret_constraint; kind_ }, func_typ) - -and deref_newtype ~(global_env : Global_env.t) (expr : Typedtree.expr) ~loc : - Typedtree.expr = - let ty = Stype.type_repr (Typedtree_util.type_of_typed_expr expr) in - match ty with - | T_constr { type_constructor = p; _ } -> ( - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = New_type { newtype_constr; _ }; _ } -> ( - match[@warning "-fragile-match"] - Poly_type.instantiate_constr newtype_constr - with - | ty_res, ty_arg :: [] -> - Ctype.unify_exn ty ty_res; - Texpr_field - { - record = expr; - accessor = Newtype; - ty = ty_arg; - pos = 0; - loc_ = loc; - } - | _ -> assert false) - | _ -> expr) - | _ -> expr + | Annotated r -> Some r + | Has_super_error _ | No_annotation -> None + in + let func_typ = + Builtin.type_arrow (Lst.map param_types fst) return_type ~err_ty:error_type + ~is_async + in + ( { params; params_loc_; body; ty = func_typ; ret_constraint; kind_ }, + func_typ ) + : Typedtree.fn * Stype.t) -and resolve_field ~(global_env : Global_env.t) (record : Typedtree.expr) - (label : Syntax.label) ~(may_be_method : unit -> bool) - ~(src_ty_record : Stype.t) ~(loc : Rloc.t) - ~(diagnostics : Local_diagnostics.t) : - Stype.t * int * bool * Typedecl_info.type_component_visibility = - let name = label.label_name in - let ty_record = Stype.type_repr (Typedtree_util.type_of_typed_expr record) in - let error () = - match Global_env.try_pick_field global_env name with - | Some ({ pos; mut; vis; _ } as field_desc) -> - let _, ty_field = Poly_type.instantiate_field field_desc in - (ty_field, pos, mut, vis) - | None -> - (Stype.new_type_var Tvar_error, Typeutil.unknown_pos, true, Read_write) - [@@inline] - in - let not_a_record () = - let kind = - match src_ty_record with - | Tvar _ -> "unknown" - | Tarrow _ -> "function" - | Tparam _ -> "type parameter" - | T_trait _ -> "trait" - | T_builtin _ -> Printer.type_to_string ty_record - | T_constr { type_constructor = p; _ } -> ( - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = Record_type _; _ } -> assert false - | Some { ty_desc = Variant_type _ | ErrorEnum_type _; _ } -> "variant" - | Some { ty_desc = New_type _; _ } -> "new type" - | Some { ty_desc = Error_type _; _ } -> "error type" - | Some { ty_desc = Extern_type | Abstract_type; _ } -> "abstract" - | None -> Type_path_util.name p) - | T_blackhole -> assert false - in - let ty = Printer.type_to_string src_ty_record in - let may_be_method = if may_be_method () then Some name else None in - add_error diagnostics (Errors.not_a_record ~ty ~may_be_method ~kind ~loc); - error () - [@@inline] - in - match ty_record with - | T_constr { type_constructor = p; _ } -> ( - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = Record_type { fields }; _ } -> ( - match Lst.find_first fields (fun f -> f.field_name = name) with - | Some field_info -> - let ty_record', ty_field = - Poly_type.instantiate_field field_info - in - Ctype.unify_exn ty_record ty_record'; - (ty_field, field_info.pos, field_info.mut, field_info.vis) - | _ -> - let ty = Printer.type_to_string src_ty_record in - let may_be_method = may_be_method () in - add_error diagnostics - (Errors.no_such_field ~ty ~field:name ~may_be_method ~loc); - error ()) - | Some { ty_desc = Variant_type constrs | ErrorEnum_type constrs; _ } -> ( - match record with - | Texpr_ident { kind = Value_constr tag; _ } -> ( - let constr = - Lst.find_first constrs (fun constr -> - Constr_info.equal constr.cs_tag tag) - in - match constr with - | None -> not_a_record () - | Some ({ constr_name; _ } as constr_info) -> ( - let ty_res, ty_args = - Poly_type.instantiate_constr constr_info - in - Ctype.unify_exn ty_res ty_record; - match - Fn_arity.find_constr_label constr_info.cs_arity_ ty_args - ~label:label.label_name - with - | None -> - add_error diagnostics - (Errors.constr_no_such_field ~ty:p ~constr:constr_name - ~field:label.label_name ~loc); - error () - | Some (ty, offset, mut) -> - (ty, offset, mut, constr_info.cs_vis))) - | _ -> not_a_record ()) - | _ -> not_a_record ()) - | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> error () - | _ -> not_a_record () - -and typing_mutate (env : Local_env.t) (record : Syntax.expr) - (label : Syntax.label) (field : Syntax.expr) - (augmented_by : Syntax.var option) loc ~control_ctx ~tvar_env ~cenv - ~global_env ~(diagnostics : _) : Typedtree.expr = - let name = label.label_name in - let record = - infer_expr env record ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let ty_record = Stype.type_repr (Typedtree_util.type_of_typed_expr record) in - let record = - let loc = Rloc.merge (Typedtree.loc_of_typed_expr record) label.loc_ in - deref_newtype ~global_env record ~loc - in - let ty_field, pos, is_mut, vis = - resolve_field ~global_env record label - ~may_be_method:(fun () -> false) - ~src_ty_record:ty_record ~diagnostics ~loc - in - (if not is_mut then - let error = Errors.immutable_field ~label:name ~loc in - add_error diagnostics error); - (if Stype.is_external ty_record && vis <> Read_write then - let error = Errors.mutate_readonly_field ~label:name ~loc in - add_error diagnostics error); - match augmented_by with - | None -> - let field = - check_expr env field (Expect_type ty_field) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - Texpr_mutate - { - record; - label; - field; - augmented_by = None; - ty = Stype.unit; - pos; - loc_ = loc; - } - | Some op -> - let lhs : Typedtree.expr = - Texpr_field - { - record; - accessor = Label label; - ty = ty_field; - pos; - loc_ = Typedtree.loc_of_typed_expr record; - } - in - let infix_expr = - typing_infix_op env op lhs field ~loc ~global_env ~cenv ~tvar_env - ~control_ctx ~diagnostics - in - let op_expr, field = - match infix_expr with - | Texpr_apply { func; args = [ _; { arg_value; _ } ]; ty; _ } -> - Ctype.unify_expr ~expect_ty:ty_field ~actual_ty:ty loc - |> store_error ~diagnostics; - (func, arg_value) - | _ -> assert false - in - Texpr_mutate - { - record; - label; - field; - augmented_by = Some op_expr; - ty = Stype.unit; - pos; - loc_ = loc; - } +and deref_newtype ~(global_env : Global_env.t) (expr : Typedtree.expr) ~loc = + (let ty = Stype.type_repr (Typedtree_util.type_of_typed_expr expr) in + match ty with + | T_constr { type_constructor = p; _ } -> ( + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = New_type { newtype_constr; _ }; _ } -> ( + match[@warning "-fragile-match"] + Poly_type.instantiate_constr newtype_constr + with + | ty_res, ty_arg :: [] -> + Ctype.unify_exn ty ty_res; + Texpr_field + { + record = expr; + accessor = Newtype; + ty = ty_arg; + pos = 0; + loc_ = loc; + } + | _ -> assert false) + | _ -> expr) + | _ -> expr + : Typedtree.expr) + +and resolve_field ~(global_env : Global_env.t) (record : Typedtree.expr) + (label : Syntax.label) ~(may_be_method : unit -> bool) + ~(src_ty_record : Stype.t) ~(loc : Rloc.t) + ~(diagnostics : Local_diagnostics.t) = + (let name = label.label_name in + let ty_record = Stype.type_repr (Typedtree_util.type_of_typed_expr record) in + let error () = + match Global_env.try_pick_field global_env name with + | Some ({ pos; mut; vis; _ } as field_desc) -> + let _, ty_field = Poly_type.instantiate_field field_desc in + (ty_field, pos, mut, vis) + | None -> + (Stype.new_type_var Tvar_error, Typeutil.unknown_pos, true, Read_write) + [@@inline] + in + let not_a_record () = + let kind = + match src_ty_record with + | Tvar _ -> "unknown" + | Tarrow _ -> "function" + | Tparam _ -> "type parameter" + | T_trait _ -> "trait" + | T_builtin _ -> Printer.type_to_string ty_record + | T_constr { type_constructor = p; _ } -> ( + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = Record_type _; _ } -> assert false + | Some { ty_desc = Variant_type _ | ErrorEnum_type _; _ } -> + "variant" + | Some { ty_desc = New_type _; _ } -> "new type" + | Some { ty_desc = Error_type _; _ } -> "error type" + | Some { ty_desc = Extern_type | Abstract_type; _ } -> "abstract" + | None -> Type_path_util.name p) + | T_blackhole -> assert false + in + let ty = Printer.type_to_string src_ty_record in + let may_be_method = if may_be_method () then Some name else None in + add_error diagnostics (Errors.not_a_record ~ty ~may_be_method ~kind ~loc); + error () + [@@inline] + in + let handle_struct_fields (fields : Typedecl_info.fields) = + match Lst.find_first fields (fun f -> f.field_name = name) with + | Some field_info -> + let ty_record', ty_field = Poly_type.instantiate_field field_info in + Ctype.unify_exn ty_record ty_record'; + (ty_field, field_info.pos, field_info.mut, field_info.vis) + | _ -> + let ty = Printer.type_to_string src_ty_record in + let may_be_method = may_be_method () in + add_error diagnostics + (Errors.no_such_field ~ty ~field:name ~may_be_method ~loc); + error () + [@@inline] + in + let handle_enum_fields (constrs : Typedecl_info.constructors) + (p : Type_path.t) = + match record with + | Texpr_ident { kind = Value_constr tag; _ } -> ( + let constr = + Lst.find_first constrs (fun constr -> + Constr_info.equal constr.cs_tag tag) + in + match constr with + | None -> not_a_record () + | Some ({ constr_name; _ } as constr_info) -> ( + let ty_res, ty_args = Poly_type.instantiate_constr constr_info in + Ctype.unify_exn ty_res ty_record; + match + Fn_arity.find_constr_label constr_info.cs_arity_ ty_args + ~label:label.label_name + with + | None -> + add_error diagnostics + (Errors.constr_no_such_field ~ty:p ~constr:constr_name + ~field:label.label_name ~loc); + error () + | Some (ty, offset, mut) -> (ty, offset, mut, constr_info.cs_vis))) + | _ -> not_a_record () + [@@inline] + in + match ty_record with + | T_constr { type_constructor = T_local { name; _ } as p; _ } -> ( + match[@warning "-fragile-match"] + Global_env.get_cur_local_type_env global_env + with + | Some local_type_env -> ( + match Local_type.find_type local_type_env name with + | Some { kind = Struct fields; _ } -> handle_struct_fields fields + | Some { kind = Enum constrs; _ } -> handle_enum_fields constrs p + | Some { kind = Newtype _; _ } -> not_a_record () + | Some { kind = Placeholder; _ } | None -> assert false) + | _ -> assert false) + | T_constr { type_constructor = p; _ } -> ( + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = Record_type { fields }; _ } -> + handle_struct_fields fields + | Some { ty_desc = Variant_type constrs | ErrorEnum_type constrs; _ } -> + handle_enum_fields constrs p + | _ -> not_a_record ()) + | Tvar { contents = Tnolink Tvar_error } | T_blackhole -> error () + | _ -> not_a_record () + : Stype.t * int * bool * Typedecl_info.type_component_visibility) + +and typing_mutate (env : Local_env.t) (record : Syntax.expr) + (label : Syntax.label) (field : Syntax.expr) + (augmented_by : Syntax.var option) loc ~control_ctx ~tvar_env ~cenv + ~global_env ~(diagnostics : _) = + (let name = label.label_name in + let record = + infer_expr env record ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let ty_record = Stype.type_repr (Typedtree_util.type_of_typed_expr record) in + let record = + let loc = Rloc.merge (Typedtree.loc_of_typed_expr record) label.loc_ in + deref_newtype ~global_env record ~loc + in + let ty_field, pos, is_mut, vis = + resolve_field ~global_env record label + ~may_be_method:(fun () -> false) + ~src_ty_record:ty_record ~diagnostics ~loc + in + (if not is_mut then + let error = Errors.immutable_field ~label:name ~loc in + add_error diagnostics error); + (if Stype.is_external ty_record && vis <> Read_write then + let error = Errors.mutate_readonly_field ~label:name ~loc in + add_error diagnostics error); + match augmented_by with + | None -> + let field = + check_expr env field (Expect_type ty_field) ~control_ctx ~tvar_env + ~cenv ~global_env ~diagnostics + in + Texpr_mutate + { + record; + label; + field; + augmented_by = None; + ty = Stype.unit; + pos; + loc_ = loc; + } + | Some op -> + let lhs : Typedtree.expr = + Texpr_field + { + record; + accessor = Label label; + ty = ty_field; + pos; + loc_ = Typedtree.loc_of_typed_expr record; + } + in + let infix_expr = + typing_infix_op env op lhs field ~loc ~global_env ~cenv ~tvar_env + ~control_ctx ~diagnostics + in + let op_expr, field = + match infix_expr with + | Texpr_apply { func; args = [ _; { arg_value; _ } ]; ty; _ } -> + unify_expr_and_store_error ~expect_ty:ty_field ~actual_ty:ty + ~diagnostics loc; + (func, arg_value) + | _ -> assert false + in + Texpr_mutate + { + record; + label; + field; + augmented_by = Some op_expr; + ty = Stype.unit; + pos; + loc_ = loc; + } + : Typedtree.expr) and typing_letrec (env : Local_env.t) (funs : (Syntax.binder * Syntax.func) list) ~(tvar_env : Tvar_env.t) ~cenv - ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) : - Local_env.t * (Typedtree.binder * Typedtree.fn) list = - let func_types = - Lst.map funs (fun (f, func) -> - match func with - | Lambda { parameters; body = _; return_type; has_error } -> - let typed_fn_annotation = - typing_function_annotation parameters return_type ~has_error - ~tvar_env ~global_env ~diagnostics - in - (Typeutil.fresh_binder f, typed_fn_annotation) - | Match _ -> assert false) - in - let env_with_funs = - Lst.fold_left func_types env (fun env (binder, typed_fn_ann) -> - let typ = - Builtin.type_arrow - (Lst.map typed_fn_ann.params_ty fst) - typed_fn_ann.ret_ty ~err_ty:typed_fn_ann.err_ty - in - Typeutil.add_binder env binder ~typ ~mut:false) - in - let tfuns = - Lst.map2 funs func_types (fun (_, func) (binder, typed_fn_annotation) -> - match func with - | Lambda - { - parameters = ps; - params_loc_; - body = funbody; - return_type = _; - kind_; - has_error = _; - } -> - let tfun, _ = - check_function ~is_impl_method:false env_with_funs ps params_loc_ - funbody typed_fn_annotation ~kind_ ~is_global:false - ~is_in_test:false ~tvar_env ~cenv ~global_env ~diagnostics - in - (binder, tfun) - | Match _ -> assert false) - in - (env_with_funs, tfuns) + ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) = + (let func_types = + Lst.map funs (fun (f, func) -> + match func with + | Lambda { parameters; body = _; return_type; has_error; is_async } -> + let typed_fn_annotation = + typing_function_annotation parameters return_type ~has_error + ~is_async ~tvar_env ~global_env ~diagnostics + in + (Typeutil.fresh_binder f, typed_fn_annotation) + | Match _ -> assert false) + in + let env_with_funs = + Lst.fold_left func_types env (fun env -> + fun (binder, typed_fn_ann) -> + let typ = + Builtin.type_arrow + (Lst.map typed_fn_ann.params_ty fst) + typed_fn_ann.ret_ty ~err_ty:typed_fn_ann.err_ty + ~is_async:typed_fn_ann.is_async + in + Typeutil.add_binder env binder ~typ ~mut:false) + in + let tfuns = + Lst.map2 funs func_types (fun (_, func) -> + fun (binder, typed_fn_annotation) -> + match func with + | Lambda + { + parameters = ps; + params_loc_; + body = funbody; + return_type = _; + kind_; + has_error = _; + is_async = _; + } -> + let tfun, _ = + check_function ~is_impl_method:false env_with_funs ps + params_loc_ funbody typed_fn_annotation ~kind_ + ~is_global:false ~is_in_test:false ~tvar_env ~cenv ~global_env + ~diagnostics + in + (binder, tfun) + | Match _ -> assert false) + in + (env_with_funs, tfuns) + : Local_env.t * (Typedtree.binder * Typedtree.fn) list) and typing_let (env : Local_env.t) (p : Syntax.pattern) (e : Syntax.expr) ~control_ctx ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) - ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) : - Typedtree.pat_binders * Typedtree.pat * Typedtree.expr = - match (p, e) with - | (Ppat_constraint { ty = ty_expr; _ } as pc), _ -> - let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in - let stype = Typedtree_util.stype_of_typ ty in - let te = - check_expr env e (Expect_type stype) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics - in - let pat_binders, tpat = - Pattern_typer.check_pat pc stype ~tvar_env ~cenv ~global_env - ~diagnostics - in - (pat_binders, tpat, te) - | _ -> - let te = - infer_expr env e ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - let ty = Typedtree_util.type_of_typed_expr te in - let pat_binders, tpat = - Pattern_typer.check_pat p ty ~tvar_env ~cenv ~global_env ~diagnostics - in - (pat_binders, tpat, te) + ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) = + (match (p, e) with + | (Ppat_constraint { ty = ty_expr; _ } as pc), _ -> + let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in + let stype = Typedtree_util.stype_of_typ ty in + let te = + check_expr env e (Expect_type stype) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics + in + let pat_binders, tpat = + Pattern_typer.check_pat pc stype ~tvar_env ~cenv ~global_env + ~diagnostics + in + (pat_binders, tpat, te) + | _ -> + let te = + infer_expr env e ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics + in + let ty = Typedtree_util.type_of_typed_expr te in + let pat_binders, tpat = + Pattern_typer.check_pat p ty ~tvar_env ~cenv ~global_env ~diagnostics + in + (pat_binders, tpat, te) + : Typedtree.pat_binders * Typedtree.pat * Typedtree.expr) and typing_letmut (env : Local_env.t) (binder : Syntax.binder) (ty : Syntax.typ option) (e : Syntax.expr) ~control_ctx ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : - Local_env.t * Typedtree.binder * Typedtree.expr * Typedtree.typ option = - let binder = Typeutil.fresh_binder binder in - let var_ty, expr, konstraint = - match ty with - | Some ty_expr -> - let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in - let stype = Typedtree_util.stype_of_typ ty in - ( stype, - check_expr env e (Expect_type stype) ~control_ctx ~tvar_env ~cenv - ~global_env ~diagnostics, - Some ty ) - | None -> - let expr = - infer_expr env e ~control_ctx ~tvar_env ~cenv ~global_env ~diagnostics - in - (Typedtree_util.type_of_typed_expr expr, expr, None) - in - let env = Typeutil.add_binder env binder ~typ:var_ty ~mut:true in - (env, binder, expr, konstraint) + ~(diagnostics : Local_diagnostics.t) = + (let binder = Typeutil.fresh_binder binder in + let var_ty, expr, konstraint = + match ty with + | Some ty_expr -> + let ty = typing_type ty_expr ~tvar_env ~global_env ~diagnostics in + let stype = Typedtree_util.stype_of_typ ty in + ( stype, + check_expr env e (Expect_type stype) ~control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics, + Some ty ) + | None -> + let expr = + infer_expr env e ~control_ctx ~tvar_env ~cenv ~global_env + ~diagnostics + in + (Typedtree_util.type_of_typed_expr expr, expr, None) + in + let env = Typeutil.add_binder env binder ~typ:var_ty ~mut:true in + (env, binder, expr, konstraint) + : Local_env.t * Typedtree.binder * Typedtree.expr * Typedtree.typ option) and check_loop (env : Local_env.t) (args : Syntax.expr list) - (body : (Syntax.pattern list * Syntax.expr) list) ~(expect_ty : expect_ty) + (body : Syntax.multi_arg_case list) ~label ~(expect_ty : expect_ty) ~loop_loc_ ~loc ~control_ctx ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) - ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) : - Typedtree.expr = - let targs, params = - Lst.map_split args (fun arg -> - let targ = - infer_expr ~global_env ~tvar_env ~cenv ~diagnostics ~control_ctx env - arg - in - let param : Typedtree.param = - Param - { - binder = - { binder_id = Ident.fresh "*param"; loc_ = Rloc.no_location }; - konstraint = None; - ty = Typedtree_util.type_of_typed_expr targ; - kind = Positional; - } - in - (targ, param)) - in - let tys = List.map Typedtree_util.type_of_typed_expr targs in - let ty_tuple = Builtin.type_product tys in - let n = List.length tys in - let control_ctx = - Control_ctx.with_loop control_ctx ~arg_typs:tys - ~result_typ:(get_expected_type expect_ty) - in - let cases = - Lst.map body (fun (pats, action) : Typedtree.match_case -> - let actual = List.length pats in - let ty_pat = - if n = actual then ty_tuple - else - let loc = - Rloc.merge - (Syntax.loc_of_pattern (List.hd pats)) - (Syntax.loc_of_pattern (Lst.last pats)) - in - let () = + ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) = + (let targs, targ_tys, params, params_expr, targs_ty = + let make_param_expr targ_ty = + let param_id = Ident.fresh "*param" in + let loc_ = Rloc.no_location in + let binder : Typedtree.binder = { binder_id = param_id; loc_ } in + let param : Typedtree.param = + Param { binder; konstraint = None; ty = targ_ty; kind = Positional } + in + let id : Typedtree.var = { var_id = param_id; loc_ } in + let param_expr : Typedtree.expr = + Texpr_ident + { + id; + ty_args_ = [||]; + arity_ = None; + kind = Normal; + ty = targ_ty; + loc_; + } + in + (param, param_expr) + [@@inline] + in + match args with + | [] -> assert false + | arg :: [] -> + let targ = + infer_expr ~global_env ~tvar_env ~cenv ~diagnostics ~control_ctx env + arg + in + let targ_ty = Typedtree_util.type_of_typed_expr targ in + let param, param_expr = make_param_expr targ_ty in + ([ targ ], [ targ_ty ], [ param ], param_expr, targ_ty) + | args -> + let rec go args = + match args with + | [] -> ([], [], [], []) + | arg :: rest -> + let targ = + infer_expr ~global_env ~tvar_env ~cenv ~diagnostics + ~control_ctx env arg + in + let targ_ty = Typedtree_util.type_of_typed_expr targ in + let param, param_expr = make_param_expr targ_ty in + let targs, params, targ_tys, param_exprs = go rest in + ( targ :: targs, + param :: params, + targ_ty :: targ_tys, + param_expr :: param_exprs ) + in + let targs, params, targ_tys, param_exprs = go args in + let ty_tuple = Builtin.type_product targ_tys in + let params_expr : Typedtree.expr = + let loc_ = + Rloc.merge + (Syntax.loc_of_expression (List.hd args)) + (Syntax.loc_of_expression (Lst.last args)) + in + Texpr_tuple { exprs = param_exprs; ty = ty_tuple; loc_ } + in + (targs, targ_tys, params, params_expr, ty_tuple) + in + let label : Typedtree.loop_label_binder option = + match label with + | None -> None + | Some label -> + Some { label = Label.fresh label.label_name; loc_ = label.loc_ } + in + let control_ctx = + Control_ctx.with_loop control_ctx ~arg_typs:targ_tys ~label + ~result_typ:(get_expected_type expect_ty) + ~diagnostics + in + let cases = + Lst.map body (fun { patterns = pats; guard; body = action } -> + (let ty_pat = + if Lst.same_length targs pats then targs_ty + else + let loc = + Rloc.merge + (Syntax.loc_of_pattern (List.hd pats)) + (Syntax.loc_of_pattern (Lst.last pats)) + in + let expected = List.length args in + let actual = List.length pats in add_error diagnostics - (Errors.loop_pat_arity_mismatch ~expected:n ~actual ~loc) - in - Builtin.type_product - (if n < actual then - tys @ Type.type_var_list (actual - n) Tvar_error - else Lst.take actual tys) - in - let tuple_pat : Syntax.pattern = - Ppat_tuple { pats; loc_ = Rloc.no_location } - in - let pat_binders, tpat = - Pattern_typer.check_pat tuple_pat ty_pat ~tvar_env ~cenv ~global_env - ~diagnostics - in - let taction = - check_expr ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - (Typeutil.add_pat_binders env pat_binders) - action expect_ty - in - { pat = tpat; pat_binders; action = taction }) - in - if not !(control_ctx.has_continue) then - Local_diagnostics.add_warning diagnostics { kind = Useless_loop; loc }; - let tuple_expr : Typedtree.expr = - let loc_ = - Rloc.merge - (Syntax.loc_of_expression (List.hd args)) - (Syntax.loc_of_expression (Lst.last args)) - in - let exprs = - Lst.map params (fun p -> - match p with - | Typedtree.Param { binder; konstraint = _; ty; kind = _ } -> - Typedtree.Texpr_ident - { - id = { var_id = binder.binder_id; loc_ = binder.loc_ }; - ty_args_ = [||]; - arity_ = None; - kind = Normal; - ty; - loc_ = Rloc.no_location; - }) - in - Texpr_tuple { exprs; ty = ty_tuple; loc_ } - in - let ty = - match cases with - | { action; _ } :: _ -> Typedtree_util.type_of_typed_expr action - | [] -> get_expected_type expect_ty - in - let body : Typedtree.expr = - Texpr_match - { expr = tuple_expr; cases; ty; match_loc_ = loop_loc_; loc_ = loc } - in - Texpr_loop { params; body; args = targs; ty; loc_ = loc } + (Errors.loop_pat_arity_mismatch ~expected ~actual ~loc); + let tys = + if expected < actual then + targ_tys @ Type.type_var_list (actual - expected) Tvar_error + else Lst.take targ_tys actual + in + match tys with ty :: [] -> ty | tys -> Builtin.type_product tys + in + let pat : Syntax.pattern = + match pats with + | p :: [] -> p + | pats -> Ppat_tuple { pats; loc_ = Rloc.no_location } + in + let pat_binders, tpat = + Pattern_typer.check_pat pat ty_pat ~tvar_env ~cenv ~global_env + ~diagnostics + in + let env1 = Typeutil.add_pat_binders env pat_binders in + let guard, env2 = + match guard with + | None -> (None, env1) + | Some guard -> + let guard = + check_expr env1 guard (Expect_type Stype.bool) ~control_ctx + ~tvar_env ~cenv ~global_env ~diagnostics + in + ( Some guard, + Typeutil.add_pat_binders env1 + (Typedtree_util.pat_binders_of_cond guard) ) + in + let taction = + check_expr ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + env2 action expect_ty + in + { pat = tpat; pat_binders; action = taction; guard } + : Typedtree.match_case)) + in + if not (Control_ctx.loop_has_continue control_ctx) then + Local_diagnostics.add_warning diagnostics + { kind = Useless_loop; loc = loop_loc_ }; + let ty = + match cases with + | { action; _ } :: _ -> Typedtree_util.type_of_typed_expr action + | [] -> get_expected_type expect_ty + in + let body : Typedtree.expr = + Texpr_match + { expr = params_expr; cases; ty; match_loc_ = loop_loc_; loc_ = loc } + in + Control_ctx.warn_if_label_unused label control_ctx ~diagnostics; + Texpr_loop { params; body; args = targs; ty; loc_ = loc; label } + : Typedtree.expr) and check_while (env : Local_env.t) (cond : Syntax.expr) (body : Syntax.expr) - (while_else : Syntax.expr option) ~(expect_ty : expect_ty) ~loc ~control_ctx - ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let typed_cond = - check_expr ~global_env ~tvar_env ~cenv ~diagnostics - ~control_ctx:(Control_ctx.with_ambiguous_position control_ctx) - env cond (Expect_type Stype.bool) - in - let new_control_ctx = - match while_else with - | Some _ -> - Control_ctx.with_while - ~break_typ:(Some (get_expected_type expect_ty)) - control_ctx - | None -> Control_ctx.with_while ~break_typ:None control_ctx - in - let typed_body = - check_expr ~global_env ~tvar_env ~cenv ~diagnostics - ~control_ctx:new_control_ctx env body Ignored - in - let typed_while_else = - match while_else with - | None -> - (match expect_ty with - | Expect_type expect_ty when not (Ctype.try_unify expect_ty Stype.unit) - -> - add_error diagnostics - (Errors.need_else_branch ~loop_kind:`While ~loc - ~ty:(Printer.type_to_string expect_ty)) - | Ignored | Expect_type _ -> ()); - None - | Some while_else -> - Some - (check_expr ~global_env ~tvar_env ~cenv ~diagnostics ~control_ctx env - while_else expect_ty) - in - Texpr_while - { - loop_cond = typed_cond; - loop_body = typed_body; - ty = - (match typed_while_else with - | Some expr -> Typedtree_util.type_of_typed_expr expr - | None -> Stype.unit); - while_else = typed_while_else; - loc_ = loc; - } + (while_else : Syntax.expr option) ~(label : Syntax.label option) + ~(expect_ty : expect_ty) ~loc ~control_ctx ~(tvar_env : Tvar_env.t) + ~(cenv : Poly_type.t) ~(global_env : Global_env.t) + ~(diagnostics : Local_diagnostics.t) = + (let typed_cond = + check_expr ~global_env ~tvar_env ~cenv ~diagnostics + ~control_ctx:(Control_ctx.with_ambiguous_position control_ctx) + env cond expect_bool + in + let label : Typedtree.loop_label_binder option = + match label with + | None -> None + | Some label -> + Some { label = Label.fresh label.label_name; loc_ = label.loc_ } + in + let new_control_ctx = + match while_else with + | Some _ -> + Control_ctx.with_while + ~break_typ:(Some (get_expected_type expect_ty)) + control_ctx ~label ~diagnostics + | None -> + Control_ctx.with_while ~break_typ:None control_ctx ~label ~diagnostics + in + let pat_binders = Typedtree_util.pat_binders_of_cond typed_cond in + let typed_body = + check_expr ~global_env ~tvar_env ~cenv ~diagnostics + ~control_ctx:new_control_ctx + (Typeutil.add_pat_binders env pat_binders) + body Ignored + in + let typed_while_else = + match while_else with + | None -> + (match expect_ty with + | Expect_type expect_ty when not (Ctype.try_unify expect_ty Stype.unit) + -> + add_error diagnostics + (Errors.need_else_branch ~loop_kind:`While ~loc + ~ty:(Printer.type_to_string expect_ty)) + | Ignored | Expect_type _ -> ()); + None + | Some while_else -> + Some + (check_expr ~global_env ~tvar_env ~cenv ~diagnostics ~control_ctx env + while_else expect_ty) + in + Control_ctx.warn_if_label_unused label new_control_ctx ~diagnostics; + Texpr_while + { + loop_cond = typed_cond; + loop_body = typed_body; + ty = + (match typed_while_else with + | Some expr -> Typedtree_util.type_of_typed_expr expr + | None -> Stype.unit); + while_else = typed_while_else; + label; + loc_ = loc; + } + : Typedtree.expr) and check_for (env : Local_env.t) (binders : (Syntax.binder * Syntax.expr) list) (condition : Syntax.expr option) (steps : (Syntax.binder * Syntax.expr) list) (body : Syntax.expr) - (for_else : Syntax.expr option) ~(expect_ty : expect_ty) ~loc ~control_ctx - ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.expr = - let is_relaxed_for = condition = None in - let ambiguous_control_ctx = Control_ctx.with_ambiguous_position control_ctx in - let typed_binders_rev = - Lst.fold_left binders [] (fun acc (binder, init) -> - let name = binder.binder_name in - let binder_loc = binder.loc_ in - (if - Lst.exists_fst acc (fun b -> - Ident.base_name b.Typedtree.binder_id = name) - then - let error = - Errors.duplicate_for_binder ~name:binder.binder_name - ~loc:binder_loc - in - add_error diagnostics error); - let binder = Typeutil.fresh_binder binder in - let init = - infer_expr ~global_env ~tvar_env ~cenv ~diagnostics - ~control_ctx:ambiguous_control_ctx env init - in - (binder, init) :: acc) - in - let typed_binders = List.rev typed_binders_rev in - let env_with_binders = - Lst.fold_left typed_binders env (fun env (binder, init) -> - Typeutil.add_binder env binder - ~typ:(Typedtree_util.type_of_typed_expr init) - ~mut:false) - in - let typed_condition = - match condition with - | None -> None - | Some cond -> - Some - (check_expr ~global_env ~tvar_env ~cenv - ~control_ctx:ambiguous_control_ctx ~diagnostics env_with_binders - cond (Expect_type Stype.bool)) - in - let typed_steps_rev = - Lst.fold_left steps [] (fun acc (binder, step) : (Typedtree.var * _) list -> - let name = binder.binder_name in - let binder_loc = binder.loc_ in - (if - Lst.exists_fst acc (fun b -> - Ident.base_name b.Typedtree.var_id = name) - then - let error = - Errors.duplicate_for_binder ~name:binder.binder_name - ~loc:binder_loc - in - add_error diagnostics error); - match - Lst.find_opt typed_binders (fun (binder, expr) -> - if Ident.base_name binder.binder_id = name then - Some (binder, Typedtree_util.type_of_typed_expr expr) - else None) - with - | Some (id, typ) -> - let typed_step = - check_expr ~global_env ~tvar_env ~cenv ~diagnostics - ~control_ctx:ambiguous_control_ctx env_with_binders step - (Expect_type typ) - in - ({ var_id = id.binder_id; loc_ = binder_loc }, typed_step) :: acc - | None -> - let error = - Errors.unknown_binder_in_for_steps ~name ~loc:binder_loc - in - add_error diagnostics error; - ( ({ var_id = Ident.fresh name; loc_ = binder_loc } : Typedtree.var), - infer_expr env_with_binders step - ~control_ctx:ambiguous_control_ctx ~tvar_env ~cenv ~global_env - ~diagnostics ) - :: acc) - in - let typed_steps = List.rev typed_steps_rev in - let binder_types = - Lst.map typed_binders (fun (_, expr) -> - Typedtree_util.type_of_typed_expr expr) - in - let new_control_ctx = - if for_else <> None || is_relaxed_for then - Control_ctx.with_for ~arg_typs:binder_types - ~break_typ:(Some (get_expected_type expect_ty)) - control_ctx - else Control_ctx.with_for ~arg_typs:binder_types ~break_typ:None control_ctx - in - let typed_body = - check_expr ~global_env ~tvar_env ~cenv ~control_ctx:new_control_ctx - ~diagnostics env_with_binders body Ignored - in - let typed_for_else = - match for_else with - | None when is_relaxed_for -> None - | None -> - (match expect_ty with - | Expect_type expect_ty when not (Ctype.try_unify expect_ty Stype.unit) - -> - add_error diagnostics - (Errors.need_else_branch ~loop_kind:`For ~loc - ~ty:(Printer.type_to_string expect_ty)) - | Ignored | Expect_type _ -> ()); - None - | Some for_else -> - Some - (check_expr ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - env_with_binders for_else expect_ty) - in - Texpr_for - { - binders = typed_binders; - condition = typed_condition; - steps = typed_steps; - body = typed_body; - for_else = typed_for_else; - ty = get_expected_type expect_ty; - loc_ = loc; - } + (for_else : Syntax.expr option) ~label ~(expect_ty : expect_ty) ~loc + ~control_ctx ~(tvar_env : Tvar_env.t) ~(cenv : Poly_type.t) + ~(global_env : Global_env.t) ~(diagnostics : Local_diagnostics.t) = + (let is_relaxed_for = condition = None in + let ambiguous_control_ctx = + Control_ctx.with_ambiguous_position control_ctx + in + let typed_binders_rev = + Lst.fold_left binders [] (fun acc -> + fun (binder, init) -> + let name = binder.binder_name in + let binder_loc = binder.loc_ in + (if + Lst.exists_fst acc (fun b -> + Ident.base_name b.Typedtree.binder_id = name) + then + let error = + Errors.duplicate_for_binder ~name:binder.binder_name + ~loc:binder_loc + in + add_error diagnostics error); + let binder = Typeutil.fresh_binder binder in + let init = + infer_expr ~global_env ~tvar_env ~cenv ~diagnostics + ~control_ctx:ambiguous_control_ctx env init + in + (binder, init) :: acc) + in + let typed_binders = List.rev typed_binders_rev in + let env_with_binders = + Lst.fold_left typed_binders env (fun env -> + fun (binder, init) -> + Typeutil.add_binder env binder + ~typ:(Typedtree_util.type_of_typed_expr init) + ~mut:false) + in + let typed_condition = + match condition with + | None -> None + | Some cond -> + Some + (check_expr ~global_env ~tvar_env ~cenv + ~control_ctx:ambiguous_control_ctx ~diagnostics env_with_binders + cond expect_bool) + in + let typed_steps_rev = + Lst.fold_left steps [] (fun acc -> + fun (binder, step) -> + (let name = binder.binder_name in + let binder_loc = binder.loc_ in + (if + Lst.exists_fst acc (fun b -> + Ident.base_name b.Typedtree.var_id = name) + then + let error = + Errors.duplicate_for_binder ~name:binder.binder_name + ~loc:binder_loc + in + add_error diagnostics error); + match + Lst.find_opt typed_binders (fun (binder, expr) -> + if Ident.base_name binder.binder_id = name then + Some (binder, Typedtree_util.type_of_typed_expr expr) + else None) + with + | Some (id, typ) -> + let typed_step = + check_expr ~global_env ~tvar_env ~cenv ~diagnostics + ~control_ctx:ambiguous_control_ctx env_with_binders step + (Expect_type typ) + in + ({ var_id = id.binder_id; loc_ = binder_loc }, typed_step) :: acc + | None -> + let error = + Errors.unknown_binder_in_for_steps ~name ~loc:binder_loc + in + add_error diagnostics error; + ( ({ var_id = Ident.fresh name; loc_ = binder_loc } + : Typedtree.var), + infer_expr env_with_binders step + ~control_ctx:ambiguous_control_ctx ~tvar_env ~cenv + ~global_env ~diagnostics ) + :: acc + : (Typedtree.var * _) list)) + in + let typed_steps = List.rev typed_steps_rev in + let binder_types = + Lst.map typed_binders (fun (_, expr) -> + Typedtree_util.type_of_typed_expr expr) + in + let label : Typedtree.loop_label_binder option = + match label with + | None -> None + | Some label -> + Some { label = Label.fresh label.label_name; loc_ = label.loc_ } + in + let new_control_ctx = + if for_else <> None || is_relaxed_for then + Control_ctx.with_for ~arg_typs:binder_types + ~break_typ:(Some (get_expected_type expect_ty)) + control_ctx ~label ~diagnostics + else + Control_ctx.with_for ~arg_typs:binder_types ~break_typ:None control_ctx + ~label ~diagnostics + in + let typed_body = + check_expr ~global_env ~tvar_env ~cenv ~control_ctx:new_control_ctx + ~diagnostics env_with_binders body Ignored + in + let typed_for_else = + match for_else with + | None when is_relaxed_for -> None + | None -> + (match expect_ty with + | Expect_type expect_ty when not (Ctype.try_unify expect_ty Stype.unit) + -> + add_error diagnostics + (Errors.need_else_branch ~loop_kind:`For ~loc + ~ty:(Printer.type_to_string expect_ty)) + | Ignored | Expect_type _ -> ()); + None + | Some for_else -> + Some + (check_expr ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + env_with_binders for_else expect_ty) + in + Control_ctx.warn_if_label_unused label new_control_ctx ~diagnostics; + Texpr_for + { + binders = typed_binders; + condition = typed_condition; + steps = typed_steps; + body = typed_body; + for_else = typed_for_else; + ty = get_expected_type expect_ty; + loc_ = loc; + label; + } + : Typedtree.expr) -and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env - ~tvar_env ~cenv ~control_ctx ~diagnostics = +and typing_foreach env binders expr body else_block ~label ~loc ~expect_ty + ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics = let loc_of_expr = Syntax.loc_of_expression expr in let n_binders = List.length binders in let expr = infer_expr env expr ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics in if Type.is_array_like (Typedtree_util.type_of_typed_expr expr) then - typing_foreach_transform_arraylike env binders expr body else_block ~loc - ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + typing_foreach_transform_arraylike env binders expr body else_block ~label + ~loc ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics else let expr, elem_tys = match Stype.type_repr (Typedtree_util.type_of_typed_expr expr) with @@ -3812,7 +4362,7 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env tys @ List.init (n_binders - n_tys) (fun _ -> Stype.new_type_var Tvar_error) - else Lst.take n_binders tys + else Lst.take tys n_binders in (expr, tys)) else (expr, tys) @@ -3833,7 +4383,7 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env in let iter = typing_self_method ty - { label_name = method_name; loc_ = loc_of_expr } + { label_name = method_name; loc_ = Rloc.no_location } ~src:Dot_src_direct ~loc:loc_of_expr ~global_env ~tvar_env ~cenv ~diagnostics in @@ -3847,7 +4397,9 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env Fn_arity.equal arity (Fn_arity.simple 1) ) | _ -> ((fun () -> Printer.type_to_string iter_method_ty), true) in - let expected = Builtin.type_arrow [ ty ] iter_ty ~err_ty:None in + let expected = + Builtin.type_arrow [ ty ] iter_ty ~err_ty:None ~is_async:false + in (if not (Ctype.try_unify expected iter_method_ty && has_correct_arity) then let expected = Printer.type_to_string expected in @@ -3855,9 +4407,10 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env add_error diagnostics (Errors.generic_type_mismatch ~header: - ("`foreach` loop: `" ^ method_name - ^ "` method of iterated expression has wrong type" + (("`foreach` loop: `" ^ method_name + ^ "` method of iterated expression has wrong type" : Stdlib.String.t) + [@merlin.hide]) ~expected ~actual ~loc:loc_of_expr)); ( Texpr_apply { @@ -3881,28 +4434,37 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env | Ignored | Expect_type _ -> ()); None | Some else_block -> - check_expr env else_block expect_ty ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - |> Option.some + Some + (check_expr env else_block expect_ty ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics) + in + let label : Typedtree.loop_label_binder option = + match label with + | None -> None + | Some label -> + Some { label = Label.fresh label.label_name; loc_ = label.loc_ } in let new_control_ctx = Control_ctx.with_foreach ~break_typ:(Option.map Typedtree_util.type_of_typed_expr else_block) - control_ctx + ~label control_ctx ~diagnostics in let binders = - Lst.map binders (fun binder : Typedtree.binder option -> - match binder with - | None -> None - | Some { binder_name; loc_ } -> - Some { binder_id = Ident.fresh binder_name; loc_ }) + Lst.map binders (fun binder -> + (match binder with + | None -> None + | Some { binder_name; loc_ } -> + Some { binder_id = Ident.fresh binder_name; loc_ } + : Typedtree.binder option)) in let new_env = - Lst.fold_left2 binders elem_tys env (fun binder elem_ty env -> - match binder with - | None -> env - | Some binder -> - Typeutil.add_binder env binder ~typ:elem_ty ~mut:false) + Lst.fold_left2 binders elem_tys env (fun binder -> + fun elem_ty -> + fun env -> + match binder with + | None -> env + | Some binder -> + Typeutil.add_binder env binder ~typ:elem_ty ~mut:false) in let body = check_expr new_env body Ignored ~global_env ~tvar_env ~cenv @@ -3913,10 +4475,13 @@ and typing_foreach env binders expr body else_block ~loc ~expect_ty ~global_env | Some expr -> Typedtree_util.type_of_typed_expr expr | None -> Stype.unit in - Texpr_foreach { binders; elem_tys; expr; body; else_block; ty; loc_ = loc } + Control_ctx.warn_if_label_unused label new_control_ctx ~diagnostics; + Texpr_foreach + { binders; elem_tys; expr; body; else_block; ty; loc_ = loc; label } and typing_foreach_transform_arraylike env binders expr_typed body else_block - ~loc ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics = + ~label ~loc ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + = let arr_name_raw = "*arr" in let arr_name = Ident.fresh arr_name_raw in let arr_binder : Typedtree.binder = @@ -4011,20 +4576,31 @@ and typing_foreach_transform_arraylike env binders expr_typed body else_block ]; for_else = else_block; body; + label; loc_ = loc; } in let el_binder, it_binder = match binders with + | [] -> + let fresh_binder_name = Ident.base_name (Ident.fresh "*el") in + ( Some + ({ binder_name = fresh_binder_name; loc_ = Rloc.no_location } + : Syntax.binder), + None ) | el_binder :: [] -> (el_binder, None) | [ it_binder; el_binder ] -> (el_binder, Some it_binder) - | _ -> assert false + | it_binder :: el_binder :: _ as binders -> + Local_diagnostics.add_error diagnostics + (Errors.foreach_loop_variable_count_mismatch ~loc + ~actual:(List.length binders) ~expected:None); + (el_binder, Some it_binder) in let binder_to_pat : Syntax.binder option -> Syntax.pattern = function | None -> Syntax.Ppat_any { loc_ = Rloc.no_location } | Some { binder_name; loc_ } -> Syntax.Ppat_var { binder_name; loc_ } in - let let_el body = + let let_el body el_binder = Syntax.Pexpr_let { pattern = binder_to_pat el_binder; @@ -4041,7 +4617,8 @@ and typing_foreach_transform_arraylike env binders expr_typed body else_block }; loc_ = Rloc.no_location; }; - method_name = { label_name = "op_get"; loc_ = Rloc.no_location }; + method_name = + { label_name = "unsafe_get"; loc_ = Rloc.no_location }; args = [ { @@ -4059,7 +4636,7 @@ and typing_foreach_transform_arraylike env binders expr_typed body else_block loc_ = Rloc.no_location; } in - let let_iter body = + let let_iter body it_binder = match it_binder with | None -> body | Some it_binder -> @@ -4072,7 +4649,7 @@ and typing_foreach_transform_arraylike env binders expr_typed body else_block loc_ = Rloc.no_location; } in - let for_loop_body = let_iter (let_el body) in + let for_loop_body = let_iter (let_el body el_binder) it_binder in let for_loop = for_loop for_loop_body in let_length for_loop in @@ -4088,568 +4665,727 @@ and typing_foreach_transform_arraylike env binders expr_typed body else_block and typing_range_for_in env (binders : Syntax.binder option list) (lhs : Syntax.expr) (rhs : Syntax.expr) (body : Syntax.expr) - (else_block : Syntax.expr option) ~(inclusive : bool) ~operator_loc ~loc - ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics : - Typedtree.expr = - let tlhs = - infer_expr env lhs ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - in - let lhs_ty = Stype.type_repr (Typedtree_util.type_of_typed_expr tlhs) in - let trhs, elem_ty = - let check_rhs expect_ty = - check_expr env rhs (Expect_type expect_ty) ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - [@@inline] - in - let is_supported (b : Stype.builtin) = - match b with - | T_int | T_uint | T_int64 | T_uint64 -> true - | T_unit | T_bool | T_byte | T_char | T_float | T_double | T_string - | T_bytes -> - false - [@@inline] - in - match lhs_ty with - | T_builtin b when is_supported b -> (check_rhs lhs_ty, lhs_ty) - | Tvar _ -> ( - let trhs = check_rhs lhs_ty in - match Stype.type_repr (Typedtree_util.type_of_typed_expr trhs) with - | T_builtin b when is_supported b -> (trhs, lhs_ty) - | Tvar _ as rhs_ty -> - Ctype.unify_exn rhs_ty Stype.int; - (trhs, lhs_ty) - | _ -> - add_error diagnostics - (Errors.range_operator_unsupported_type - ~actual_ty:(Printer.type_to_string lhs_ty) - ~loc:operator_loc); - (trhs, Stype.int)) - | _ -> - add_error diagnostics - (Errors.range_operator_unsupported_type - ~actual_ty:(Printer.type_to_string lhs_ty) - ~loc:operator_loc); - (check_rhs (Stype.new_type_var Tvar_error), Stype.int) - in - let lhs_var = - ("*start" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) - in - let rhs_var = - ("*end" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) - in - let hole () : Syntax.expr = - Pexpr_hole { kind = Synthesized; loc_ = Rloc.no_location } - in - let loop_binders = - match binders with - | [] -> [] - | first_binder :: rest -> - let first_binder = - match first_binder with - | Some binder -> binder - | None -> { binder_name = "_"; loc_ = Rloc.no_location } - in - if rest <> [] then - add_error diagnostics - (Errors.foreach_loop_variable_count_mismatch - ~actual:(List.length binders) ~expected:(Some 1) ~loc); - ( first_binder, - Syntax.Pexpr_ident - { - id = { var_name = Lident lhs_var; loc_ = Rloc.no_location }; - loc_ = Rloc.no_location; - } ) - :: Lst.fold_right rest [] (fun binder_opt acc -> - match binder_opt with - | Some binder -> (binder, hole ()) :: acc - | None -> acc) - in - let loop_variable : Syntax.expr = - match loop_binders with - | (binder, _) :: _ -> - Pexpr_ident - { - id = - { var_name = Lident binder.binder_name; loc_ = Rloc.no_location }; - loc_ = Rloc.no_location; - } - | [] -> hole () - in - let cond_op : Syntax.var = - if inclusive then { var_name = Lident "<="; loc_ = Rloc.no_location } - else { var_name = Lident "<"; loc_ = Rloc.no_location } - in - let condition : Syntax.expr = - Pexpr_infix - { - op = cond_op; - lhs = loop_variable; - rhs = - Pexpr_ident - { - id = { var_name = Lident rhs_var; loc_ = Rloc.no_location }; - loc_ = Rloc.no_location; - }; - loc_ = Rloc.no_location; - } - in - let loop_update : (Syntax.binder * Syntax.expr) list = - match loop_binders with - | (binder, _) :: _ -> - [ - ( binder, - Pexpr_infix - { - op = { var_name = Lident "+"; loc_ = Rloc.no_location }; - lhs = loop_variable; - rhs = - Pexpr_constant { c = Const_int "1"; loc_ = Rloc.no_location }; - loc_ = Rloc.no_location; - } ); - ] - | [] -> [] - in - let lhs_binder : Typedtree.binder = - { binder_id = Ident.fresh lhs_var; loc_ = Rloc.no_location } - in - let rhs_binder : Typedtree.binder = - { binder_id = Ident.fresh rhs_var; loc_ = Rloc.no_location } - in - let lhs_pat_binder : Typedtree.pat_binder = - { binder = lhs_binder; binder_typ = elem_ty } - in - let rhs_pat_binder : Typedtree.pat_binder = - { binder = rhs_binder; binder_typ = elem_ty } - in - let loop : Syntax.expr = - Pexpr_for - { - binders = loop_binders; - condition = Some condition; - continue_block = loop_update; - for_else = else_block; - body; - loc_ = loc; - } - in - let tloop = - check_expr - (Typeutil.add_pat_binders env [ lhs_pat_binder; rhs_pat_binder ]) - loop expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics - in - let ty = Stype.type_repr (Typedtree_util.type_of_typed_expr tloop) in - Texpr_let - { - pat = - Tpat_var { binder = lhs_binder; ty = elem_ty; loc_ = Rloc.no_location }; - pat_binders = [ lhs_pat_binder ]; - rhs = tlhs; - ty; - loc_ = Rloc.no_location; - body = - Texpr_let - { - pat = - Tpat_var - { binder = rhs_binder; ty = elem_ty; loc_ = Rloc.no_location }; - pat_binders = [ rhs_pat_binder ]; - rhs = trhs; - ty; - loc_ = Rloc.no_location; - body = tloop; - }; - } - -and check_break env arg ~expect_ty ~loc ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics : Typedtree.expr = - let check_break_arg break_arg arg = - let arg = - check_expr env arg (Expect_type break_arg) ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics - in - Typedtree.Texpr_break { arg = Some arg; ty = expect_ty; loc_ = loc } - in - let fallback () = - let arg = - arg - |> Option.map (fun arg -> - infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics) - in - Typedtree.Texpr_break { arg; ty = expect_ty; loc_ = loc } - [@@inline] - in - match control_ctx.control_info with - | Not_in_loop -> - add_error diagnostics (Errors.outside_loop ~msg:"break" ~loc); - fallback () - | Ambiguous_position -> - add_error diagnostics (Errors.ambiguous_break loc); - fallback () - | In_while - | In_for { break = None; continue = _ } - | In_foreach { break = None } -> ( - match arg with - | None -> Texpr_break { arg = None; ty = expect_ty; loc_ = loc } - | Some arg -> - let kind = - match control_ctx.control_info with - | In_while | In_while_else _ -> `While - | In_for _ -> `For - | In_foreach _ -> `For - | _ -> assert false - in - add_error diagnostics (Errors.invalid_break ~loop_kind:kind ~loc); - let arg = - infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics - in - Texpr_break { arg = Some arg; ty = expect_ty; loc_ = loc }) - | In_loop { break = break_arg; continue = _ } - | In_while_else { break = break_arg } - | In_for { break = Some break_arg; continue = _ } - | In_foreach { break = Some break_arg } -> ( - match arg with - | None -> - (try Ctype.unify_exn break_arg Stype.unit - with _ -> + (else_block : Syntax.expr option) ~label ~(inclusive : bool) ~operator_loc + ~loc ~expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics = + (let tlhs = + infer_expr env lhs ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + in + let lhs_ty = Stype.type_repr (Typedtree_util.type_of_typed_expr tlhs) in + let trhs, elem_ty = + let check_rhs expect_ty = + check_expr env rhs (Expect_type expect_ty) ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics + [@@inline] + in + let is_supported (b : Stype.builtin) = + match b with + | T_int | T_uint | T_int64 | T_uint64 -> true + | T_unit | T_bool | T_byte | T_int16 | T_uint16 | T_char | T_float + | T_double | T_string | T_bytes -> + false + [@@inline] + in + match lhs_ty with + | T_builtin b when is_supported b -> (check_rhs lhs_ty, lhs_ty) + | Tvar _ -> ( + let trhs = check_rhs lhs_ty in + match Stype.type_repr (Typedtree_util.type_of_typed_expr trhs) with + | T_builtin b when is_supported b -> (trhs, lhs_ty) + | Tvar _ as rhs_ty -> + Ctype.unify_exn rhs_ty Stype.int; + (trhs, lhs_ty) + | _ -> add_error diagnostics - (Errors.break_type_mismatch - ~expected:(Printer.type_to_string break_arg) - ~actual:"no arguments" ~loc)); - Texpr_break { arg = None; ty = expect_ty; loc_ = loc } - | Some arg -> check_break_arg break_arg arg) + (Errors.range_operator_unsupported_type + ~actual_ty:(Printer.type_to_string lhs_ty) + ~loc:operator_loc); + (trhs, Stype.int)) + | _ -> + add_error diagnostics + (Errors.range_operator_unsupported_type + ~actual_ty:(Printer.type_to_string lhs_ty) + ~loc:operator_loc); + (check_rhs (Stype.new_type_var Tvar_error), Stype.int) + in + let lhs_var = + ("*start" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) + in + let rhs_var = + ("*end" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) + in + let hole () = + (Pexpr_hole { kind = Synthesized; loc_ = Rloc.no_location } : Syntax.expr) + in + let loop_binders = + match binders with + | [] -> [] + | first_binder :: rest -> + let first_binder = + match first_binder with + | Some binder -> binder + | None -> { binder_name = "_"; loc_ = Rloc.no_location } + in + if rest <> [] then + add_error diagnostics + (Errors.foreach_loop_variable_count_mismatch + ~actual:(List.length binders) ~expected:(Some 1) ~loc); + ( first_binder, + Syntax.Pexpr_ident + { + id = { var_name = Lident lhs_var; loc_ = Rloc.no_location }; + loc_ = Rloc.no_location; + } ) + :: Lst.fold_right rest [] (fun binder_opt -> + fun acc -> + match binder_opt with + | Some binder -> (binder, hole ()) :: acc + | None -> acc) + in + let loop_variable : Syntax.expr = + match loop_binders with + | (binder, _) :: _ -> + Pexpr_ident + { + id = + { var_name = Lident binder.binder_name; loc_ = Rloc.no_location }; + loc_ = Rloc.no_location; + } + | [] -> hole () + in + let cond_op : Syntax.var = + if inclusive then { var_name = Lident "<="; loc_ = Rloc.no_location } + else { var_name = Lident "<"; loc_ = Rloc.no_location } + in + let condition : Syntax.expr = + Pexpr_infix + { + op = cond_op; + lhs = loop_variable; + rhs = + Pexpr_ident + { + id = { var_name = Lident rhs_var; loc_ = Rloc.no_location }; + loc_ = Rloc.no_location; + }; + loc_ = Rloc.no_location; + } + in + let loop_update : (Syntax.binder * Syntax.expr) list = + match loop_binders with + | (binder, _) :: _ -> + [ + ( binder, + Pexpr_infix + { + op = { var_name = Lident "+"; loc_ = Rloc.no_location }; + lhs = loop_variable; + rhs = + Pexpr_constant { c = Const_int "1"; loc_ = Rloc.no_location }; + loc_ = Rloc.no_location; + } ); + ] + | [] -> [] + in + let lhs_binder : Typedtree.binder = + { binder_id = Ident.fresh lhs_var; loc_ = Rloc.no_location } + in + let rhs_binder : Typedtree.binder = + { binder_id = Ident.fresh rhs_var; loc_ = Rloc.no_location } + in + let lhs_pat_binder : Typedtree.pat_binder = + { binder = lhs_binder; binder_typ = elem_ty } + in + let rhs_pat_binder : Typedtree.pat_binder = + { binder = rhs_binder; binder_typ = elem_ty } + in + let loop : Syntax.expr = + Pexpr_for + { + binders = loop_binders; + condition = Some condition; + continue_block = loop_update; + for_else = else_block; + body; + label; + loc_ = loc; + } + in + let tloop = + check_expr + (Typeutil.add_pat_binders env [ lhs_pat_binder; rhs_pat_binder ]) + loop expect_ty ~global_env ~tvar_env ~cenv ~control_ctx ~diagnostics + in + let ty = Stype.type_repr (Typedtree_util.type_of_typed_expr tloop) in + Texpr_let + { + pat = + Tpat_var { binder = lhs_binder; ty = elem_ty; loc_ = Rloc.no_location }; + pat_binders = [ lhs_pat_binder ]; + rhs = tlhs; + ty; + loc_ = Rloc.no_location; + body = + Texpr_let + { + pat = + Tpat_var + { binder = rhs_binder; ty = elem_ty; loc_ = Rloc.no_location }; + pat_binders = [ rhs_pat_binder ]; + rhs = trhs; + ty; + loc_ = Rloc.no_location; + body = tloop; + }; + } + : Typedtree.expr) -and check_continue env args ~expect_ty ~loc ~global_env ~tvar_env ~cenv - ~control_ctx ~diagnostics : Typedtree.expr = - let check_continue_args continue_args = - let expected = List.length continue_args in - let actual = List.length args in - if expected <> actual then - add_error diagnostics - (Errors.continue_arity_mismatch ~expected ~actual ~loc); - let rec check_args expected_tys args = - match (expected_tys, args) with - | [], args -> - Lst.map args (fun arg -> - infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics) - | _, [] -> [] - | expected_ty :: expected_tys, arg :: args -> - check_expr env arg (Expect_type expected_ty) ~global_env ~tvar_env - ~cenv ~control_ctx ~diagnostics - :: check_args expected_tys args - in - let args = check_args continue_args args in - Typedtree.Texpr_continue { args; ty = expect_ty; loc_ = loc } - [@@inline] - in - let fallback () = - let args = - Lst.map args (fun arg -> - infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics) - in - Typedtree.Texpr_continue { args; ty = expect_ty; loc_ = loc } - [@@inline] - in - match control_ctx.control_info with - | Not_in_loop -> - add_error diagnostics (Errors.outside_loop ~msg:"continue" ~loc); - fallback () - | Ambiguous_position -> - add_error diagnostics (Errors.ambiguous_continue loc); - fallback () - | In_while | In_while_else _ | In_foreach _ -> - if args <> [] then - add_error diagnostics - (Errors.continue_arity_mismatch ~expected:0 ~actual:(List.length args) - ~loc); - let args = - Lst.map args (fun arg -> - infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx - ~diagnostics) - in - Texpr_continue { args; ty = expect_ty; loc_ = loc } - | In_for { continue = continue_args; break = _ } -> - if args = [] then Texpr_continue { args = []; ty = expect_ty; loc_ = loc } - else check_continue_args continue_args - | In_loop { continue = continue_args; _ } -> - control_ctx.has_continue := true; - check_continue_args continue_args +and check_break env arg ~label ~expect_ty ~loc ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics = + (let check_break_arg break_arg arg label = + let arg = + check_expr env arg (Expect_type break_arg) ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics + in + Typedtree.Texpr_break { arg = Some arg; ty = expect_ty; loc_ = loc; label } + in + let fallback label = + let arg = + Option.map + (fun arg -> + infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics) + arg + in + Typedtree.Texpr_break { arg; ty = expect_ty; loc_ = loc; label } + [@@inline] + in + let check_with_control_info (control_info : Control_ctx.control_info) + (label : Typedtree.loop_label option) = + match control_info with + | Not_in_loop -> + add_error diagnostics (Errors.outside_loop ~msg:"break" ~loc); + fallback label + | Ambiguous_position -> + add_error diagnostics (Errors.ambiguous_break loc); + fallback label + | In_while + | In_for { break = None; continue = _ } + | In_foreach { break = None } -> ( + match arg with + | None -> Texpr_break { arg = None; ty = expect_ty; loc_ = loc; label } + | Some arg -> + let kind = + match control_ctx.control_info with + | In_while | In_while_with_else _ -> `While + | In_for _ -> `For + | In_foreach _ -> `For + | _ -> assert false + in + add_error diagnostics (Errors.invalid_break ~loop_kind:kind ~loc); + let arg = + infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics + in + Texpr_break { arg = Some arg; ty = expect_ty; loc_ = loc; label }) + | In_loop { break = break_arg; continue = _; has_continue = _ } + | In_while_with_else { break = break_arg } + | In_for { break = Some break_arg; continue = _ } + | In_foreach { break = Some break_arg } -> ( + match arg with + | None -> + (try Ctype.unify_exn break_arg Stype.unit + with _ -> + add_error diagnostics + (Errors.break_type_mismatch + ~expected:(Printer.type_to_string break_arg) + ~actual:"no arguments" ~loc)); + Texpr_break { arg = None; ty = expect_ty; loc_ = loc; label } + | Some arg -> check_break_arg break_arg arg label) + [@@inline] + in + match label with + | None -> check_with_control_info control_ctx.control_info None + | Some label -> ( + match Lst.assoc_str control_ctx.labeled_controls label.label_name with + | Some control_info -> + let label : Typedtree.loop_label = + { label = control_info.label; loc_ = label.loc_ } + in + control_info.used := true; + check_with_control_info control_info.control_info (Some label) + | None -> + let error = + Errors.use_undeclared_loop_label ~loc:label.loc_ label.label_name + in + add_error diagnostics error; + let label : Typedtree.loop_label = + { label = Label.fresh label.label_name; loc_ = label.loc_ } + in + fallback (Some label)) + : Typedtree.expr) + +and check_continue env args ~label ~expect_ty ~loc ~global_env ~tvar_env ~cenv + ~control_ctx ~diagnostics = + (let check_continue_args continue_args label = + let expected = List.length continue_args in + let actual = List.length args in + if expected <> actual then + add_error diagnostics + (Errors.continue_arity_mismatch ~expected ~actual ~loc); + let rec check_args expected_tys args = + match (expected_tys, args) with + | [], args -> + Lst.map args (fun arg -> + infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics) + | _, [] -> [] + | expected_ty :: expected_tys, arg :: args -> + check_expr env arg (Expect_type expected_ty) ~global_env ~tvar_env + ~cenv ~control_ctx ~diagnostics + :: check_args expected_tys args + in + let args = check_args continue_args args in + Typedtree.Texpr_continue { args; ty = expect_ty; loc_ = loc; label } + [@@inline] + in + let fallback label = + let args = + Lst.map args (fun arg -> + infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics) + in + Typedtree.Texpr_continue { args; ty = expect_ty; label; loc_ = loc } + [@@inline] + in + let check_with_control_info (control_info : Control_ctx.control_info) label = + match control_info with + | Not_in_loop -> + add_error diagnostics (Errors.outside_loop ~msg:"continue" ~loc); + fallback label + | Ambiguous_position -> + add_error diagnostics (Errors.ambiguous_continue loc); + fallback label + | In_while | In_while_with_else _ | In_foreach _ -> + if args <> [] then + add_error diagnostics + (Errors.continue_arity_mismatch ~expected:0 + ~actual:(List.length args) ~loc); + let args = + Lst.map args (fun arg -> + infer_expr env arg ~global_env ~tvar_env ~cenv ~control_ctx + ~diagnostics) + in + Texpr_continue { args; ty = expect_ty; loc_ = loc; label } + | In_for { continue = continue_args; break = _ } -> + if args = [] then + Texpr_continue { args = []; ty = expect_ty; loc_ = loc; label } + else check_continue_args continue_args label + | In_loop { continue = continue_args; has_continue; _ } -> + has_continue := true; + check_continue_args continue_args label + [@@inline] + in + match label with + | None -> check_with_control_info control_ctx.control_info None + | Some label -> ( + match Lst.assoc_str control_ctx.labeled_controls label.label_name with + | Some control_info -> + let label : Typedtree.loop_label = + { label = control_info.label; loc_ = label.loc_ } + in + control_info.used := true; + check_with_control_info control_info.control_info (Some label) + | None -> + let error = + Errors.use_undeclared_loop_label ~loc:label.loc_ label.label_name + in + add_error diagnostics error; + let label : Typedtree.loop_label = + { label = Label.fresh label.label_name; loc_ = label.loc_ } + in + fallback (Some label)) + : Typedtree.expr) let typing_impl_expr env expr ~(global_env : Global_env.t) ~diagnostics = let cenv = Poly_type.make () in let tvar_env = Tvar_env.empty in let te = check_expr env expr Ignored - ~control_ctx:(Control_ctx.make_fn ~return:Stype.unit ~error_ctx:None) + ~control_ctx: + (Control_ctx.make_fn ~return:Stype.unit ~error_ctx:None ~is_async:false) ~tvar_env ~cenv ~global_env ~diagnostics in Type_lint.type_lint te ~diagnostics; Type_constraint.solve_constraints cenv ~tvar_env ~global_env ~diagnostics; te -let typing_impl_let (binder : Syntax.binder) - (expr : Toplevel_typer.top_let_body) ~(id : Ident.t) ~(typ : Stype.t) - (env : Local_env.t) ~(global_env : Global_env.t) - ~(diagnostics : Local_diagnostics.t) : Typedtree.binder * Typedtree.expr = - let cenv = Poly_type.make () in - let tvar_env = Tvar_env.empty in - let te = - match expr with - | Wl_toplet_const c -> c - | Wl_toplet_normal expr -> - check_expr env expr (Expect_type typ) ~control_ctx:Control_ctx.empty - ~tvar_env ~cenv ~global_env ~diagnostics - in - Type_lint.type_lint te ~diagnostics; - Type_constraint.solve_constraints cenv ~tvar_env ~global_env ~diagnostics; - let binder : Typedtree.binder = { binder_id = id; loc_ = binder.loc_ } in - (binder, te) +let typing_impl_let (binder : Syntax.binder) (expr : Syntax.expr) + ~(id : Ident.t) ~(typ : Stype.t) ~(global_env : Global_env.t) + ~(diagnostics : Local_diagnostics.t) = + (let cenv = Poly_type.make () in + let tvar_env = Tvar_env.empty in + let te = + check_expr Local_env.empty expr (Expect_type typ) + ~control_ctx:Control_ctx.empty ~tvar_env ~cenv ~global_env ~diagnostics + in + Type_lint.type_lint te ~diagnostics; + Type_constraint.solve_constraints cenv ~tvar_env ~global_env ~diagnostics; + let binder : Typedtree.binder = { binder_id = id; loc_ = binder.loc_ } in + (binder, te) + : Typedtree.binder * Typedtree.expr) let derive_by_ast ~global_env (directive : Syntax.deriving_directive) (decl : Syntax.type_decl) (method_name : string) ~trait_path - ~(deriver : Ast_derive.deriver) ~(diagnostics : Local_diagnostics.t) : - Toplevel_typer.value_worklist_item = - let trait = directive.type_name_ in - let tpath = - Type_path.toplevel_type ~pkg:!Basic_config.current_package decl.tycon - in - let meth_info = - Ext_method_env.find_method - (Global_env.get_ext_method_env global_env) - ~trait:trait_path ~self_type:tpath ~method_name - |> Option.get - in - match[@warning "-fragile-match"] meth_info.typ with - | (Tarrow { params_ty; ret_ty; err_ty } : Stype.t) -> - let param_names, params = - Lst.map_split params_ty (fun _ -> - let param_name = - ("*x_" ^ Int.to_string (Basic_uuid.next ()) : Stdlib.String.t) - in - let param : Syntax.parameter = - { - param_binder = - { binder_name = param_name; loc_ = Rloc.no_location }; - param_annot = None; - param_kind = Positional; - } - in - (param_name, param)) - in - let assertions = Vec.empty () in - let body = - deriver directive decl ~params:param_names ~assertions ~diagnostics - in - Wl_top_funcdef - { - fun_binder = { binder_name = method_name; loc_ = trait.loc_ }; - decl_params = params; - params_loc = Rloc.no_location; - is_pub = meth_info.pub; - doc = meth_info.doc_; - decl_body = - Decl_body - { - expr = - Pexpr_static_assert { asserts = Vec.to_list assertions; body }; - local_types = []; - }; - loc_ = decl.loc_; - id = meth_info.id; - kind = Fun_kind_method None; - arity = meth_info.arity_; - tvar_env = meth_info.ty_params_; - typed_fn_annotation = - { - params_ty = Lst.map params_ty (fun ty -> (ty, None)); - ret_ty; - err_ty; - ret_annotation = No_error_type_annotated; - }; - } - | _ -> assert false + ~(type_path : Type_path.t) ~(deriver : Ast_derive.deriver) + ~(diagnostics : Local_diagnostics.t) = + (let trait = directive.type_name_ in + let tpath = type_path in + let meth_info = + Option.get + (Ext_method_env.find_method + (Global_env.get_ext_method_env global_env) + ~trait:trait_path ~self_type:tpath ~method_name) + in + match[@warning "-fragile-match"] meth_info.typ with + | (Tarrow { params_ty; ret_ty; err_ty; is_async } : Stype.t) -> + let param_names, params = + Lst.map_split params_ty (fun _ -> + let param_name = + (("*x_" ^ Int.to_string (Basic_uuid.next ()) + : Stdlib.String.t) + [@merlin.hide]) + in + let param : Syntax.parameter = + Positional + { + binder = + { binder_name = param_name; loc_ = Rloc.no_location }; + ty = None; + } + in + (param_name, param)) + in + let assertions = Vec.empty () in + let body = + deriver directive decl ~params:param_names ~assertions ~diagnostics + in + Wl_top_funcdef + { + fun_binder = { binder_name = method_name; loc_ = trait.loc_ }; + decl_params = params; + params_loc = Rloc.no_location; + is_pub = meth_info.pub; + doc = meth_info.doc_; + attrs = []; + decl_body = + Decl_body + { + expr = + Pexpr_static_assert + { asserts = Vec.to_list assertions; body }; + local_types = []; + }; + loc_ = decl.loc_; + id = meth_info.id; + kind = Fun_kind_method None; + arity = meth_info.arity_; + tvar_env = meth_info.ty_params_; + typed_fn_annotation = + { + params_ty = Lst.map params_ty (fun ty -> (ty, None)); + ret_ty; + err_ty; + is_async; + ret_annotation = No_annotation; + }; + constraint_names = []; + } + | _ -> assert false + : Local_typing_worklist.value) -let rec typing_worklist_item (item : Toplevel_typer.value_worklist_item) - ~global_env ~diagnostics ~(acc : Typedtree.impls) : Typedtree.impls = - match item with - | Wl_top_expr { expr; is_main; id; loc_ } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let te = - typing_impl_expr Local_env.empty expr ~global_env - ~diagnostics:local_diagnostics - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - Typedtree.Timpl_expr - { expr = te; is_main; expr_id = id; loc_; is_generated_ = false } - :: acc - | Wl_top_letdef { binder; expr; loc_; is_pub; doc_; konstraint; id; typ } -> - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let binder, te = - typing_impl_let binder expr ~id:(Ident.of_qual_ident id) ~typ - Local_env.empty ~global_env ~diagnostics:local_diagnostics - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - Typedtree.Timpl_letdef - { - binder; - expr = te; - is_pub; - loc_; - konstraint; - doc_; - is_generated_ = false; - } - :: acc - | Wl_top_funcdef - { - fun_binder; - decl_params; - params_loc; - is_pub; - doc; - decl_body; - loc_; - id; - kind; - arity; - tvar_env; - typed_fn_annotation; - } -> ( - let local_diagnostics = Local_diagnostics.make ~base:loc_ in - let binder : Typedtree.binder = - { binder_id = Ident.of_qual_ident id; loc_ = fun_binder.loc_ } - in - match decl_body with - | Decl_stubs func_stubs -> - let is_import_stub, language = - match func_stubs with - | Import _ -> (true, None) - | Embedded { language; _ } -> (false, language) - in - let ({ params_ty; ret_ty = _; err_ty = _; ret_annotation } - : Toplevel_typer.typed_fn_annotation) = - typed_fn_annotation - in - let stub_body : Typedtree.stub_body = - if Syntax_util.is_intrinsic func_stubs then Intrinsic - else - let language = - Option.map (fun s -> s.Literal.string_val) language - in - let check_type ~allow_func ty = - Typeutil.check_stub_type ~language ty global_env ~allow_func - ~is_import_stub - |> store_error ~diagnostics:local_diagnostics - in - Lst.iter params_ty (fun (_, ty_opt) -> - match ty_opt with - | Some ty -> check_type ~allow_func:true ty - | None -> ()); - (match ret_annotation with - | Annotated (ret_annot, _) -> - check_type ~allow_func:false ret_annot - | No_error_type_annotated | Has_error_type _ -> ()); - let func_stubs = - Stub_type.from_syntax func_stubs ~loc:loc_ - |> Parsing_partial_info.take_info ~diagnostics - in - Func_stub func_stubs - in - let cenv = Poly_type.make () in - let _, params = - check_function_params Local_env.empty decl_params params_ty - ~is_global:true ~tvar_env ~cenv ~global_env - ~diagnostics:local_diagnostics - in - Lst.iter params (fun (Param { kind; _ }) -> - match kind with - | Optional default -> - Type_lint.type_lint default ~diagnostics:local_diagnostics - | Positional | Labelled | Autofill | Question_optional -> ()); - Type_constraint.solve_constraints cenv ~tvar_env ~global_env - ~diagnostics:local_diagnostics; - let ret = - match ret_annotation with - | Annotated (ret, _) -> Some ret - | Has_error_type _ | No_error_type_annotated -> None - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - Timpl_stub_decl - { - binder; - params; - ret; - func_stubs = stub_body; - is_pub; - arity_ = arity; - kind_ = kind; - loc_; - doc_ = doc; - } - :: acc - | Decl_body { expr = decl_body; local_types = _ } -> - let cenv = Poly_type.make () in - let is_in_test = - String.starts_with ~prefix:"__test_" fun_binder.binder_name - in - let is_impl_method = - match id with - | Qext_method _ -> true - | Qregular _ | Qmethod _ | Qregular_implicit_pkg _ -> false - in - let tfuns, _ = - check_function ~is_impl_method Local_env.empty decl_params - params_loc decl_body typed_fn_annotation ~kind_:Lambda - ~is_global:true ~is_in_test ~tvar_env ~cenv ~global_env - ~diagnostics:local_diagnostics - in - Type_lint.type_lint_fn tfuns ~diagnostics:local_diagnostics; - Type_constraint.solve_constraints cenv ~tvar_env ~global_env - ~diagnostics:local_diagnostics; - Local_diagnostics.add_to_global local_diagnostics diagnostics; - Timpl_fun_decl - { - fun_decl = - { - kind; - fn_binder = binder; - fn = tfuns; - is_pub; - ty_params_ = tvar_env; - doc_ = doc; - }; - arity_ = arity; - loc_; - is_generated_ = false; - } - :: acc) - | Wl_derive { ty_decl; directive; syn_decl; trait_path; _ } -> ( - let local_diagnostics = Local_diagnostics.make ~base:syn_decl.loc_ in - match Type_path.Hash.find_opt Ast_derive.derivers trait_path with - | Some derivers -> - let res = - Lst.fold_right derivers acc (fun (method_name, deriver) acc -> - derive_by_ast ~global_env directive syn_decl method_name - ~trait_path ~deriver ~diagnostics:local_diagnostics - |> typing_worklist_item ~acc ~global_env ~diagnostics) - in - Local_diagnostics.add_to_global local_diagnostics diagnostics; - res - | None -> - Local_diagnostics.add_error local_diagnostics - (Errors.derive_unsupported_trait ~tycon:ty_decl.ty_constr - ~trait:directive.type_name_.name ~loc:directive.loc_); - Local_diagnostics.add_to_global local_diagnostics diagnostics; - acc) +let rec typing_worklist_item (item : Local_typing_worklist.value) ~global_env + ~diagnostics ~(impls_acc : Typedtree.impls) + ~(local_types_acc : Typedtree.type_decl list) + ~(local_type_env : Local_type.env option) = + (match item with + | Wl_top_expr { expr; is_main; id; loc_; local_types } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + if local_type_env = None then + Global_env.add_new_local_type_env global_env id loc_; + let local_types_tast, derive_tasks = + Typeutil.typing_local_type local_types id ~global_env + ~tvar_env:Tvar_env.empty ~base:loc_ ~diagnostics:local_diagnostics + in + let derived_impls = + Lst.concat_map derive_tasks + (fun { decl; directive; trait_path; type_path } -> + let trait_name = directive.type_name_ in + match Type_path.Hash.find_opt Ast_derive.derivers trait_path with + | Some derivers -> + Lst.concat_map derivers (fun (method_name, deriver) -> + let ast = + derive_by_ast ~type_path ~trait_path ~global_env + directive decl method_name ~deriver + ~diagnostics:local_diagnostics + in + fst + (typing_worklist_item ast ~global_env ~diagnostics + ~impls_acc:[] ~local_types_acc:[] + ~local_type_env: + (Global_env.get_cur_local_type_env global_env))) + | None -> + Local_diagnostics.add_error local_diagnostics + (Errors.derive_unsupported_trait ~tycon:type_path + ~trait:trait_name.name ~loc:trait_name.loc_); + []) + in + let te = + typing_impl_expr Local_env.empty expr ~global_env + ~diagnostics:local_diagnostics + in + if local_type_env = None then + Global_env.clear_cur_local_type_env global_env; + Local_diagnostics.add_to_global local_diagnostics diagnostics; + ( Typedtree.Timpl_expr + { expr = te; is_main; expr_id = id; loc_; is_generated_ = false } + :: derived_impls + @ impls_acc, + local_types_tast @ local_types_acc ) + | Wl_top_letdef + { binder; expr; loc_; is_pub; doc_; konstraint; id; typ; attrs } -> + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let binder, te = + typing_impl_let binder expr ~id:(Ident.of_qual_ident id) ~typ + ~global_env ~diagnostics:local_diagnostics + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + ( Typedtree.Timpl_letdef + { + binder; + expr = te; + is_pub; + loc_; + konstraint; + doc_; + attrs; + is_generated_ = false; + } + :: impls_acc, + local_types_acc ) + | Wl_top_funcdef + { + fun_binder; + decl_params; + params_loc; + is_pub; + doc; + attrs; + decl_body; + loc_; + id; + kind; + arity; + tvar_env; + constraint_names; + typed_fn_annotation; + } -> ( + let local_diagnostics = Local_diagnostics.make ~base:loc_ in + let binder : Typedtree.binder = + { binder_id = Ident.of_qual_ident id; loc_ = fun_binder.loc_ } + in + match decl_body with + | Decl_stubs func_stubs -> + let is_import_stub, language = + match func_stubs with + | Import _ -> (true, None) + | Embedded { language; _ } -> (false, language) + in + let ({ + params_ty; + ret_ty = _; + err_ty = _; + is_async = _; + ret_annotation; + } + : Local_typing_worklist.typed_fn_annotation) = + typed_fn_annotation + in + let stub_body : Typedtree.stub_body = + if Syntax_util.is_intrinsic func_stubs then Intrinsic + else + let language = + Option.map (fun s -> s.Literal.string_val) language + in + let check_type ~allow_func ty = + store_error ~diagnostics:local_diagnostics + (Typeutil.check_stub_type ~language ty global_env ~allow_func + ~is_import_stub) + in + Lst.iter params_ty ~f:(fun (_, ty_opt) -> + match ty_opt with + | Some ty -> check_type ~allow_func:true ty + | None -> ()); + (match ret_annotation with + | Annotated (ret_annot, _) -> + check_type ~allow_func:false ret_annot + | No_annotation | Has_super_error _ -> ()); + let func_stubs = + Parsing_partial_info.take_info ~diagnostics + (Stub_type.from_syntax func_stubs ~loc:loc_ ~diagnostics) + in + Func_stub func_stubs + in + let cenv = Poly_type.make () in + let _, params = + check_function_params Local_env.empty decl_params params_ty + ~is_global:true ~tvar_env ~cenv ~global_env + ~diagnostics:local_diagnostics + in + Lst.iter params ~f:(fun p -> + match p with + | Discard_positional_param _ -> () + | Param { kind; _ } -> ( + match kind with + | Optional default -> + Type_lint.type_lint default + ~diagnostics:local_diagnostics + | Positional | Labelled | Autofill | Question_optional -> ())); + Type_constraint.solve_constraints cenv ~tvar_env ~global_env + ~diagnostics:local_diagnostics; + let ret = + match ret_annotation with + | Annotated (ret, _) -> Some ret + | Has_super_error _ | No_annotation -> None + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + ( Timpl_stub_decl + { + binder; + params; + ret; + func_stubs = stub_body; + is_pub; + arity_ = arity; + kind_ = kind; + loc_; + doc_ = doc; + } + :: impls_acc, + local_types_acc ) + | Decl_body { expr = decl_body; local_types } -> + let cenv = Poly_type.make () in + let is_in_test = + String.starts_with ~prefix:"__test_" fun_binder.binder_name + in + let is_impl_method = + match id with + | Qext_method _ -> true + | Qregular _ | Qmethod _ | Qregular_implicit_pkg _ -> false + in + if local_type_env = None then + Global_env.add_new_local_type_env global_env id loc_; + let local_types_tast, derive_tasks = + Typeutil.typing_local_type local_types id ~global_env ~tvar_env + ~base:loc_ ~diagnostics:local_diagnostics + in + let derived_impls = + Lst.concat_map derive_tasks + (fun { decl; directive; trait_path; type_path } -> + let trait_name = directive.type_name_ in + match + Type_path.Hash.find_opt Ast_derive.derivers trait_path + with + | Some derivers -> + Lst.concat_map derivers (fun (method_name, deriver) -> + let ast = + derive_by_ast ~type_path ~trait_path ~global_env + directive decl method_name ~deriver + ~diagnostics:local_diagnostics + in + fst + (typing_worklist_item ast ~global_env ~diagnostics + ~impls_acc:[] ~local_types_acc:[] + ~local_type_env: + (Global_env.get_cur_local_type_env global_env))) + | None -> + Local_diagnostics.add_error local_diagnostics + (Errors.derive_unsupported_trait ~tycon:type_path + ~trait:trait_name.name ~loc:trait_name.loc_); + []) + in + let tfuns, _ = + check_function ~is_impl_method Local_env.empty decl_params + params_loc decl_body typed_fn_annotation ~kind_:Lambda + ~is_global:true ~is_in_test ~tvar_env ~cenv ~global_env + ~diagnostics:local_diagnostics + in + if local_type_env = None then + Global_env.clear_cur_local_type_env global_env; + Type_lint.type_lint_fn tfuns ~diagnostics:local_diagnostics; + Type_constraint.solve_constraints cenv ~tvar_env ~global_env + ~diagnostics:local_diagnostics; + Local_diagnostics.add_to_global local_diagnostics diagnostics; + ( Timpl_fun_decl + { + fun_decl = + { + kind; + fn_binder = binder; + fn = tfuns; + is_pub; + ty_params_ = tvar_env; + doc_ = doc; + attrs; + constraint_names; + }; + arity_ = arity; + loc_; + is_generated_ = false; + } + :: (derived_impls @ impls_acc), + local_types_tast @ local_types_acc )) + | Wl_derive { ty_decl; syn_decl; trait_path; directive } -> ( + let local_diagnostics = Local_diagnostics.make ~base:syn_decl.loc_ in + match Type_path.Hash.find_opt Ast_derive.derivers trait_path with + | Some derivers -> + let type_path = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + syn_decl.tycon + in + let derived_impls = + Lst.fold_right derivers impls_acc (fun (method_name, deriver) -> + fun impls_acc -> + fst + (typing_worklist_item ~impls_acc ~local_types_acc:[] + ~global_env ~diagnostics ~local_type_env:None + (derive_by_ast ~type_path ~global_env directive syn_decl + method_name ~trait_path ~deriver + ~diagnostics:local_diagnostics))) + in + Local_diagnostics.add_to_global local_diagnostics diagnostics; + (derived_impls, local_types_acc) + | None -> + Local_diagnostics.add_error local_diagnostics + (Errors.derive_unsupported_trait ~tycon:ty_decl.ty_constr + ~trait:directive.type_name_.name ~loc:directive.loc_); + Local_diagnostics.add_to_global local_diagnostics diagnostics; + (impls_acc, local_types_acc)) + : Typedtree.impls * Typedtree.type_decl list) -let type_check ~diagnostics (input : Toplevel_typer.output) : Typedtree.output = - let global_env = input.global_env in - let value_defs = - Vec.fold_right input.values [] ~f:(fun item acc -> - typing_worklist_item ~global_env ~diagnostics item ~acc) - in - Typedtree.Output - { value_defs; type_defs = input.type_decls; trait_defs = input.trait_decls } +let type_check ~diagnostics (input : Local_typing_worklist.t) = + (let global_env = input.global_env in + let value_defs, local_types = + Vec.fold_right input.values ([], []) ~f:(fun item -> + fun (impls_acc, local_types_acc) -> + typing_worklist_item ~global_env ~diagnostics item ~impls_acc + ~local_types_acc ~local_type_env:None) + in + Typedtree.Output + { + value_defs = input.const_decls @ value_defs; + type_defs = local_types @ input.type_decls; + trait_defs = input.trait_decls; + trait_alias = input.trait_alias; + } + : Typedtree.output) diff --git a/src/typeutil.ml b/src/typeutil.ml index 5c4f27e..54ff11f 100644 --- a/src/typeutil.ml +++ b/src/typeutil.ml @@ -17,6 +17,7 @@ type typ = Stype.t module Ident = Basic_ident module Lst = Basic_lst +module Vec = Basic_vec module Hashset_string = Basic_hashset_string module Longident = Basic_longident module Type_path = Basic_type_path @@ -24,6 +25,7 @@ module Syntax = Parsing_syntax module UInt32 = Basic_uint32 module UInt64 = Basic_uint64 module Bigint = Basic_bigint +module Constr_info = Basic_constr_info type build_context = Exec of { is_main_loc : Loc.t } | Lib | SingleFile @@ -45,7 +47,12 @@ let type_of_constant (c : Syntax.constant) = let unknown_tag : Typedtree.constr_tag = Constr_tag_regular - { total = -1; index = -1; name_ = ""; is_constant_ = false } + { + total = Constr_info.Index_set.empty; + index = -1; + name_ = ""; + repr_ = Non_constant; + } let unknown_pos : int = -1 let default_err_type = Stype.error @@ -60,77 +67,81 @@ let default_err_typedtree_type = loc_ = Loc.no_location; } -let typing_type ~(is_toplevel : bool) ~(allow_private : bool) +let typing_type ~(allow_partial : bool) ~(allow_private : bool) ?(placeholder_env : Placeholder_env.t option) (te : Syntax.typ) - ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) : - Typedtree.typ Local_diagnostics.partial_info = - let errors = ref [] in - let check_arity ~kind id expected ~loc - (tys : [ `Wildcard | `Fixed of Stype.t list ]) = - match tys with - | `Wildcard -> - if expected = 0 then - errors := - Errors.type_constr_arity_mismatch ~kind ~id ~expected ~actual:1 ~loc - :: !errors; - if is_toplevel then List.init expected (fun _ -> Stype.blackhole) - else Type.type_var_list expected Tvar_normal - | `Fixed tys -> - let actual = List.length tys in - if expected <> actual then - errors := - Errors.type_constr_arity_mismatch ~kind ~id ~expected ~actual ~loc - :: !errors; - if expected = actual then tys - else if expected < actual then Lst.take expected tys - else if is_toplevel then - tys @ List.init (expected - actual) (fun _ -> Stype.blackhole) - else tys @ Type.type_var_list (expected - actual) Tvar_error - [@@inline] - in - let rec go (te : Syntax.typ) : typ * Typedtree.typ * bool = - match te with - | Ptype_any { loc_ } -> - if is_toplevel then - errors := Errors.unexpected_partial_type loc_ :: !errors; - let ty = - if is_toplevel then Stype.blackhole - else Stype.new_type_var Tvar_normal - in - (ty, Tany { ty; loc_ }, false) - | Ptype_arrow { ty_arg; ty_res; ty_err; loc_ } -> - let params_ty, params, params_is_generic = go_list ty_arg in - let ret_ty, return, ret_is_generic = go ty_res in - let err_ty, err, err_is_generic = - match ty_err with - | Error_typ { ty = ty_err } -> - let err_ty, err, err_is_generic = go ty_err in - if not (Type.is_error_type ~tvar_env err_ty) then - errors := - Errors.not_error_subtype (Printer.type_to_string err_ty) loc_ - :: !errors; - (Some err_ty, Typedtree.Error_typ { ty = err }, err_is_generic) - | Default_error_typ { loc_ } -> - (Some default_err_type, Default_error_typ { loc_ }, false) - | No_error_typ -> (None, No_error_typ, false) - in - let generic_ = params_is_generic || ret_is_generic || err_is_generic in - let ty : Stype.t = Tarrow { params_ty; ret_ty; err_ty; generic_ } in - (ty, Tarrow { ty; params; return; err_ty = err; loc_ }, generic_) - | Ptype_name { constr_id; tys; loc_ } -> ( - let tys, params, generic_ = go_list tys in - let make_typ ty ~is_alias ~generic_ = - ( ty, - Typedtree.Tname - { ty; constr = constr_id; params; is_alias_ = is_alias; loc_ }, - generic_ ) - [@@inline] - in - let tys = - match params with Tany _ :: [] -> `Wildcard | _ -> `Fixed tys - in - match constr_id.lid with - | Lident id -> ( + ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) + ~(local_type_env : Local_type.env option) + ~(diagnostics : Local_diagnostics.t) = + (let add_error err = Local_diagnostics.add_error diagnostics err [@@inline] in + let check_arity ~kind id expected ~loc + (tys : [ `Wildcard | `Fixed of Stype.t list ]) = + match tys with + | `Wildcard -> + if expected = 0 then + add_error + (Errors.type_constr_arity_mismatch ~kind ~id ~expected ~actual:1 + ~loc); + if allow_partial then Type.type_var_list expected Tvar_normal + else List.init expected (fun _ -> Stype.blackhole) + | `Fixed tys -> + let actual = List.length tys in + if expected <> actual then + add_error + (Errors.type_constr_arity_mismatch ~kind ~id ~expected ~actual ~loc); + if expected = actual then tys + else if expected < actual then Lst.take tys expected + else if allow_partial then + tys @ Type.type_var_list (expected - actual) Tvar_error + else tys @ List.init (expected - actual) (fun _ -> Stype.blackhole) + [@@inline] + in + let rec go (te : Syntax.typ) = + (match te with + | Ptype_any { loc_ } -> + if not allow_partial then + add_error (Errors.unexpected_partial_type loc_); + let ty = + if allow_partial then Stype.new_type_var Tvar_normal + else Stype.blackhole + in + (ty, Tany { ty; loc_ }, false) + | Ptype_arrow { ty_arg; ty_res; ty_err; is_async; loc_ } -> + let params_ty, params, params_is_generic = go_list ty_arg in + let ret_ty, return, ret_is_generic = go ty_res in + let err_ty, err, err_is_generic = + match ty_err with + | Error_typ { ty = ty_err } -> + let err_ty, err, err_is_generic = go ty_err in + if not (Type.is_error_type ~tvar_env err_ty) then + add_error + (Errors.not_error_subtype + (Printer.type_to_string err_ty) + loc_); + (Some err_ty, Typedtree.Error_typ { ty = err }, err_is_generic) + | Default_error_typ { loc_ } -> + (Some default_err_type, Default_error_typ { loc_ }, false) + | No_error_typ -> (None, No_error_typ, false) + in + let generic_ = + params_is_generic || ret_is_generic || err_is_generic + in + let ty : Stype.t = + Tarrow { params_ty; ret_ty; err_ty; is_async; generic_ } + in + (ty, Tarrow { ty; params; return; err_ty = err; loc_ }, generic_) + | Ptype_name { constr_id; tys; loc_ } -> ( + let tys, params, generic_ = go_list tys in + let make_typ ty ~is_alias ~generic_ = + ( ty, + Typedtree.Tname + { ty; constr = constr_id; params; is_alias_ = is_alias; loc_ }, + generic_ ) + [@@inline] + in + let tys = + match params with Tany _ :: [] -> `Wildcard | _ -> `Fixed tys + in + let find_tvar_env id = match Tvar_env.find_by_name tvar_env id with | Some tvar_info -> let _ = @@ -140,438 +151,463 @@ let typing_type ~(is_toplevel : bool) ~(allow_private : bool) make_typ ~generic_:true ~is_alias:false tvar_info.typ | None -> let ty, is_alias = go_constr ~generic_ constr_id.lid tys loc_ in - make_typ ~generic_ ~is_alias ty) - | _ -> - let ty, is_alias = go_constr ~generic_ constr_id.lid tys loc_ in - make_typ ~generic_ ~is_alias ty) - | Ptype_tuple { tys; loc_ } -> - let tys, params, generic_ = go_list tys in - let ty : Stype.t = - T_constr - { - type_constructor = Type_path.tuple (List.length tys); - tys; - generic_; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - (ty, T_tuple { ty; params; loc_ }, generic_) - | Ptype_option { ty; loc_; question_loc } -> - let tys, params, generic_ = go_list [ ty ] in - let ty : Stype.t = - T_constr - { - type_constructor = Type_path.Builtin.type_path_option; - tys; - generic_; - only_tag_enum_ = false; - is_suberror_ = false; - } - in - ( ty, - Tname - { - params; - ty; - loc_; - constr = { lid = Lident "Option"; loc_ = question_loc }; - is_alias_ = false; - }, - generic_ ) - and go_list tys = - match tys with - | [] -> ([], [], false) - | ty :: tys -> - let sty, typ, ty_is_generic = go ty in - let stys, typs, tys_is_generic = go_list tys in - (sty :: stys, typ :: typs, ty_is_generic || tys_is_generic) - and go_constr ~generic_ (constr_id : Longident.t) tys (loc_ : Loc.t) : - Stype.t * bool = - let exception - Found_type of { - arity : int; - type_constructor : Type_path.t; - only_tag_enum_ : bool; - is_private : bool; - is_suberror_ : bool; - } - in - let exception Found_predef of Stype.t in - let exception - Found_trait of { - trait : Type_path.t; - is_private : bool; - object_safety_status : Trait_decl.object_safety_status; - } - in - let exception Found_alias of Typedecl_info.alias in - try - (match Global_env.All_types.find_type_alias types constr_id with - | None -> () - | Some alias -> raise_notrace (Found_alias alias)); - (match (placeholder_env, constr_id) with - | Some placeholder_env, Lident name -> ( - match Placeholder_env.find_type_opt placeholder_env name with - | Some decl -> - let type_constructor = - Type_path.toplevel_type - ~pkg:!Basic_config.current_package - decl.tycon - in - let only_tag_enum_ = - match decl.components with - | Ptd_variant cs -> - Lst.for_all cs (fun { constr_args; _ } -> - constr_args = None) - | _ -> false - in - let is_suberror_ = - match decl.components with Ptd_error _ -> true | _ -> false - in - let arity = List.length decl.params in - raise_notrace - (Found_type - { - arity; - type_constructor; - only_tag_enum_; - is_private = - (match decl.type_vis with - | Vis_priv _ -> true - | _ -> false); - is_suberror_; - }) - | None -> ( - match Placeholder_env.find_trait_opt placeholder_env name with - | Some { decl = { trait_vis; _ }; object_safety_status; _ } -> - let trait = - Type_path.toplevel_type - ~pkg:!Basic_config.current_package - name + make_typ ~generic_ ~is_alias ty + [@@inline] + in + match (local_type_env, constr_id.lid) with + | Some local_type_env, Lident name -> ( + match Local_type.find_type local_type_env name with + | Some { name; toplevel_id; _ } -> + let ty : Stype.t = + T_constr + { + type_constructor = Type_path.local_type toplevel_id name; + tys = Tvar_env.get_types tvar_env; + generic_ = false; + is_suberror_ = false; + } in - let is_private = - match trait_vis with Vis_priv _ -> true | _ -> false + let _ = + check_arity ~kind:"type constructor" constr_id.lid 0 tys + ~loc:loc_ in - raise_notrace - (Found_trait { trait; is_private; object_safety_status }) - | None -> ())) - | _ -> ()); - (match - Global_env.All_types.find_type_or_trait types constr_id ~loc:loc_ - with - | `Type - { - ty_arity; - ty_constr; - ty_is_only_tag_enum_; - ty_vis; - ty_is_suberror_; - _; - } -> - raise_notrace - (Found_type - { - arity = ty_arity; - type_constructor = ty_constr; - only_tag_enum_ = ty_is_only_tag_enum_; - is_private = ty_vis = Vis_priv; - is_suberror_ = ty_is_suberror_; - }) - | `Trait trait_decl -> - raise_notrace - (Found_trait - { - trait = trait_decl.name; - is_private = trait_decl.vis_ = Vis_priv; - object_safety_status = trait_decl.object_safety_; - }) - | `Error _ -> ()); - (match constr_id with - | Lident "Unit" -> raise_notrace (Found_predef Stype.unit) - | Lident "Bool" -> raise_notrace (Found_predef Stype.bool) - | Lident "Byte" -> raise_notrace (Found_predef Stype.byte) - | Lident "Char" -> raise_notrace (Found_predef Stype.char) - | Lident "Int" -> raise_notrace (Found_predef Stype.int) - | Lident "Int64" -> raise_notrace (Found_predef Stype.int64) - | Lident "UInt" -> raise_notrace (Found_predef Stype.uint) - | Lident "UInt64" -> raise_notrace (Found_predef Stype.uint64) - | Lident "Float" -> raise_notrace (Found_predef Stype.float) - | Lident "Double" -> raise_notrace (Found_predef Stype.double) - | Lident "String" -> raise_notrace (Found_predef Stype.string) - | Lident "Bytes" -> raise_notrace (Found_predef Stype.bytes) - | _ -> ()); - let error_message = - match constr_id with - | Ldot { pkg; id = _ } - when Option.is_none - (Pkg.find_pkg_opt - (Global_env.All_types.get_pkg_tbl types) - ~pkg) -> - Errors.pkg_not_loaded ~pkg ~loc:loc_ - | _ -> Errors.unbound_type ~name:constr_id ~loc:loc_ - in - errors := error_message :: !errors; - ( (if is_toplevel then Stype.blackhole else Stype.new_type_var Tvar_error), - false ) - with - | Found_type - { arity; type_constructor; only_tag_enum_; is_private; is_suberror_ } -> - if (not allow_private) && is_private then - errors := - Errors.cannot_depend_private ~entity:"type" ~loc:loc_ :: !errors; - let tys = - check_arity ~kind:"type constructor" constr_id arity tys ~loc:loc_ - in - ( T_constr - { type_constructor; tys; generic_; only_tag_enum_; is_suberror_ }, - false ) - | Found_predef ty -> - let _ = - check_arity ~kind:"type constructor" constr_id 0 tys ~loc:loc_ - in - (ty, false) - | Found_trait { trait; is_private; object_safety_status } -> - if (not allow_private) && is_private then - errors := - Errors.cannot_depend_private ~entity:"trait" ~loc:loc_ :: !errors; - let _ = check_arity ~kind:"trait" constr_id 0 tys ~loc:loc_ in - (match - Trait_decl.check_object_safety - ~name:(Type_path_util.name trait) - ~loc:loc_ object_safety_status - with - | None -> () - | Some err -> errors := err :: !errors); - (T_trait trait, false) - | Found_alias ({ arity; _ } as alias) -> - let tys = - check_arity ~kind:"type alias" constr_id arity tys ~loc:loc_ - in - let exception Alias_mentions_priv_type of Type_path.t in - let rec check_priv (ty : Stype.t) = - let check_path (p : Type_path.t) = - match p with - | Toplevel { pkg; id } when pkg = !Basic_config.current_package -> ( - match placeholder_env with - | Some placeholder_env -> ( - match Placeholder_env.find_type_opt placeholder_env id with - | None -> () - | Some decl -> ( - match decl.type_vis with - | Vis_priv _ -> - raise_notrace (Alias_mentions_priv_type p) - | Vis_pub _ | Vis_default -> ())) - | None -> ( - match Global_env.All_types.find_type_by_path types p with - | None -> () - | Some decl -> - if decl.ty_vis = Vis_priv then - raise_notrace (Alias_mentions_priv_type p))) - | _ -> () + make_typ ~generic_:false ~is_alias:false ty + | None -> find_tvar_env name) + | None, Lident id -> find_tvar_env id + | _ -> + let ty, is_alias = go_constr ~generic_ constr_id.lid tys loc_ in + make_typ ~generic_ ~is_alias ty) + | Ptype_tuple { tys; loc_ } -> + let tys, params, generic_ = go_list tys in + let ty : Stype.t = + T_constr + { + type_constructor = Type_path.tuple (List.length tys); + tys; + generic_; + is_suberror_ = false; + } + in + (ty, T_tuple { ty; params; loc_ }, generic_) + | Ptype_option { ty; loc_; question_loc } -> + let tys, params, generic_ = go_list [ ty ] in + let ty : Stype.t = + T_constr + { + type_constructor = Type_path.Builtin.type_path_option; + tys; + generic_; + is_suberror_ = false; + } + in + ( ty, + Tname + { + params; + ty; + loc_; + constr = { lid = Lident "Option"; loc_ = question_loc }; + is_alias_ = false; + }, + generic_ ) + | Ptype_object ({ lid; loc_ } as constr) -> ( + let check_object_safety ~name object_safety = + match + Trait_decl.check_object_safety ~name:(Type_path_util.name name) + ~loc:loc_ object_safety + with + | Some err -> add_error err + | None -> () [@@inline] in - match Stype.type_repr ty with - | T_constr { type_constructor = p; tys } -> - check_path p; - Lst.iter tys check_priv - | T_trait trait -> check_path trait - | Tarrow { params_ty; ret_ty; err_ty } -> ( - Lst.iter params_ty check_priv; - check_priv ret_ty; - match err_ty with None -> () | Some err_ty -> check_priv err_ty) - | Tvar _ | Tparam _ | T_blackhole | T_builtin _ -> () - in - (match constr_id with - | Lident name -> ( - if (not allow_private) && not alias.is_pub then - try check_priv alias.alias - with Alias_mentions_priv_type p -> - errors := - Errors.alias_with_priv_target_in_pub_sig ~alias:name - ~priv_type:(Type_path_util.name p) ~loc:loc_ - :: !errors) - | Ldot _ -> ()); - (Poly_type.instantiate_alias alias tys, true) - in - let _, typ, _ = go te in - match !errors with [] -> Ok typ | errs -> Partial (typ, errs) + match Global_env.All_types.find_type_alias types lid with + | Some { target = Trait_alias { trait }; _ } -> + (match Global_env.All_types.find_trait_by_path types trait with + | Some decl -> check_object_safety ~name:trait decl.object_safety_ + | None -> ()); + let ty : Stype.t = T_trait trait in + (ty, Tobject { constr; ty; is_alias_ = true; loc_ }, false) + | Some { target = Type_alias _; name; _ } -> + add_error (Errors.not_a_trait ~name ~loc:loc_); + (Stype.blackhole, Tany { ty = Stype.blackhole; loc_ }, false) + | None -> ( + let resolve_in_types () = + (match Global_env.All_types.find_trait types lid ~loc:loc_ with + | Ok { name; object_safety_; _ } -> + check_object_safety ~name object_safety_; + let ty : Stype.t = T_trait name in + (ty, Tobject { constr; ty; is_alias_ = false; loc_ }, false) + | Error err -> + add_error err; + ( Stype.blackhole, + Tany { ty = Stype.blackhole; loc_ }, + false ) + : Stype.t * Typedtree.typ * bool) + [@@local] + in + match (lid, placeholder_env) with + | Lident name, Some placeholder_env -> ( + match Placeholder_env.find_trait_opt placeholder_env name with + | None -> resolve_in_types () + | Some decl -> + let name = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + decl.trait_name.binder_name + in + let ty : Stype.t = T_trait name in + ( ty, + Tobject { constr; ty; is_alias_ = false; loc_ }, + false )) + | _ -> resolve_in_types ())) + : typ * Typedtree.typ * bool) + and go_list tys = + match tys with + | [] -> ([], [], false) + | ty :: tys -> + let sty, typ, ty_is_generic = go ty in + let stys, typs, tys_is_generic = go_list tys in + (sty :: stys, typ :: typs, ty_is_generic || tys_is_generic) + and go_constr ~generic_ (constr_id : Longident.t) tys (loc_ : Loc.t) = + (let exception + Found_type of { + arity : int; + type_constructor : Type_path.t; + is_private : bool; + is_suberror_ : bool; + } + in + let exception Found_predef of Stype.t in + let exception Found_alias of Type_alias.t in + try + (match Global_env.All_types.find_type_alias types constr_id with + | Some ({ target = Type_alias _; _ } as alias) -> + raise_notrace (Found_alias alias) + | None | Some { target = Trait_alias _; _ } -> ()); + (match (placeholder_env, constr_id) with + | Some placeholder_env, Lident name -> ( + match Placeholder_env.find_type_opt placeholder_env name with + | Some decl -> + let type_constructor = + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + decl.tycon + in + let is_suberror_ = + match decl.components with Ptd_error _ -> true | _ -> false + in + let arity = List.length decl.params in + raise_notrace + (Found_type + { + arity; + type_constructor; + is_private = + (match decl.type_vis with + | Vis_priv _ -> true + | _ -> false); + is_suberror_; + }) + | None -> ()) + | _ -> ()); + match + Global_env.All_types.find_type_or_trait types constr_id ~loc:loc_ + with + | `Type { ty_arity; ty_constr; ty_vis; ty_is_suberror_; _ } -> + raise_notrace + (Found_type + { + arity = ty_arity; + type_constructor = ty_constr; + is_private = ty_vis = Vis_priv; + is_suberror_ = ty_is_suberror_; + }) + | `Predef ty -> raise_notrace (Found_predef ty) + | `Trait _ -> + add_error + (Errors.not_a_type + ~name:(Longident.to_string constr_id) + ~loc:loc_); + ( (if allow_partial then Stype.new_type_var Tvar_error + else Stype.blackhole), + false ) + | `Error error_message -> + add_error error_message; + ( (if allow_partial then Stype.new_type_var Tvar_error + else Stype.blackhole), + false ) + with + | Found_type { arity; type_constructor; is_private; is_suberror_ } -> + if (not allow_private) && is_private then + add_error (Errors.cannot_depend_private ~entity:"type" ~loc:loc_); + let tys = + check_arity ~kind:"type constructor" constr_id arity tys ~loc:loc_ + in + (T_constr { type_constructor; tys; generic_; is_suberror_ }, false) + | Found_predef ty -> + let _ = + check_arity ~kind:"type constructor" constr_id 0 tys ~loc:loc_ + in + (ty, false) + | Found_alias ({ arity; _ } as alias) -> + let tys = + check_arity ~kind:"type alias" constr_id arity tys ~loc:loc_ + in + let exception Alias_mentions_priv_type of Type_path.t in + let rec check_priv (ty : Stype.t) = + let check_path (p : Type_path.t) = + match p with + | Toplevel { pkg; id } when pkg = !Basic_config.current_package + -> ( + match placeholder_env with + | Some placeholder_env -> ( + match + Placeholder_env.find_type_opt placeholder_env id + with + | None -> () + | Some decl -> ( + match decl.type_vis with + | Vis_priv _ -> + raise_notrace (Alias_mentions_priv_type p) + | Vis_pub _ | Vis_default -> ())) + | None -> ( + match Global_env.All_types.find_type_by_path types p with + | None -> () + | Some decl -> + if decl.ty_vis = Vis_priv then + raise_notrace (Alias_mentions_priv_type p))) + | _ -> () + [@@inline] + in + match Stype.type_repr ty with + | T_constr { type_constructor = p; tys } -> + check_path p; + Lst.iter tys ~f:check_priv + | T_trait trait -> check_path trait + | Tarrow { params_ty; ret_ty; err_ty; is_async = _ } -> ( + Lst.iter params_ty ~f:check_priv; + check_priv ret_ty; + match err_ty with + | None -> () + | Some err_ty -> check_priv err_ty) + | Tvar _ | Tparam _ | T_blackhole | T_builtin _ -> () + in + (match constr_id with + | Lident name -> ( + if (not allow_private) && not alias.is_pub then + match[@warning "-fragile-match"] alias.target with + | Type_alias ty -> ( + try check_priv ty + with Alias_mentions_priv_type p -> + add_error + (Errors.alias_with_priv_target_in_pub_sig ~alias:name + ~priv_type:(Type_path_util.name p) ~loc:loc_)) + | _ -> assert false) + | Ldot _ -> ()); + (Poly_type.instantiate_alias alias tys, true) + : Stype.t * bool) + in + let _, typ, _ = go te in + typ + : Typedtree.typ) type type_name = | Tname_param of { index : int; name_ : string } | Tname_predef of Type_path.t | Tname_defined of Typedecl_info.t | Tname_trait of Trait_decl.t + | Tname_local_type of Local_type.t + | Tname_trait_object of Trait_decl.t -let typing_type_name ~(allow_private : bool) (type_name : Syntax.type_name) - ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) : - (type_name * Typedtree.type_name) option Local_diagnostics.partial_info = - let loc = type_name.loc_ in - let resolve_as_constr () : _ Local_diagnostics.partial_info = - match Global_env.All_types.find_type_or_trait types type_name.name ~loc with - | `Type ty_decl -> - let type_name : Typedtree.type_name = - Tname_path - { name = ty_decl.ty_constr; kind = Type; loc_ = type_name.loc_ } - in - let result = Some (Tname_defined ty_decl, type_name) in - if (not allow_private) && ty_decl.ty_vis = Vis_priv then - Partial (result, [ Errors.cannot_depend_private ~entity:"type" ~loc ]) - else Ok result - | `Trait trait -> - let type_name : Typedtree.type_name = - Tname_path { name = trait.name; kind = Trait; loc_ = type_name.loc_ } - in - let result = Some (Tname_trait trait, type_name) in - if (not allow_private) && trait.vis_ = Vis_priv then - Partial (result, [ Errors.cannot_depend_private ~entity:"trait" ~loc ]) - else Ok result - | `Error err -> ( - let resolve_as_predef p : _ Local_diagnostics.partial_info = - let type_name : Typedtree.type_name = - Tname_path { name = p; kind = Type; loc_ = type_name.loc_ } - in - Ok (Some (Tname_predef p, type_name)) - [@@inline] - in - match type_name.name with - | Lident "Unit" -> resolve_as_predef Type_path.Builtin.type_path_unit - | Lident "Bool" -> resolve_as_predef Type_path.Builtin.type_path_bool - | Lident "Byte" -> resolve_as_predef Type_path.Builtin.type_path_byte - | Lident "Char" -> resolve_as_predef Type_path.Builtin.type_path_char - | Lident "Int" -> resolve_as_predef Type_path.Builtin.type_path_int - | Lident "Int64" -> resolve_as_predef Type_path.Builtin.type_path_int64 - | Lident "UInt" -> resolve_as_predef Type_path.Builtin.type_path_uint - | Lident "UInt64" -> - resolve_as_predef Type_path.Builtin.type_path_uint64 - | Lident "Float" -> resolve_as_predef Type_path.Builtin.type_path_float - | Lident "Double" -> - resolve_as_predef Type_path.Builtin.type_path_double - | Lident "String" -> - resolve_as_predef Type_path.Builtin.type_path_string - | Lident "Bytes" -> resolve_as_predef Type_path.Builtin.type_path_bytes - | _ -> Partial (None, [ err ])) - in - match Global_env.All_types.find_type_alias types type_name.name with - | Some alias -> ( - match Stype.type_repr alias.alias with - | T_constr { type_constructor = p; _ } -> ( - match Global_env.All_types.find_type_by_path types p with - | Some decl -> - let type_name : Typedtree.type_name = - Tname_alias - { - name = p; - kind = Type; - alias_ = type_name.name; - loc_ = type_name.loc_; - } - in - let result = Some (Tname_defined decl, type_name) in - if (not allow_private) && decl.ty_vis = Vis_priv then - Partial - (result, [ Errors.cannot_depend_private ~entity:"type" ~loc ]) - else Ok result - | None -> Ok None) - | T_builtin predef -> - let p = Stype.tpath_of_builtin predef in - Ok - (Some - ( Tname_predef p, - Tname_alias +let typing_type_name_not_object ~(allow_private : bool) + (type_name : Syntax.type_name) ~(tvar_env : Tvar_env.t) + ~(types : Global_env.All_types.t) ~(local_type_env : Local_type.env option) + ~(diagnostics : Local_diagnostics.t) = + (let loc = type_name.loc_ in + let resolve_as_constr () = + match + Global_env.All_types.find_type_or_trait types type_name.name ~loc + with + | `Type ty_decl -> + let type_name : Typedtree.type_name = + Tname_path + { name = ty_decl.ty_constr; kind = Type; loc_ = type_name.loc_ } + in + if (not allow_private) && ty_decl.ty_vis = Vis_priv then + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"type" ~loc); + Some (Tname_defined ty_decl, type_name) + | `Trait trait -> + let type_name : Typedtree.type_name = + Tname_path { name = trait.name; kind = Trait; loc_ = type_name.loc_ } + in + if (not allow_private) && trait.vis_ = Vis_priv then + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"trait" ~loc); + Some (Tname_trait trait, type_name) + | `Predef ty -> ( + match[@warning "-fragile-match"] ty with + | T_builtin builtin -> + let path = Stype.tpath_of_builtin builtin in + let type_name : Typedtree.type_name = + Tname_path { name = path; kind = Type; loc_ = type_name.loc_ } + in + Some (Tname_predef path, type_name) + | _ -> assert false) + | `Error err -> + Local_diagnostics.add_error diagnostics err; + None + in + let local_type : (type_name * Typedtree.type_name) option = + match (type_name.name, local_type_env) with + | Lident name, Some local_type_env -> ( + match Local_type.find_type local_type_env name with + | Some type_info -> + Some + ( Tname_local_type type_info, + Tname_path { - name = p; + name = Type_path.local_type type_info.toplevel_id name; kind = Type; + loc_ = type_name.loc_; + } ) + | None -> None) + | _ -> None + in + match local_type with + | Some local_type -> Some local_type + | None -> ( + match Global_env.All_types.find_type_alias types type_name.name with + | Some { target = Type_alias alias; _ } -> ( + match Stype.type_repr alias with + | T_constr { type_constructor = Tuple _ as p; _ } -> + Some + ( Tname_predef p, + Tname_alias + { + name = p; + kind = Type; + alias_ = type_name.name; + loc_ = type_name.loc_; + } ) + | T_constr { type_constructor = p; _ } -> ( + match Global_env.All_types.find_type_by_path types p with + | Some decl -> + let type_name : Typedtree.type_name = + Tname_alias + { + name = p; + kind = Type; + alias_ = type_name.name; + loc_ = type_name.loc_; + } + in + if (not allow_private) && decl.ty_vis = Vis_priv then + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"type" ~loc); + Some (Tname_defined decl, type_name) + | None -> None) + | T_builtin predef -> + let p = Stype.tpath_of_builtin predef in + Some + ( Tname_predef p, + Tname_alias + { + name = p; + kind = Type; + alias_ = type_name.name; + loc_ = type_name.loc_; + } ) + | Tarrow _ -> + Local_diagnostics.add_error diagnostics + (Errors.type_alias_not_a_constructor + ~alias_name:(Longident.to_string type_name.name) + ~loc:type_name.loc_); + None + | T_blackhole -> None + | Tparam _ | Tvar _ | T_trait _ -> assert false) + | Some { target = Trait_alias { trait }; _ } -> ( + match Global_env.All_types.find_trait_by_path types trait with + | Some decl -> + let type_name : Typedtree.type_name = + Tname_alias + { + name = trait; + kind = Trait; alias_ = type_name.name; loc_ = type_name.loc_; - } )) - | T_trait trait -> ( - match Global_env.All_types.find_trait_by_path types trait with - | Some decl -> - let type_name : Typedtree.type_name = - Tname_alias - { - name = trait; - kind = Trait; - alias_ = type_name.name; - loc_ = type_name.loc_; - } - in - let result = Some (Tname_trait decl, type_name) in - if (not allow_private) && decl.vis_ = Vis_priv then - Partial - (result, [ Errors.cannot_depend_private ~entity:"trait" ~loc ]) - else Ok result - | None -> Ok None) - | Tarrow _ -> - Partial - ( None, - [ - Errors.type_alias_not_a_constructor - ~alias_name:(Longident.to_string type_name.name) - ~loc:type_name.loc_; - ] ) - | T_blackhole -> Ok None - | Tparam _ | Tvar _ -> assert false) - | None -> ( - match type_name.name with - | Lident name -> ( - match Tvar_env.find_by_name tvar_env name with - | Some tvar_info -> ( - match tvar_info.typ with - | Tparam { index; name_ } -> - let type_name : Typedtree.type_name = - Tname_tvar { index; name_; loc_ = type_name.loc_ } - in - Ok (Some (Tname_param { index; name_ }, type_name)) - | _ -> assert false) - | None -> resolve_as_constr ()) - | Ldot _ -> resolve_as_constr ()) - -let typing_trait_name ~types ~allow_private (trait : Syntax.type_name) : - _ Local_diagnostics.partial_info = - let fallback_type_name () : Typedtree.type_name = - Tname_path - { - name = Type_path.toplevel_type ~pkg:!Basic_config.current_package ""; - kind = Trait; - loc_ = trait.loc_; - } + } + in + if (not allow_private) && decl.vis_ = Vis_priv then + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"trait" ~loc); + Some (Tname_trait decl, type_name) + | None -> None) + | None -> ( + match type_name.name with + | Lident name -> ( + match Tvar_env.find_by_name tvar_env name with + | Some tvar_info -> ( + match tvar_info.typ with + | Tparam { index; name_ } -> + let type_name : Typedtree.type_name = + Tname_tvar { index; name_; loc_ = type_name.loc_ } + in + Some (Tname_param { index; name_ }, type_name) + | _ -> assert false) + | None -> resolve_as_constr ()) + | Ldot _ -> resolve_as_constr ())) + : (type_name * Typedtree.type_name) option) + +let typing_trait_name ~types ~allow_private (trait : Syntax.type_name) + ~diagnostics = + let fallback_type_name () = + (Tname_path + { + name = Type_path.toplevel_type ~pkg:!Basic_config.current_package ""; + kind = Trait; + loc_ = trait.loc_; + } + : Typedtree.type_name) in - let error ?type_name err : _ Local_diagnostics.partial_info = + let error ?type_name err = let type_name = match type_name with | None -> fallback_type_name () | Some type_name -> type_name in - Partial ((None, type_name), [ err ]) + Local_diagnostics.add_error diagnostics err; + (None, type_name) [@@local] in match Global_env.All_types.find_type_alias types trait.name with - | Some alias -> ( - match Stype.type_repr alias.alias with - | T_trait trait_path -> ( - match Global_env.All_types.find_trait_by_path types trait_path with - | None -> Ok (None, fallback_type_name ()) - | Some decl -> - let type_name : Typedtree.type_name = - Tname_alias - { - name = trait_path; - kind = Trait; - alias_ = trait.name; - loc_ = trait.loc_; - } - in - let result = (Some decl, type_name) in - if (not allow_private) && decl.vis_ = Vis_priv then - Partial - ( result, - [ - Errors.cannot_depend_private ~entity:"trait" - ~loc:trait.loc_; - ] ) - else Ok result) + | Some { target = Trait_alias { trait = trait_path }; _ } -> ( + match Global_env.All_types.find_trait_by_path types trait_path with + | None -> (None, fallback_type_name ()) + | Some decl -> + let type_name : Typedtree.type_name = + Tname_alias + { + name = trait_path; + kind = Trait; + alias_ = trait.name; + loc_ = trait.loc_; + } + in + if (not allow_private) && decl.vis_ = Vis_priv then + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"trait" ~loc:trait.loc_) + else if trait.is_object then + Local_diagnostics.add_error diagnostics + (Errors.not_a_trait + ~name: + (("&" ^ Longident.to_string trait.name + : Stdlib.String.t) + [@merlin.hide]) + ~loc:trait.loc_); + (Some decl, type_name)) + | Some { target = Type_alias alias; _ } -> ( + match Stype.type_repr alias with | T_constr { type_constructor = p; _ } -> let type_name : Typedtree.type_name = Tname_alias @@ -594,176 +630,262 @@ let typing_trait_name ~types ~allow_private (trait : Syntax.type_name) : let type_name : Typedtree.type_name = Tname_path { name = decl.name; kind = Trait; loc_ = trait.loc_ } in - let result = (Some decl, type_name) in if (not allow_private) && decl.vis_ = Vis_priv then - Partial - ( result, - [ Errors.cannot_depend_private ~entity:"trait" ~loc:trait.loc_ ] - ) - else Ok result + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"trait" ~loc:trait.loc_) + else if trait.is_object then + Local_diagnostics.add_error diagnostics + (Errors.not_a_trait + ~name: + (("&" ^ Longident.to_string trait.name + : Stdlib.String.t) + [@merlin.hide]) + ~loc:trait.loc_); + (Some decl, type_name) | Error err -> error err) -let typing_type_decl_binders (binders : Syntax.type_decl_binder list) : - Tvar_env.t = - let go index (tvb : Syntax.type_decl_binder) = - let name = - match tvb.tvar_name with Some tvar_name -> tvar_name | None -> "_" - in - let typ : Stype.t = Tparam { index; name_ = name } in - Tvar_env.tparam_info ~name ~typ ~constraints:[] ~loc:tvb.loc_ - in - Tvar_env.of_list_mapi binders go +let typing_type_name ~(allow_private : bool) (type_name : Syntax.type_name) + ~(tvar_env : Tvar_env.t) ~(types : Global_env.All_types.t) + ~(local_type_env : Local_type.env option) ~diagnostics = + (if type_name.is_object then + match + typing_trait_name ~types ~allow_private + { type_name with is_object = false } + ~diagnostics + with + | Some trait_decl, type_name -> + Some (Tname_trait_object trait_decl, type_name) + | None, _ -> None + else + typing_type_name_not_object ~allow_private ~tvar_env ~types ~local_type_env + type_name ~diagnostics + : (type_name * Typedtree.type_name) option) + +let typing_type_decl_binders (binders : Syntax.type_decl_binder list) = + (let go index (tvb : Syntax.type_decl_binder) = + let name = + match tvb.tvar_name with Some tvar_name -> tvar_name | None -> "_" + in + let typ : Stype.t = Tparam { index; name_ = name } in + Tvar_env.tparam_info ~name ~typ ~constraints:[] ~loc:tvb.loc_ + in + Tvar_env.of_list_mapi binders go + : Tvar_env.t) + +let typing_super_traits ~types ~placeholder_env ~allow_private ~self supers + ~diagnostics = + (match supers with + | [] -> ([], [ self ]) + | supers -> + let visited = Type_path.Hashset.create 17 in + let direct_supers = Vec.empty () in + let closure = Vec.empty () in + Type_path.Hashset.add visited self; + Vec.push closure self; + let rec add_super_trait ~is_direct + ({ tvc_trait; loc_ } : Syntax.tvar_constraint) = + match + Placeholder_env.typing_trait_name ~types placeholder_env + { name = tvc_trait; is_object = false; loc_ } + with + | Ok (Local_trait (path, decl), trait_name) -> + if is_direct then ( + Vec.push direct_supers trait_name; + match decl.trait_vis with + | Vis_priv _ when not allow_private -> + Local_diagnostics.add_error diagnostics + (Errors.cannot_depend_private ~entity:"trait" ~loc:loc_) + | _ -> ()); + if not (Type_path.Hashset.mem visited path) then ( + Type_path.Hashset.add visited path; + Vec.push closure path; + Lst.iter decl.trait_supers ~f:(add_super_trait ~is_direct:false)) + | Ok (Foreign_trait decl, trait_name) -> + if is_direct then Vec.push direct_supers trait_name; + Lst.iter decl.closure ~f:(fun path -> + if not (Type_path.Hashset.mem visited path) then ( + Type_path.Hashset.add visited path; + Vec.push closure path)) + | Error err -> Local_diagnostics.add_error diagnostics err + in + Lst.iter supers ~f:(add_super_trait ~is_direct:true); + (Vec.to_list direct_supers, Vec.to_list closure) + : Typedtree.type_name list * Type_path.t list) let typing_func_def_tparam_binders ~(allow_private : bool) - ~(types : Global_env.All_types.t) (binders : Syntax.tvar_binder list) : - Tvar_env.t Local_diagnostics.partial_info = - let errors : Local_diagnostics.report list ref = ref [] in - let go index tvar_name tvar_constraints loc : Tvar_env.tparam_info = - let name = tvar_name in - let typ : Stype.t = Tparam { index; name_ = name } in - let constraints = - Lst.map tvar_constraints (fun tvc : Tvar_env.type_constraint -> - let Syntax.{ tvc_trait; loc_ } = tvc in - match tvc_trait with - | Lident "Error" -> - { - trait = Type_path.Builtin.type_path_error; - loc_; - required_by_ = []; - } - | _ -> ( - let trait_decl = - match - typing_trait_name ~types ~allow_private - { name = tvc_trait; loc_ } - with - | Ok (trait_decl, _) -> trait_decl - | Partial ((trait_decl, _), errs) -> - errors := errs @ !errors; - trait_decl - in - match trait_decl with - | Some trait -> { trait = trait.name; loc_; required_by_ = [] } - | None -> - let trait = - match tvc_trait with - | Lident name -> - Type_path.toplevel_type - ~pkg:!Basic_config.current_package - name - | Ldot { pkg; id } -> Type_path.toplevel_type ~pkg id - in - { trait; loc_; required_by_ = [] })) - in - let constraints = Trait_closure.compute_closure ~types constraints in - Tvar_env.tparam_info ~name ~typ ~constraints ~loc - in - let go_with_constraints index (tvb : Syntax.tvar_binder) = - go index tvb.tvar_name tvb.tvar_constraints tvb.loc_ - in - let tvar_env = Tvar_env.of_list_mapi binders go_with_constraints in - match !errors with [] -> Ok tvar_env | errors -> Partial (tvar_env, errors) - -let typing_constant ~(expect_ty : Stype.t option) (c : Syntax.constant) ~loc : - (Stype.t * Constant.t) Local_diagnostics.partial_info = - let overflow c = [ Errors.overflow ~value:c ~loc ] [@@inline] in - let check_byte_literal v ~repr : - (Stype.t * Constant.t) Local_diagnostics.partial_info = - if v < 0 || v > 255 then - Partial ((Stype.byte, C_int { v = 0l; repr = Some repr }), overflow repr) - else Ok (Stype.byte, C_int { v = Int32.of_int v; repr = Some repr }) - in - match expect_ty with - | None -> ( - match c with - | Const_bool b -> Ok (Stype.bool, C_bool b) - | Const_char lit -> Ok (Stype.char, C_char lit.char_val) - | Const_string lit -> Ok (Stype.string, C_string lit.string_val) - | Const_bytes lit -> - Ok - ( Stype.bytes, - C_bytes { v = lit.bytes_val; repr = Some lit.bytes_repr } ) - | Const_int c -> ( - match Int32.of_string_opt c with - | Some v -> Ok (Stype.int, C_int { v; repr = Some c }) - | None -> - Partial ((Stype.int, C_int { v = 0l; repr = Some c }), overflow c) - ) - | Const_byte c -> check_byte_literal c.byte_val ~repr:c.byte_repr - | Const_uint c -> ( - match UInt32.of_string_opt c with - | Some v -> Ok (Stype.uint, C_uint { v; repr = Some c }) - | None -> - Partial - ( (Stype.uint, C_uint { v = UInt32.min_int; repr = Some c }), - overflow c )) - | Const_int64 c -> ( - match Int64.of_string_opt c with - | Some v -> Ok (Stype.int64, C_int64 { v; repr = Some c }) - | None -> - Partial - ((Stype.int64, C_int64 { v = 0L; repr = Some c }), overflow c)) - | Const_uint64 c -> ( - match UInt64.of_string_opt c with - | Some v -> Ok (Stype.uint64, C_uint64 { v; repr = Some c }) - | None -> - Partial - ( (Stype.uint64, C_uint64 { v = UInt64.min_int; repr = Some c }), - overflow c )) - | Const_bigint c -> - Ok (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) - | Const_double c -> - Ok (Stype.double, C_double { v = float_of_string c; repr = Some c })) - | Some expect_ty -> ( - match (Stype.type_repr expect_ty, c) with - | _, Const_bool b -> Ok (Stype.bool, C_bool b) - | _, Const_char lit -> Ok (Stype.char, C_char lit.char_val) - | _, Const_string lit -> Ok (Stype.string, C_string lit.string_val) - | _, Const_bytes lit -> - Ok - ( Stype.bytes, - C_bytes { v = lit.bytes_val; repr = Some lit.bytes_repr } ) - | T_builtin T_byte, Const_int c -> ( - match int_of_string_opt c with - | Some v -> check_byte_literal v ~repr:c - | None -> - Partial ((Stype.byte, C_int { v = 0l; repr = Some c }), overflow c) - ) - | _, Const_byte c -> check_byte_literal c.byte_val ~repr:c.byte_repr - | T_builtin T_uint, Const_int c | _, Const_uint c -> ( - match UInt32.of_string_opt c with - | Some v -> Ok (Stype.uint, C_uint { v; repr = Some c }) - | None -> - Partial - ( (Stype.uint, C_uint { v = UInt32.min_int; repr = Some c }), - overflow c )) - | T_builtin T_int64, Const_int c | _, Const_int64 c -> ( - match Int64.of_string_opt c with - | Some v -> Ok (Stype.int64, C_int64 { v; repr = Some c }) - | None -> - Partial - ((Stype.int64, C_int64 { v = 0L; repr = Some c }), overflow c)) - | T_builtin T_uint64, Const_int c | _, Const_uint64 c -> ( - match UInt64.of_string_opt c with - | Some v -> Ok (Stype.uint64, C_uint64 { v; repr = Some c }) - | None -> - Partial - ( (Stype.uint64, C_uint64 { v = UInt64.min_int; repr = Some c }), - overflow c )) - | ty, Const_int c when Type.same_type ty Stype.bigint -> - Ok (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) - | _, Const_bigint c -> - Ok (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) - | T_builtin T_float, (Const_double c | Const_int c) -> - Ok (Stype.float, C_float { v = float_of_string c; repr = Some c }) - | T_builtin T_double, Const_int c | _, Const_double c -> - Ok (Stype.double, C_double { v = float_of_string c; repr = Some c }) - | _, Const_int c -> ( - match Int32.of_string_opt c with - | Some v -> Ok (Stype.int, C_int { v; repr = Some c }) - | None -> - Partial ((Stype.int, C_int { v = 0l; repr = Some c }), overflow c) - )) + ~(types : Global_env.All_types.t) (binders : Syntax.tvar_binder list) + ~diagnostics = + (let constraint_names : Typedtree.type_name list ref = ref [] in + let go index tvar_name tvar_constraints loc = + (let name = tvar_name in + let typ : Stype.t = Tparam { index; name_ = name } in + let constraints = + Lst.map tvar_constraints (fun tvc -> + (let Syntax.{ tvc_trait; loc_ } = tvc in + match tvc_trait with + | Lident "Error" -> + { + trait = Type_path.Builtin.type_path_error; + loc_; + src_ = Direct; + } + | _ -> ( + let trait_decl, constraint_name = + typing_trait_name ~types ~allow_private + { name = tvc_trait; is_object = false; loc_ } + ~diagnostics + in + constraint_names := constraint_name :: !constraint_names; + match trait_decl with + | Some trait -> { trait = trait.name; loc_; src_ = Direct } + | None -> + let trait = + match tvc_trait with + | Lident name -> + Type_path.toplevel_type + ~pkg:!Basic_config.current_package + name + | Ldot { pkg; id } -> Type_path.toplevel_type ~pkg id + in + { trait; loc_; src_ = Direct }) + : Tvar_env.type_constraint)) + in + let constraints = Trait_closure.compute_closure ~types constraints in + Tvar_env.tparam_info ~name ~typ ~constraints ~loc + : Tvar_env.tparam_info) + in + let go_with_constraints index (tvb : Syntax.tvar_binder) = + go index tvb.tvar_name tvb.tvar_constraints tvb.loc_ + in + let tvar_env = Tvar_env.of_list_mapi binders go_with_constraints in + (tvar_env, !constraint_names) + : Tvar_env.t * Typedtree.type_name list) + +let typing_constant ~(expect_ty : Stype.t option) (c : Syntax.constant) ~loc + ~diagnostics = + (let overflow c = + Local_diagnostics.add_error diagnostics (Errors.overflow ~value:c ~loc) + [@@inline] + in + let check_byte_literal v ~repr = + (if v < 0 || v > 255 then ( + overflow repr; + (Stype.byte, C_byte { v = 0; repr = Some repr })) + else (Stype.byte, C_byte { v; repr = Some repr }) + : Stype.t * Constant.t) + in + let check_short_literal v ~repr ~signed = + (if signed then + if v < -32768 || v > 32767 then ( + overflow repr; + (Stype.int16, C_int { v = 0l; repr = Some repr })) + else (Stype.int16, C_int { v = Int32.of_int v; repr = Some repr }) + else if v < 0 || v > 65536 then ( + overflow repr; + (Stype.uint16, C_int { v = 0l; repr = Some repr })) + else (Stype.uint16, C_int { v = Int32.of_int v; repr = Some repr }) + : Stype.t * Constant.t) + in + match expect_ty with + | None -> ( + match c with + | Const_bool b -> (Stype.bool, C_bool b) + | Const_char lit -> (Stype.char, C_char lit.char_val) + | Const_string lit -> (Stype.string, C_string lit.string_val) + | Const_bytes lit -> + ( Stype.bytes, + C_bytes { v = lit.bytes_val; repr = Some lit.bytes_repr } ) + | Const_int c -> ( + match Int32.of_string_opt c with + | Some v -> (Stype.int, C_int { v; repr = Some c }) + | None -> + overflow c; + (Stype.int, C_int { v = 0l; repr = Some c })) + | Const_byte c -> check_byte_literal c.byte_val ~repr:c.byte_repr + | Const_uint c -> ( + match UInt32.of_string_opt c with + | Some v -> (Stype.uint, C_uint { v; repr = Some c }) + | None -> + overflow c; + (Stype.uint, C_uint { v = UInt32.min_int; repr = Some c })) + | Const_int64 c -> ( + match Int64.of_string_opt c with + | Some v -> (Stype.int64, C_int64 { v; repr = Some c }) + | None -> + overflow c; + (Stype.int64, C_int64 { v = 0L; repr = Some c })) + | Const_uint64 c -> ( + match UInt64.of_string_opt c with + | Some v -> (Stype.uint64, C_uint64 { v; repr = Some c }) + | None -> + overflow c; + (Stype.uint64, C_uint64 { v = UInt64.min_int; repr = Some c })) + | Const_bigint c -> + (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) + | Const_double c -> + (Stype.double, C_double { v = float_of_string c; repr = Some c })) + | Some expect_ty -> ( + match (Stype.type_repr expect_ty, c) with + | _, Const_bool b -> (Stype.bool, C_bool b) + | _, Const_char lit -> (Stype.char, C_char lit.char_val) + | T_builtin T_bytes, Const_string { string_val; string_repr = _ } -> + (Stype.bytes, C_bytes { v = string_val; repr = Some string_val }) + | _, Const_string lit -> (Stype.string, C_string lit.string_val) + | _, Const_bytes lit -> + ( Stype.bytes, + C_bytes { v = lit.bytes_val; repr = Some lit.bytes_repr } ) + | T_builtin T_byte, Const_int c -> ( + match int_of_string_opt c with + | Some v -> check_byte_literal v ~repr:c + | None -> + overflow c; + (Stype.byte, C_int { v = 0l; repr = Some c })) + | T_builtin T_int16, Const_int c -> ( + match int_of_string_opt c with + | Some v -> check_short_literal v ~repr:c ~signed:true + | None -> + overflow c; + (Stype.int16, C_int { v = 0l; repr = Some c })) + | T_builtin T_uint16, Const_int c -> ( + match int_of_string_opt c with + | Some v -> check_short_literal v ~repr:c ~signed:false + | None -> + overflow c; + (Stype.uint16, C_int { v = 0l; repr = Some c })) + | _, Const_byte c -> check_byte_literal c.byte_val ~repr:c.byte_repr + | T_builtin T_uint, Const_int c | _, Const_uint c -> ( + match UInt32.of_string_opt c with + | Some v -> (Stype.uint, C_uint { v; repr = Some c }) + | None -> + overflow c; + (Stype.uint, C_uint { v = UInt32.min_int; repr = Some c })) + | T_builtin T_int64, Const_int c | _, Const_int64 c -> ( + match Int64.of_string_opt c with + | Some v -> (Stype.int64, C_int64 { v; repr = Some c }) + | None -> + overflow c; + (Stype.int64, C_int64 { v = 0L; repr = Some c })) + | T_builtin T_uint64, Const_int c | _, Const_uint64 c -> ( + match UInt64.of_string_opt c with + | Some v -> (Stype.uint64, C_uint64 { v; repr = Some c }) + | None -> + overflow c; + (Stype.uint64, C_uint64 { v = UInt64.min_int; repr = Some c })) + | ty, Const_int c when Type.same_type ty Stype.bigint -> + (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) + | _, Const_bigint c -> + (Stype.bigint, C_bigint { v = Bigint.of_string c; repr = Some c }) + | T_builtin T_float, (Const_double c | Const_int c) -> + (Stype.float, C_float { v = float_of_string c; repr = Some c }) + | T_builtin T_double, Const_int c | _, Const_double c -> + (Stype.double, C_double { v = float_of_string c; repr = Some c }) + | _, Const_int c -> ( + match Int32.of_string_opt c with + | Some v -> (Stype.int, C_int { v; repr = Some c }) + | None -> + overflow c; + (Stype.int, C_int { v = 0l; repr = Some c }))) + : Stype.t * Constant.t) let typed_constant_to_syntax_constant = function | Constant.C_bool b -> Syntax.Const_bool b @@ -774,6 +896,10 @@ let typed_constant_to_syntax_constant = function match repr with | Some repr -> Const_int repr | None -> Const_int (Int32.to_string v)) + | C_byte { repr; v } -> ( + match repr with + | Some repr -> Const_byte { byte_val = v; byte_repr = repr } + | None -> Const_byte { byte_val = v; byte_repr = Int.to_string v }) | C_int64 { repr; v } -> ( match repr with | Some repr -> Const_int repr @@ -805,182 +931,833 @@ let typed_constant_to_syntax_constant = function type func_type = Method of Syntax.typ option | Regular_func -let classify_func (ps : Syntax.parameters) : func_type = - match ps with - | { - param_binder = { binder_name = "self" }; - param_annot; - param_kind = Positional; - } - :: _ -> - Method param_annot - | _ -> Regular_func +let classify_func (ps : Syntax.parameters) = + (match ps with + | Positional { binder = { binder_name = "self"; _ }; ty } :: _ -> Method ty + | _ -> Regular_func + : func_type) let check_stub_type ~(language : string option) (typ : Typedtree.typ) - (global_env : Global_env.t) ~(allow_func : bool) ~(is_import_stub : bool) : - Local_diagnostics.error_option = - match language with - | Some ("js" | "c" | "C") -> None - | _ -> ( - let loc = Typedtree.loc_of_typ typ in - match Typedtree_util.stype_of_typ typ with - | T_builtin T_unit - | T_builtin T_int - | T_builtin T_bool - | T_builtin T_byte - | T_builtin T_char - | T_builtin T_int64 - | T_builtin T_float - | T_builtin T_double - | T_builtin T_uint - | T_builtin T_uint64 -> - None - | T_builtin T_string -> - if is_import_stub && !Basic_config.target <> Wasm_gc then - Some (Errors.invalid_stub_type loc) - else None - | T_builtin T_bytes -> - if is_import_stub then Some (Errors.invalid_stub_type loc) else None - | T_constr { type_constructor; tys = ty_elem :: [] } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_fixedarray -> ( - if is_import_stub then Some (Errors.invalid_stub_type loc) - else - match language with - | Some "wasm" -> ( - match ty_elem with - | T_builtin _ -> None - | _ -> Some (Errors.invalid_stub_type loc)) - | _ -> ( - match ty_elem with - | T_builtin builtin -> ( - match builtin with - | T_int | T_int64 | T_double -> None - | T_unit | T_byte | T_bytes | T_uint64 | T_string | T_uint - | T_bool | T_char | T_float -> - Some (Errors.invalid_stub_type loc)) - | _ -> Some (Errors.invalid_stub_type loc))) - | T_constr { type_constructor = p; tys = _ } -> ( - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = Extern_type; _ } -> None - | _ -> Some (Errors.invalid_stub_type loc)) - | Tarrow _ when not allow_func -> Some (Errors.invalid_stub_type loc) - | Tarrow { params_ty; ret_ty; err_ty } -> - let is_simple_stub (ty : Stype.t) = - match Stype.type_repr ty with - | T_builtin T_unit - | T_builtin T_int - | T_builtin T_bool - | T_builtin T_byte - | T_builtin T_char - | T_builtin T_int64 - | T_builtin T_uint - | T_builtin T_uint64 - | T_builtin T_float - | T_builtin T_double -> - true - | T_builtin T_string | T_builtin T_bytes -> not is_import_stub - | T_constr { type_constructor; tys = _ } - when Type_path.equal type_constructor - Type_path.Builtin.type_path_fixedarray -> - not is_import_stub - | T_constr { type_constructor = p; tys = _ } -> ( - match Global_env.find_type_by_path global_env p with - | Some { ty_desc = Extern_type; _ } -> true - | _ -> false) - | T_blackhole -> true - | Tarrow _ | Tparam _ | T_trait _ -> false - | Tvar _ -> assert false - [@@inline] - in - if - Lst.for_all params_ty is_simple_stub - && is_simple_stub ret_ty && err_ty = None - then None - else Some (Errors.invalid_stub_type loc) - | Tparam _ | T_trait _ | T_blackhole -> - Some (Errors.invalid_stub_type loc) - | Tvar _ -> assert false) + (global_env : Global_env.t) ~(allow_func : bool) ~(is_import_stub : bool) = + (match language with + | Some ("js" | "c" | "C") -> None + | _ -> ( + let loc = Typedtree.loc_of_typ typ in + let ty = Stype.type_repr (Typedtree_util.stype_of_typ typ) in + let ty = + match ty with + | T_constr { type_constructor; tys = ty :: [] } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_func_ref -> + Stype.type_repr ty + | _ -> ty + in + match ty with + | T_builtin T_unit + | T_builtin T_int + | T_builtin T_bool + | T_builtin T_byte + | T_builtin T_int16 + | T_builtin T_uint16 + | T_builtin T_char + | T_builtin T_int64 + | T_builtin T_float + | T_builtin T_double + | T_builtin T_uint + | T_builtin T_uint64 -> + None + | T_builtin T_string -> + if is_import_stub && !Basic_config.target <> Wasm_gc then + Some (Errors.invalid_stub_type loc) + else None + | T_builtin T_bytes -> + if is_import_stub then Some (Errors.invalid_stub_type loc) else None + | T_constr { type_constructor; tys = ty_elem :: [] } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_fixedarray -> ( + if is_import_stub then Some (Errors.invalid_stub_type loc) + else + match language with + | Some "wasm" -> ( + match ty_elem with + | T_builtin _ -> None + | _ -> Some (Errors.invalid_stub_type loc)) + | _ -> ( + match ty_elem with + | T_builtin builtin -> ( + match builtin with + | T_int | T_int64 | T_double -> None + | T_unit | T_byte | T_int16 | T_uint16 | T_bytes | T_uint64 + | T_string | T_uint | T_bool | T_char | T_float -> + Some (Errors.invalid_stub_type loc)) + | _ -> Some (Errors.invalid_stub_type loc))) + | T_constr { type_constructor = p; tys = _ } -> ( + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = Extern_type; _ } -> None + | Some { ty_desc = Variant_type constrs; _ } + when Lst.for_all constrs (fun constr -> constr.cs_args = []) -> + None + | _ -> Some (Errors.invalid_stub_type loc)) + | Tarrow { is_async; _ } when (not allow_func) || is_async -> + Some (Errors.invalid_stub_type loc) + | Tarrow { params_ty; ret_ty; err_ty; is_async = _ } -> + let is_simple_stub (ty : Stype.t) = + match Stype.type_repr ty with + | T_builtin T_unit + | T_builtin T_int + | T_builtin T_bool + | T_builtin T_byte + | T_builtin T_int16 + | T_builtin T_uint16 + | T_builtin T_char + | T_builtin T_int64 + | T_builtin T_uint + | T_builtin T_uint64 + | T_builtin T_float + | T_builtin T_double -> + true + | T_builtin T_string | T_builtin T_bytes -> not is_import_stub + | T_constr { type_constructor; tys = _ } + when Type_path.equal type_constructor + Type_path.Builtin.type_path_fixedarray -> + not is_import_stub + | T_constr { type_constructor = p; tys = _ } -> ( + match Global_env.find_type_by_path global_env p with + | Some { ty_desc = Extern_type; _ } -> true + | _ -> false) + | T_blackhole -> true + | Tarrow _ | Tparam _ | T_trait _ -> false + | Tvar _ -> assert false + [@@inline] + in + if + Lst.for_all params_ty is_simple_stub + && is_simple_stub ret_ty && err_ty = None + then None + else Some (Errors.invalid_stub_type loc) + | Tparam _ | T_trait _ | T_blackhole -> + Some (Errors.invalid_stub_type loc) + | Tvar _ -> assert false) + : Local_diagnostics.error option) let is_raw_string = function Syntax.Multiline_string _ -> true | _ -> false -let is_tvar (typ : Stype.t) : bool = - let typ = Stype.type_repr typ in - match typ with Tvar _ -> true | _ -> false - -let is_trait (typ : Stype.t) : bool = - let typ = Stype.type_repr typ in - match typ with T_trait _ -> true | _ -> false +let is_tvar (typ : Stype.t) = + (let typ = Stype.type_repr typ in + match typ with Tvar _ -> true | _ -> false + : bool) -let is_only_tag_enum (typ : Stype.t) : bool = - let typ = Stype.type_repr typ in - match typ with T_constr { only_tag_enum_; _ } -> only_tag_enum_ | _ -> false +let is_trait (typ : Stype.t) = + (let typ = Stype.type_repr typ in + match typ with T_trait _ -> true | _ -> false + : bool) let validate_record ~(context : [ `Pattern | `Creation ]) ~(expected : Typedecl_info.fields) (fields : Syntax.label list) - ~(record_ty : Stype.t) ~(is_strict : bool) ~loc : - string list Local_diagnostics.partial_info = - let seen_labels = Hashset_string.create 17 in - let superfluous = ref [] in - let errors = ref [] in - Lst.iter fields (fun { label_name; loc_ = label_loc } -> - if not (Hashset_string.check_add seen_labels label_name) then - errors := - Errors.duplicate_record_field ~label:label_name ~context - ~loc:label_loc - :: !errors; - if - not - (Lst.exists expected (fun { field_name; _ } -> - field_name = label_name)) - then ( - superfluous := label_name :: !superfluous; - errors := - Errors.superfluous_field ~label:label_name - ~ty:(Printer.type_to_string record_ty) - ~loc:label_loc - :: !errors)); - let missing = - Lst.fold_right expected [] (fun { field_name; _ } acc -> - if Hashset_string.mem seen_labels field_name then acc - else field_name :: acc) - in - if missing <> [] && is_strict then - errors := - Errors.missing_fields_in_record ~labels:missing - ~ty:(Printer.type_to_string record_ty) - ~context ~loc - :: !errors; - match !errors with - | [] -> Ok !superfluous - | errs -> Partial (!superfluous, errs) - -let add_binder (env : Local_env.t) (binder : Typedtree.binder) ~typ ~mut : - Local_env.t = - Local_env.add env binder.binder_id ~typ ~mut ~loc:binder.loc_ - -let fresh_binder (b : Syntax.binder) : Typedtree.binder = - { binder_id = Ident.fresh b.binder_name; loc_ = b.loc_ } + ~(record_ty : Stype.t) ~(is_strict : bool) ~loc ~diagnostics = + (let seen_labels = Hashset_string.create 17 in + let superfluous = ref [] in + Lst.iter fields ~f:(fun { label_name; loc_ = label_loc } -> + if not (Hashset_string.check_add seen_labels label_name) then + Local_diagnostics.add_error diagnostics + (Errors.duplicate_record_field ~label:label_name ~context + ~loc:label_loc); + if + not + (Lst.exists expected (fun { field_name; _ } -> + field_name = label_name)) + then ( + superfluous := label_name :: !superfluous; + Local_diagnostics.add_error diagnostics + (Errors.superfluous_field ~label:label_name + ~ty:(Printer.type_to_string record_ty) + ~loc:label_loc))); + let missing = + Lst.fold_right expected [] (fun { field_name; _ } -> + fun acc -> + if Hashset_string.mem seen_labels field_name then acc + else field_name :: acc) + in + if missing <> [] && is_strict then + Local_diagnostics.add_error diagnostics + (Errors.missing_fields_in_record ~labels:missing + ~ty:(Printer.type_to_string record_ty) + ~context ~loc); + !superfluous + : string list) + +let resolve_constr_or_constant ~(global_env : Global_env.t) ~tvar_env + ~(expect_ty : Stype.t option) ~(constr : Syntax.constructor) + ~(creating_value : bool) ~diagnostics = + (let ({ constr_name; extra_info; loc_ = loc } : Syntax.constructor) = + constr + in + let find_constr (constrs : Typedecl_info.constructor list) ~type_name = + match + Lst.find_first constrs (fun c -> c.constr_name = constr_name.name) + with + | Some constr -> + (match constr.cs_res with + | T_constr { type_constructor = p; _ } + when creating_value + && Type_path_util.is_foreign p + && constr.cs_vis <> Read_write -> + Local_diagnostics.add_error diagnostics + (Errors.readonly_type ~name:constr.constr_name ~loc) + | _ -> ()); + (Some (`Constr constr), type_name) + | None -> + let ty = + match extra_info with + | Type_name type_name -> Some (Longident.to_string type_name.name) + | Package _ | No_extra_info -> ( + match expect_ty with + | Some expect_ty -> Some (Printer.type_to_string expect_ty) + | None -> None) + in + Local_diagnostics.add_error diagnostics + (Errors.constr_not_found ~constr:constr_name.name ~ty + ~loc:constr_name.loc_); + (None, type_name) + [@@local] + in + match extra_info with + | Type_name type_name -> ( + match + typing_type_name ~allow_private:true + ~types:(Global_env.get_all_types global_env) + ~tvar_env + ~local_type_env:(Global_env.get_cur_local_type_env global_env) + ~diagnostics type_name + with + | None -> (None, None) + | Some (type_info, tast_type_name) -> ( + let not_a_variant kind = + Local_diagnostics.add_error diagnostics + (Errors.not_a_variant + ~ty:(Longident.to_string type_name.name) + ~kind ~loc:type_name.loc_); + (None, Some tast_type_name) + [@@local] + in + match type_info with + | Tname_defined { ty_desc = Variant_type constrs; _ } + | Tname_defined { ty_desc = ErrorEnum_type constrs; _ } + | Tname_local_type { kind = Enum constrs; _ } -> + find_constr constrs ~type_name:(Some tast_type_name) + | Tname_defined + { ty_desc = New_type { newtype_constr = constr; _ }; _ } + | Tname_defined { ty_desc = Error_type constr; _ } + | Tname_local_type + { kind = Newtype { newtype_constr = constr; _ }; _ } -> + find_constr [ constr ] ~type_name:(Some tast_type_name) + | Tname_defined { ty_desc = Abstract_type | Extern_type; _ } -> + not_a_variant "abstract" + | Tname_defined { ty_desc = Record_type _; _ } + | Tname_local_type { kind = Struct _; _ } -> + not_a_variant "struct type" + | Tname_local_type { kind = Placeholder; _ } -> assert false + | Tname_param _ -> not_a_variant "type parameter" + | Tname_predef (Tuple _) -> not_a_variant "tuple" + | Tname_predef _ -> not_a_variant "predefined type" + | Tname_trait _ -> not_a_variant "trait" + | Tname_trait_object _ -> not_a_variant "trait object type")) + | No_extra_info -> ( + let expect_ty = Option.map Stype.type_repr expect_ty in + let take_info info = + match info with + | Ok result -> (Some result, None) + | Error err -> + (match expect_ty with + | Some (Tvar { contents = Tnolink Tvar_error }) | Some T_blackhole + -> + () + | _ -> Local_diagnostics.add_error diagnostics err); + (None, None) + [@@local] + in + match expect_ty with + | None | Some (Tvar _) -> + take_info + (Global_env.find_constructor_or_constant global_env + constr_name.name ~loc) + | Some ty when Type.is_super_error ty -> + take_info + (Global_env.find_constructor_or_constant global_env + constr_name.name ~loc) + | Some (T_builtin _) -> + take_info + (Global_env.find_constructor_or_constant global_env + constr_name.name ~loc) + | Some ty -> ( + match + Global_env.constrs_of_variant global_env ty ~loc ~creating_value + with + | Ok constrs -> find_constr constrs ~type_name:None + | Error err -> + Local_diagnostics.add_error diagnostics err; + (None, None))) + | Package pkg -> ( + match + Pkg.find_constructor_or_constant + (Global_env.get_pkg_tbl global_env) + ~pkg constr_name.name ~loc + with + | Ok result -> (Some result, None) + | Error err -> + Local_diagnostics.add_error diagnostics err; + (None, None)) + : [ `Constr of Typedecl_info.constructor | `Constant of Value_info.toplevel ] + option + * Typedtree.type_name option) + +let resolve_constant ~(global_env : Global_env.t) ~(pkg : string option) + ~(constant_name : Syntax.binder) ~diagnostics ~loc = + match pkg with + | None -> ( + match + Typing_info.find_value + (Global_env.get_toplevel_values global_env) + constant_name.binder_name + with + | Some c -> Some c + | None -> + Local_diagnostics.add_error diagnostics + (Errors.constant_not_found ~name:constant_name.binder_name + ~loc:constant_name.loc_); + None) + | Some pkg -> + Pkg.find_constant + (Global_env.get_pkg_tbl global_env) + ~pkg ~constant_name:constant_name.binder_name ~loc ~diagnostics + +let add_binder (env : Local_env.t) (binder : Typedtree.binder) ~typ ~mut = + (Local_env.add env binder.binder_id ~typ ~mut ~loc:binder.loc_ : Local_env.t) + +let fresh_binder (b : Syntax.binder) = + ({ binder_id = Ident.fresh b.binder_name; loc_ = b.loc_ } : Typedtree.binder) let add_pat_binder (env : Local_env.t) - ({ binder; binder_typ } : Typedtree.pat_binder) : Local_env.t = - Local_env.add env binder.binder_id ~typ:binder_typ ~mut:false ~loc:binder.loc_ + ({ binder; binder_typ } : Typedtree.pat_binder) = + (Local_env.add env binder.binder_id ~typ:binder_typ ~mut:false + ~loc:binder.loc_ + : Local_env.t) -let add_pat_binders (env : Local_env.t) (bs : Typedtree.pat_binders) : - Local_env.t = - List.fold_left add_pat_binder env bs +let rec add_pat_binders (env : Local_env.t) (bs : Typedtree.pat_binders) = + (match bs with + | [] -> env + | b :: [] -> add_pat_binder env b + | b1 :: b2 :: bs -> + let env = add_pat_binder env b1 in + let env = add_pat_binder env b2 in + add_pat_binders env bs + : Local_env.t) let add_local_typing_error = Local_diagnostics.add_error -let store_error (error_option : Local_diagnostics.error_option) ~diagnostics = +let store_error (error_option : Local_diagnostics.error option) ~diagnostics = match error_option with | None -> () | Some err -> add_local_typing_error diagnostics err -let take_info_partial (x : 'a Local_diagnostics.partial_info) ~diagnostics : 'a +let take_info_partial (x : 'a Local_diagnostics.partial_info) ~diagnostics = + (match x with + | Ok a -> a + | Partial (a, errors) -> + Basic_lst.iter errors ~f:(add_local_typing_error diagnostics); + a + : 'a) + +let resolve_derive_alias (trait : Longident.t) = + (match trait with + | Lident "FromJson" -> + Ldot { pkg = "moonbitlang/core/json"; id = "FromJson" } + | Lident "Arbitrary" -> + Ldot { pkg = "moonbitlang/core/quickcheck"; id = "Arbitrary" } + | trait -> trait + : Longident.t) + +let generate_signatures_local_type_derive ~(global_env : Global_env.t) + ~(self_typ_path : Type_path.t) ~(self_typ : Stype.t) ~(trait : Type_path.t) + ~(tvar_env : Tvar_env.t) ~loc = + match Global_env.find_trait_by_path global_env trait with + | None -> () + | Some trait_decl -> + let impl_params = tvar_env in + Lst.iter trait_decl.methods ~f:(fun method_ -> + let impl_ty = + Poly_type.instantiate_method_decl method_ ~self:self_typ + in + let method_name = method_.method_name in + if + (not + (Type_path.equal trait_decl.name Type_path.Builtin.trait_hash + && method_name = "hash")) + && not + (Type_path.equal trait_decl.name Type_path.Builtin.trait_show + && method_name = "to_string") + then ( + let id = + Basic_qual_ident.ext_meth ~trait:trait_decl.name + ~self_typ:self_typ_path ~name:method_name + in + let method_info : Method_env.method_info = + { + id; + prim = None; + typ = impl_ty; + pub = false; + loc; + doc_ = Docstring.empty; + attrs = []; + ty_params_ = impl_params; + kind_ = Method_explicit_self { self_ty = self_typ }; + arity_ = method_.method_arity; + param_names_ = []; + } + in + Ext_method_env.add_method + (Global_env.get_ext_method_env global_env) + ~trait ~self_type:self_typ_path ~method_name method_info; + Method_env.add_impl + (Global_env.get_method_env global_env) + ~type_name:self_typ_path ~method_name ~method_info) + else + match[@warning "-fragile-match"] + Global_env.find_trait_method global_env ~trait + ~type_name:self_typ_path ~method_name + with + | Some method_info -> + Method_env.add_impl + (Global_env.get_method_env global_env) + ~type_name:self_typ_path ~method_name ~method_info + | _ -> assert false) + +let local_type_decl_to_type_decl (local_decl : Parsing_syntax.local_type_decl) + base = + ({ + tycon = local_decl.local_tycon; + tycon_loc_ = local_decl.local_tycon_loc_; + params = []; + components = local_decl.local_components; + doc_ = Docstring.empty; + type_vis = Vis_default; + deriving_ = []; + loc_ = base; + attrs = []; + } + : Parsing_syntax.type_decl) + +let add_newtype_dep (newtype_deps : string list Basic_hash_string.t) + (name : string) (underlying_type : Syntax.typ) = + let result = ref [] in + let rec go (typ : Syntax.typ) = + match typ with + | Ptype_name { constr_id; tys } -> ( + Lst.iter tys ~f:go; + match constr_id.lid with + | Lident name -> + if not (Lst.exists !result (fun x -> x = name)) then + result := name :: !result + | Ldot _ -> ()) + | Ptype_arrow { ty_arg; ty_res; ty_err; is_async = _ } -> ( + Lst.iter ty_arg ~f:go; + go ty_res; + match ty_err with + | Error_typ { ty = ty_err } -> go ty_err + | No_error_typ | Default_error_typ _ -> ()) + | Ptype_tuple { tys } -> Lst.iter tys ~f:go + | Ptype_option { ty; _ } -> go ty + | Ptype_object _ -> () + | Ptype_any _ -> () + in + go underlying_type; + Basic_hash_string.add newtype_deps name !result + +let check_newtype_cycle (newtype_deps : string list Basic_hash_string.t) + (name : string) = + (let visiting = Hashset_string.create 17 in + let rec go (name : string) = + if Hashset_string.mem visiting name then true + else + match Basic_hash_string.find_opt newtype_deps name with + | None -> false + | Some deps -> + Hashset_string.add visiting name; + let result = Lst.exists deps (fun dep -> go dep) in + Hashset_string.remove visiting name; + result + in + go name + : bool) + +let typing_local_type (local_types : Parsing_syntax.local_type_decl list) + (toplevel_id : Basic_qual_ident.t) ~global_env ~tvar_env ~base ~diagnostics = - match x with - | Ok a -> a - | Partial (a, errors) -> - List.iter (add_local_typing_error diagnostics) errors; - a + (let newtype_deps = Basic_hash_string.create 17 in + let typing_type typ = + typing_type typ + ~types:(Global_env.get_all_types global_env) + ~tvar_env ~allow_partial:false ~allow_private:true + ~local_type_env:(Global_env.get_cur_local_type_env global_env) + ~diagnostics + [@@inline] + in + let typing_fields (struct_ty : Stype.t) (fs : Syntax.field_decl list) = + (let all_labels = Lst.map fs (fun f -> f.field_name.label) in + List.split + (Lst.mapi fs (fun i -> + fun f -> + let field_ty = typing_type f.field_ty in + let field : Typedecl_info.field = + { + field_name = f.field_name.label; + pos = i; + ty_field = Typedtree_util.stype_of_typ field_ty; + ty_record = struct_ty; + all_labels; + mut = f.field_mut; + label_loc_ = Rloc.to_loc ~base f.field_name.loc_; + loc_ = Rloc.to_loc ~base f.field_loc_; + ty_params_ = Tvar_env.empty; + vis = Read_write; + } + in + let tast_field : Typedtree.field_decl = + { + field_label = + { + label_name = f.field_name.label; + loc_ = f.field_name.loc_; + }; + field_typ = field_ty; + field_mut = f.field_mut; + field_vis = Invisible; + field_loc_ = f.field_loc_; + } + in + Global_env.add_local_field global_env field; + (tast_field, field))) + : Typedtree.field_decl list * Typedecl_info.field list) + in + let typing_constructors ~is_only_tag_enum (enum_ty : Stype.t) + (cs : Syntax.constr_decl list) = + (let total = + let n = List.length cs in + if n = 0 then Constr_info.Index_set.empty + else Constr_info.Index_set.singleton 0 (n - 1) + in + List.split + (Lst.mapi cs (fun i -> + fun c -> + let args, arity = + match c.constr_args with + | None -> ([], Fn_arity.simple 0) + | Some args -> + ( args, + take_info_partial ~diagnostics + (Fn_arity.from_constr_params ~base args) ) + in + let args_ty, tast_args = + Lst.map_split args (fun arg -> + let typ = typing_type arg.cparam_typ in + let tast_arg : Typedtree.constr_decl_arg = + { + carg_typ = typ; + carg_mut = arg.cparam_mut; + carg_label = arg.cparam_label; + } + in + (Typedtree_util.stype_of_typ typ, tast_arg)) + in + let cs_tag : Constr_info.constr_tag = + Constr_tag_regular + { + total; + index = i; + name_ = c.constr_name.name; + repr_ = + (if is_only_tag_enum then Integer i + else + match c.constr_args with + | None -> Constant + | _ -> Non_constant); + } + in + let constructor : Typedecl_info.constructor = + { + constr_name = c.constr_name.name; + cs_args = args_ty; + cs_res = enum_ty; + cs_tag; + cs_arity_ = arity; + cs_constr_loc_ = Rloc.to_loc ~base c.constr_name.loc_; + cs_loc_ = Rloc.to_loc ~base c.constr_loc_; + cs_vis = Read_write; + cs_ty_params_ = Tvar_env.empty; + } + in + let tast_constructor : Typedtree.constr_decl = + { + constr_name = + { + label_name = c.constr_name.name; + loc_ = c.constr_name.loc_; + }; + constr_tag = constructor.cs_tag; + constr_args = tast_args; + constr_arity_ = arity; + constr_loc_ = c.constr_loc_; + } + in + Global_env.add_local_constr global_env constructor; + (tast_constructor, constructor))) + : Typedtree.constr_decl list * Typedecl_info.constructor list) + in + let typing_decl (decl : Syntax.local_type_decl) + (type_constructor : Type_path.t) = + (match decl.local_components with + | Ptd_record fs -> + let struct_ty : Stype.t = + T_constr + { + type_constructor; + tys = Tvar_env.get_types tvar_env; + generic_ = false; + is_suberror_ = false; + } + in + (match + Basic_duplicate_check.check_duplicate_by fs (fun f -> + f.field_name.label) + with + | Some { field_name = { label = name; loc_ }; _ } -> + Local_diagnostics.add_error diagnostics + (Errors.field_duplicate ~name ~loc:loc_) + | None -> ()); + let fields, fields_info = typing_fields struct_ty fs in + (Td_record fields, Struct fields_info, false) + | Ptd_variant cs -> + let only_tag_enum_ = Lst.for_all cs (fun c -> c.constr_args = None) in + let enum_ty : Stype.t = + T_constr + { + type_constructor; + tys = Tvar_env.get_types tvar_env; + generic_ = false; + is_suberror_ = false; + } + in + (match + Basic_duplicate_check.check_duplicate_by cs (fun c -> + c.constr_name.name) + with + | Some { constr_name = { name; loc_ }; _ } -> + Local_diagnostics.add_error diagnostics + (Errors.constructor_duplicate ~name ~loc:loc_) + | None -> ()); + let constructors, constructors_info = + typing_constructors ~is_only_tag_enum:only_tag_enum_ enum_ty cs + in + (Td_variant constructors, Enum constructors_info, only_tag_enum_) + | Ptd_newtype ty -> + let underlying_typ = typing_type ty in + let underlying_sty = Typedtree_util.stype_of_typ underlying_typ in + let newtype_ty : Stype.t = + T_constr + { + type_constructor; + tys = Tvar_env.get_types tvar_env; + generic_ = false; + is_suberror_ = false; + } + in + let constr : Typedecl_info.constructor = + { + constr_name = decl.local_tycon; + cs_res = newtype_ty; + cs_args = [ underlying_sty ]; + cs_tag = + Constr_tag_regular + { + total = Constr_info.Index_set.singleton 0 0; + index = 0; + name_ = decl.local_tycon; + repr_ = Non_constant; + }; + cs_arity_ = Fn_arity.simple 1; + cs_constr_loc_ = Rloc.to_loc ~base decl.local_tycon_loc_; + cs_loc_ = Rloc.to_loc ~base decl.local_tycon_loc_; + cs_vis = Read_write; + cs_ty_params_ = Tvar_env.empty; + } + in + Global_env.add_local_constr global_env constr; + let recursive = check_newtype_cycle newtype_deps decl.local_tycon in + ( Td_newtype underlying_typ, + Newtype + { + newtype_constr = constr; + underlying_typ = underlying_sty; + recursive; + }, + false ) + | _ -> assert false + : Typedtree.type_desc * Local_type.local_type_kind * bool) + in + Lst.iter local_types ~f:(fun decl -> + match Global_env.find_local_type global_env decl.local_tycon with + | Some t -> + let error = + Errors.local_type_redeclare ~name:decl.local_tycon + ~first_loc:(Rloc.to_loc ~base t.loc_) + ~second_loc:decl.local_tycon_loc_ + in + Local_diagnostics.add_error diagnostics error + | None -> + (match decl.local_components with + | Ptd_newtype typ -> + add_newtype_dep newtype_deps decl.local_tycon typ + | _ -> ()); + let placeholder : Local_type.t = + { + name = decl.local_tycon; + toplevel_id = Basic_qual_ident.to_toplevel_id toplevel_id; + kind = Placeholder; + loc_ = decl.local_tycon_loc_; + is_only_tag_enum = false; + ty_params_ = Tvar_env.empty; + } + in + Global_env.add_local_type global_env placeholder); + let derive_tasks = Basic_vec.empty () in + let type_decl_tast = + Lst.map local_types (fun decl -> + (let type_path = + Type_path.local_type + (Basic_qual_ident.to_toplevel_id toplevel_id) + decl.local_tycon + in + let desc, kind, is_only_tag_enum = typing_decl decl type_path in + let self_typ : Stype.t = + T_constr + { + type_constructor = type_path; + tys = Tvar_env.get_types tvar_env; + generic_ = not (Tvar_env.is_empty tvar_env); + is_suberror_ = false; + } + in + Lst.iter decl.deriving_ ~f:(fun d -> + let name = resolve_derive_alias d.type_name_.name in + match + Global_env.All_types.find_trait + (Global_env.get_all_types global_env) + name ~loc:d.loc_ + with + | Ok { name = trait_path; _ } -> + generate_signatures_local_type_derive ~global_env + ~self_typ_path:type_path ~self_typ ~trait:trait_path + ~tvar_env + ~loc:(Rloc.to_loc ~base decl.local_tycon_loc_); + let decl = local_type_decl_to_type_decl decl base in + Basic_vec.push derive_tasks + ({ decl; type_path; directive = d; trait_path } + : Local_type.derive_task) + | Error err -> Local_diagnostics.add_error diagnostics err); + let type_info : Local_type.t = + { + name = decl.local_tycon; + toplevel_id = Basic_qual_ident.to_toplevel_id toplevel_id; + kind; + loc_ = decl.local_tycon_loc_; + is_only_tag_enum; + ty_params_ = tvar_env; + } + in + Global_env.update_local_type global_env type_info; + { + td_binder = + { name = type_path; kind = Type; loc_ = decl.local_tycon_loc_ }; + td_params = Tvar_env.empty; + td_desc = desc; + td_vis = Vis_priv; + td_loc_ = base; + td_doc_ = Docstring.empty; + td_deriving_ = []; + } + : Typedtree.type_decl)) + in + (type_decl_tast, Basic_vec.to_list derive_tasks) + : Typedtree.type_decl list * Local_type.derive_tasks) + +type ret_annotation = + | Annotated of (Typedtree.typ * Typedtree.error_typ) + | Has_super_error of Rloc.t + | No_annotation + +type ret_info = { + ret_sty : Stype.t; + err_sty : Stype.t option; + annotation : ret_annotation; +} + +let handle_return_annotation + (return_type : (Syntax.typ * Syntax.error_typ) option) + ~(has_error : Rloc.t option) ~(typing_type : Syntax.typ -> Typedtree.typ) = + (match return_type with + | None -> ( + let ret_sty = Stype.new_type_var Tvar_normal in + match has_error with + | None -> { ret_sty; err_sty = None; annotation = No_annotation } + | Some loc_ -> + { + ret_sty; + err_sty = Some default_err_type; + annotation = Has_super_error loc_; + }) + | Some (ret_ty, err_ty) -> ( + let ret_ty = typing_type ret_ty in + let ret_sty = Typedtree_util.stype_of_typ ret_ty in + match err_ty with + | Error_typ { ty = err_ty } -> + let err_ty = typing_type err_ty in + let err_sty = Typedtree_util.stype_of_typ err_ty in + { + ret_sty; + err_sty = Some err_sty; + annotation = Annotated (ret_ty, Error_typ { ty = err_ty }); + } + | Default_error_typ { loc_ } -> + { + ret_sty; + err_sty = Some default_err_type; + annotation = Annotated (ret_ty, Default_error_typ { loc_ }); + } + | No_error_typ -> ( + match has_error with + | None -> + { + ret_sty; + err_sty = None; + annotation = Annotated (ret_ty, No_error_typ); + } + | Some loc_ -> + { + ret_sty; + err_sty = Some default_err_type; + annotation = Annotated (ret_ty, Default_error_typ { loc_ }); + })) + : ret_info) + +let report_unused_error_annotation (annotation : ret_annotation) + (diagnostics : Local_diagnostics.t) = + match annotation with + | Annotated (_, Error_typ { ty }) -> + let loc = Typedtree.loc_of_typ ty in + Local_diagnostics.add_warning diagnostics + { kind = Useless_error_type; loc } + | Annotated (_, Default_error_typ { loc_ = loc }) | Has_super_error loc -> + Local_diagnostics.add_warning diagnostics + { kind = Useless_error_type; loc } + | Annotated (_, No_error_typ) | No_annotation -> () diff --git a/src/typing_info.ml b/src/typing_info.ml index 7429e78..fa45af5 100644 --- a/src/typing_info.ml +++ b/src/typing_info.ml @@ -62,7 +62,8 @@ include struct values = values__007_; constructors = constructors__009_; fields = fields__011_; - } -> + } + -> let bnds__006_ = ([] : _ Stdlib.List.t) in let bnds__006_ = let arg__012_ = @@ -132,14 +133,14 @@ let add_value (info : values) (value : Value_info.toplevel) = Hash_string.add info.values (Qual_ident.base_name value.id) value let add_constructor (info : values) (x : Typedecl_info.constructor) = - Hash_string.add_or_update info.constructors x.constr_name [ x ] - ~update:(fun cs -> x :: cs) - |> ignore + ignore + (Hash_string.add_or_update info.constructors x.constr_name [ x ] + ~update:(fun cs -> x :: cs)) let add_field (info : values) ~(field : Typedecl_info.field) = - Hash_string.add_or_update info.fields field.field_name [ field ] - ~update:(fun fields -> field :: fields) - |> ignore + ignore + (Hash_string.add_or_update info.fields field.field_name [ field ] + ~update:(fun fields -> field :: fields)) let find_type (info : types) name = Hash_string.find_opt info.type_decls name @@ -154,7 +155,7 @@ let find_trait_exn (info : types) name = let find_value (info : values) name = Hash_string.find_opt info.values name let find_constructor (info : values) name = - Hash_string.find_opt info.constructors name |> Option.value ~default:[] + Option.value ~default:[] (Hash_string.find_opt info.constructors name) let find_all_fields (info : values) (name : string) = Hash_string.find_default info.fields name [] @@ -163,43 +164,46 @@ let find_all_fields (info : values) (name : string) = let find_field (info : values) name = match find_all_fields info name with entry :: _ -> Some entry | [] -> None -let get_all_types (info : types) : (string * Typedecl_info.t) array = - Hash_string.to_array info.type_decls +let get_all_types (info : types) = + (Hash_string.to_array info.type_decls : (string * Typedecl_info.t) array) -let get_all_traits (info : types) : (string * Trait_decl.t) array = - Hash_string.to_array info.trait_decls +let get_all_traits (info : types) = + (Hash_string.to_array info.trait_decls : (string * Trait_decl.t) array) let iter_types (info : types) (f : string * Typedecl_info.t -> unit) = Hash_string.iter info.type_decls f -let get_pub_types (info : types) : (string * Typedecl_info.t) array = - Hash_string.to_array_filter_map info.type_decls (fun (name, decl) -> - match decl.ty_vis with - | Vis_priv -> None - | Vis_default -> Some (name, { decl with ty_desc = Abstract_type }) - | Vis_fully_pub | Vis_readonly -> - let decl = - match decl.ty_desc with - | Record_type { has_private_field_ = true; fields } -> - let fields = Lst.filter fields (fun f -> f.vis <> Invisible) in - { - decl with - ty_desc = Record_type { has_private_field_ = true; fields }; - } - | _ -> decl - in - Some (name, decl)) - -let get_pub_traits (info : types) : (string * Trait_decl.t) array = - Hash_string.to_array_filter_map info.trait_decls (fun (name, trait) -> - if trait.vis_ <> Vis_priv then Some (name, trait) else None) +let get_pub_types (info : types) = + (Hash_string.to_array_filter_map info.type_decls (fun (name, decl) -> + match decl.ty_vis with + | Vis_priv -> None + | Vis_default -> Some (name, { decl with ty_desc = Abstract_type }) + | Vis_fully_pub | Vis_readonly -> + let decl = + match decl.ty_desc with + | Record_type { has_private_field_ = true; fields } -> + let fields = Lst.filter fields (fun f -> f.vis <> Invisible) in + { + decl with + ty_desc = Record_type { has_private_field_ = true; fields }; + } + | _ -> decl + in + Some (name, decl)) + : (string * Typedecl_info.t) array) + +let get_pub_traits (info : types) = + (Hash_string.to_array_filter_map info.trait_decls (fun (name, trait) -> + if trait.vis_ <> Vis_priv then Some (name, trait) else None) + : (string * Trait_decl.t) array) let iter_traits (info : types) (f : string * Trait_decl.t -> unit) = Hash_string.iter info.trait_decls f -let get_pub_values (info : values) : (string * Value_info.toplevel) array = - Hash_string.to_array_filter_map info.values (fun (name, vd) -> - if vd.pub then Some (name, vd) else None) +let get_pub_values (info : values) = + (Hash_string.to_array_filter_map info.values (fun (name, vd) -> + if vd.pub then Some (name, vd) else None) + : (string * Value_info.toplevel) array) let iter_values (info : values) (f : Value_info.toplevel -> unit) = Hash_string.iter info.values (fun (_, entry) -> f entry) @@ -207,8 +211,8 @@ let iter_values (info : values) (f : Value_info.toplevel -> unit) = let iter_constructors (info : values) (f : string * Typedecl_info.constructor -> unit) = Hash_string.iter info.constructors (fun (name, constrs) -> - Basic_lst.iter constrs (fun constr -> f (name, constr))) + Basic_lst.iter constrs ~f:(fun constr -> f (name, constr))) let iter_fields (info : values) (f : string * Typedecl_info.field -> unit) = Hash_string.iter info.fields (fun (field_name, fields) -> - List.iter (fun field_desc -> f (field_name, field_desc)) fields) + Basic_lst.iter fields ~f:(fun field_desc -> f (field_name, field_desc))) diff --git a/src/value_info.ml b/src/value_info.ml index 245e37a..fd77cbe 100644 --- a/src/value_info.ml +++ b/src/value_info.ml @@ -66,6 +66,7 @@ type toplevel = { [@sexp_drop_if function Normal -> true | Prim _ | Const _ -> false] loc_ : Loc.t; doc_ : Docstring.t; [@sexp_drop_if Docstring.is_empty] + attrs : Checked_attributes.t; ty_params_ : Tvar_env.t; [@sexp_drop_if Tvar_env.is_empty] arity_ : Fn_arity.t option; [@sexp_drop_if @@ -82,11 +83,11 @@ include struct | Normal -> true | Prim _ | Const _ -> false and (drop_if__024_ : Docstring.t -> Stdlib.Bool.t) = Docstring.is_empty - and (drop_if__029_ : Tvar_env.t -> Stdlib.Bool.t) = Tvar_env.is_empty - and (drop_if__034_ : Fn_arity.t option -> Stdlib.Bool.t) = function + and (drop_if__031_ : Tvar_env.t -> Stdlib.Bool.t) = Tvar_env.is_empty + and (drop_if__036_ : Fn_arity.t option -> Stdlib.Bool.t) = function | Some arity -> Fn_arity.is_simple arity | None -> true - and (drop_if__041_ : direct_use_loc -> Stdlib.Bool.t) = is_no_direct_use in + and (drop_if__043_ : direct_use_loc -> Stdlib.Bool.t) = is_no_direct_use in fun { id = id__010_; typ = typ__012_; @@ -94,42 +95,47 @@ include struct kind = kind__018_; loc_ = loc___021_; doc_ = doc___025_; - ty_params_ = ty_params___030_; - arity_ = arity___035_; - param_names_ = param_names___038_; - direct_use_loc_ = direct_use_loc___042_; + attrs = attrs__028_; + ty_params_ = ty_params___032_; + arity_ = arity___037_; + param_names_ = param_names___040_; + direct_use_loc_ = direct_use_loc___044_; } -> let bnds__009_ = ([] : _ Stdlib.List.t) in let bnds__009_ = - if drop_if__041_ direct_use_loc___042_ then bnds__009_ + if drop_if__043_ direct_use_loc___044_ then bnds__009_ else - let arg__044_ = sexp_of_direct_use_loc direct_use_loc___042_ in - let bnd__043_ = S.List [ S.Atom "direct_use_loc_"; arg__044_ ] in - (bnd__043_ :: bnds__009_ : _ Stdlib.List.t) + let arg__046_ = sexp_of_direct_use_loc direct_use_loc___044_ in + let bnd__045_ = S.List [ S.Atom "direct_use_loc_"; arg__046_ ] in + (bnd__045_ :: bnds__009_ : _ Stdlib.List.t) in let bnds__009_ = - let arg__039_ = + let arg__041_ = Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string - param_names___038_ + param_names___040_ in - (S.List [ S.Atom "param_names_"; arg__039_ ] :: bnds__009_ + (S.List [ S.Atom "param_names_"; arg__041_ ] :: bnds__009_ : _ Stdlib.List.t) in let bnds__009_ = - if drop_if__034_ arity___035_ then bnds__009_ + if drop_if__036_ arity___037_ then bnds__009_ else - let arg__037_ = - (Moon_sexp_conv.sexp_of_option Fn_arity.sexp_of_t) arity___035_ + let arg__039_ = + (Moon_sexp_conv.sexp_of_option Fn_arity.sexp_of_t) arity___037_ in - let bnd__036_ = S.List [ S.Atom "arity_"; arg__037_ ] in - (bnd__036_ :: bnds__009_ : _ Stdlib.List.t) + let bnd__038_ = S.List [ S.Atom "arity_"; arg__039_ ] in + (bnd__038_ :: bnds__009_ : _ Stdlib.List.t) in let bnds__009_ = - if drop_if__029_ ty_params___030_ then bnds__009_ + if drop_if__031_ ty_params___032_ then bnds__009_ else - let arg__032_ = Tvar_env.sexp_of_t ty_params___030_ in - let bnd__031_ = S.List [ S.Atom "ty_params_"; arg__032_ ] in - (bnd__031_ :: bnds__009_ : _ Stdlib.List.t) + let arg__034_ = Tvar_env.sexp_of_t ty_params___032_ in + let bnd__033_ = S.List [ S.Atom "ty_params_"; arg__034_ ] in + (bnd__033_ :: bnds__009_ : _ Stdlib.List.t) + in + let bnds__009_ = + let arg__029_ = Checked_attributes.sexp_of_t attrs__028_ in + (S.List [ S.Atom "attrs"; arg__029_ ] :: bnds__009_ : _ Stdlib.List.t) in let bnds__009_ = if drop_if__024_ doc___025_ then bnds__009_ @@ -177,39 +183,39 @@ include struct let sexp_of_t = (function - | Local_imm { id = id__046_; typ = typ__048_; loc_ = loc___050_ } -> - let bnds__045_ = ([] : _ Stdlib.List.t) in - let bnds__045_ = - let arg__051_ = Rloc.sexp_of_t loc___050_ in - (S.List [ S.Atom "loc_"; arg__051_ ] :: bnds__045_ : _ Stdlib.List.t) + | Local_imm { id = id__048_; typ = typ__050_; loc_ = loc___052_ } -> + let bnds__047_ = ([] : _ Stdlib.List.t) in + let bnds__047_ = + let arg__053_ = Rloc.sexp_of_t loc___052_ in + (S.List [ S.Atom "loc_"; arg__053_ ] :: bnds__047_ : _ Stdlib.List.t) in - let bnds__045_ = - let arg__049_ = Stype.sexp_of_t typ__048_ in - (S.List [ S.Atom "typ"; arg__049_ ] :: bnds__045_ : _ Stdlib.List.t) + let bnds__047_ = + let arg__051_ = Stype.sexp_of_t typ__050_ in + (S.List [ S.Atom "typ"; arg__051_ ] :: bnds__047_ : _ Stdlib.List.t) in - let bnds__045_ = - let arg__047_ = Ident.sexp_of_t id__046_ in - (S.List [ S.Atom "id"; arg__047_ ] :: bnds__045_ : _ Stdlib.List.t) + let bnds__047_ = + let arg__049_ = Ident.sexp_of_t id__048_ in + (S.List [ S.Atom "id"; arg__049_ ] :: bnds__047_ : _ Stdlib.List.t) in - S.List (S.Atom "Local_imm" :: bnds__045_) - | Local_mut { id = id__053_; typ = typ__055_; loc_ = loc___057_ } -> - let bnds__052_ = ([] : _ Stdlib.List.t) in - let bnds__052_ = - let arg__058_ = Rloc.sexp_of_t loc___057_ in - (S.List [ S.Atom "loc_"; arg__058_ ] :: bnds__052_ : _ Stdlib.List.t) + S.List (S.Atom "Local_imm" :: bnds__047_) + | Local_mut { id = id__055_; typ = typ__057_; loc_ = loc___059_ } -> + let bnds__054_ = ([] : _ Stdlib.List.t) in + let bnds__054_ = + let arg__060_ = Rloc.sexp_of_t loc___059_ in + (S.List [ S.Atom "loc_"; arg__060_ ] :: bnds__054_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__056_ = Stype.sexp_of_t typ__055_ in - (S.List [ S.Atom "typ"; arg__056_ ] :: bnds__052_ : _ Stdlib.List.t) + let bnds__054_ = + let arg__058_ = Stype.sexp_of_t typ__057_ in + (S.List [ S.Atom "typ"; arg__058_ ] :: bnds__054_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__054_ = Ident.sexp_of_t id__053_ in - (S.List [ S.Atom "id"; arg__054_ ] :: bnds__052_ : _ Stdlib.List.t) + let bnds__054_ = + let arg__056_ = Ident.sexp_of_t id__055_ in + (S.List [ S.Atom "id"; arg__056_ ] :: bnds__054_ : _ Stdlib.List.t) in - S.List (S.Atom "Local_mut" :: bnds__052_) - | Toplevel_value arg0__059_ -> - let res0__060_ = sexp_of_toplevel arg0__059_ in - S.List [ S.Atom "Toplevel_value"; res0__060_ ] + S.List (S.Atom "Local_mut" :: bnds__054_) + | Toplevel_value arg0__061_ -> + let res0__062_ = sexp_of_toplevel arg0__061_ in + S.List [ S.Atom "Toplevel_value"; res0__062_ ] : t -> S.t) let _ = sexp_of_t diff --git a/src/value_tracing.ml b/src/value_tracing.ml new file mode 100644 index 0000000..7401959 --- /dev/null +++ b/src/value_tracing.ml @@ -0,0 +1,256 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Parse = Parsing_parse +module Syntax = Parsing_syntax +module Ident = Basic_longident +module Lst = Basic_lst + +type tracing_item = { display : string; loc : Loc.t; expr : Syntax.expr } +type env = { mutable tracing_list : tracing_item list; mutable base : Loc.t } + +module Ast = Ast_builder + +let generate_trace (item : tracing_item) = + let start_signal = "######MOONBIT_VALUE_TRACING_START######" in + let end_signal = "######MOONBIT_VALUE_TRACING_END######" in + let abs_loc = item.loc in + let line = Loc.line_number abs_loc in + let start_column = Loc.column_number abs_loc in + let end_column = Loc.column_number_end abs_loc in + let make_string_const str = + Syntax.Const_string { string_val = str; string_repr = str } + in + Ast.sequence + (Ast.apply + (Ast.ident (Ident.Ldot { pkg = "builtin"; id = "println" })) + [ Ast.const_string start_signal ] + No_attr) + (Ast.sequence + (Ast.apply + (Ast.ident (Ident.Ldot { pkg = "builtin"; id = "println" })) + [ + Ast.dot_apply + (Ast.annotation + (Ast.map + [ + Ast.map_elem (make_string_const "name") + (Ast.const_string item.display); + Ast.map_elem + (make_string_const "value") + (Ast.constr "String" + [ + Ast.apply + (Ast.ident (Ident.Lident "any_to_string")) + [ item.expr ] No_attr; + ]); + Ast.map_elem (make_string_const "line") + (Ast.const_string (string_of_int line)); + Ast.map_elem + (make_string_const "start_column") + (Ast.const_string (string_of_int start_column)); + Ast.map_elem + (make_string_const "end_column") + (Ast.const_string (string_of_int end_column)); + ]) + (Ast.typ "Json" [])) + "stringify" []; + ] + No_attr) + (Ast.apply + (Ast.ident (Ident.Ldot { pkg = "builtin"; id = "println" })) + [ Ast.const_string end_signal ] + No_attr)) + +let wrap_trace (item : tracing_item) expr = + let generated_ast = generate_trace item in + Ast.sequence generated_ast expr + +let wrap_traces (items : tracing_item list) expr = + List.fold_left (fun expr -> fun item -> wrap_trace item expr) expr items + +let binder2tracing_item ~base (binder : Syntax.binder) = + (let id = Ident.Lident binder.binder_name in + { + display = binder.binder_name; + expr = Ast.ident id; + loc = Rloc.to_loc ~base binder.loc_; + } + : tracing_item) + +let impl_visitor = + object (self) + inherit [_] Syntax.map as super + + method! visit_binder env binder = + let item = binder2tracing_item ~base:env.base binder in + env.tracing_list <- item :: env.tracing_list; + super#visit_binder env binder + + method! visit_Pexpr_let env pattern expr body loc_ = + env.tracing_list <- []; + let pattern = self#visit_pattern env pattern in + let tracing_list = env.tracing_list in + let expr = self#visit_expr env expr in + let body = self#visit_expr env body in + let body = wrap_traces tracing_list body in + Syntax.Pexpr_let { pattern; expr; body; loc_ } + + method! visit_Pexpr_guard_let env pat expr otherwise body loc_ = + env.tracing_list <- []; + let pat = self#visit_pattern env pat in + let vars = env.tracing_list in + let expr = self#visit_expr env expr in + let otherwise = + match otherwise with + | Some xs -> + Some + (Lst.map xs (fun { pattern = pat; guard; body = expr } -> + (env.tracing_list <- []; + let pat = self#visit_pattern env pat in + let vars = env.tracing_list in + let expr = wrap_traces vars (self#visit_expr env expr) in + { pattern = pat; guard; body = expr } + : Syntax.case))) + | None -> None + in + let body = wrap_traces vars (self#visit_expr env body) in + Syntax.Pexpr_guard_let { pat; expr; otherwise; body; loc_ } + + method! visit_Pexpr_letmut env binder ty expr body loc_ = + let expr = self#visit_expr env expr in + let body = + wrap_trace + (binder2tracing_item ~base:env.base binder) + (self#visit_expr env body) + in + Syntax.Pexpr_letmut { binder; ty; expr; body; loc_ } + + method! visit_Pexpr_match env expr cases match_loc_ loc_ = + let expr = self#visit_expr env expr in + let cases = + Lst.map cases (fun { pattern = pat; guard; body = expr } -> + (env.tracing_list <- []; + let pat = self#visit_pattern env pat in + let bindings = env.tracing_list in + let expr = wrap_traces bindings (self#visit_expr env expr) in + { pattern = pat; guard; body = expr } + : Syntax.case)) + in + Syntax.Pexpr_match { expr; cases; match_loc_; loc_ } + + method! visit_Pexpr_assign env var expr augmented_by loc_ = + let assign_expr = + super#visit_Pexpr_assign env var expr augmented_by loc_ + in + let tracing_item = + { + display = Ident.to_string var.var_name; + expr = Ast.ident var.var_name; + loc = Rloc.to_loc ~base:env.base var.loc_; + } + in + let trace_expr = generate_trace tracing_item in + Ast.sequence assign_expr trace_expr + + method! visit_impl env impl = + env.base <- Syntax.loc_of_impl impl; + super#visit_impl env impl + end + +let instrument (outputs : Parse.output list) = + (let env = { base = Loc.no_location; tracing_list = [] } in + match outputs with + | [] -> [] + | output :: outputs -> + let any_to_string_intrinsic = + Syntax.Ptop_funcdef + { + fun_decl = + { + type_name = None; + has_error = None; + decl_params = + Some + [ + Positional + { + binder = + { binder_name = "a"; loc_ = Rloc.no_location }; + ty = + Some + (Ptype_name + { + constr_id = + { + lid = Ident.Lident "A"; + loc_ = Rloc.no_location; + }; + tys = []; + loc_ = Rloc.no_location; + }); + }; + ]; + params_loc_ = Rloc.no_location; + quantifiers = + [ + { + tvar_name = "A"; + tvar_constraints = []; + loc_ = Rloc.no_location; + }; + ]; + vis = Vis_default; + is_async = false; + return_type = + Some + ( Ptype_name + { + constr_id = + { + lid = Ident.Lident "String"; + loc_ = Rloc.no_location; + }; + tys = []; + loc_ = Rloc.no_location; + }, + No_error_typ ); + name = + { binder_name = "any_to_string"; loc_ = Rloc.no_location }; + doc_ = Docstring.empty; + attrs = []; + }; + loc_ = Loc.no_location; + decl_body = + Decl_stubs + (Embedded + { + language = None; + code = + Code_string + { + string_val = "%any.to_string"; + string_repr = "%any.to_string"; + }; + }); + } + in + let output = + { output with ast = any_to_string_intrinsic :: output.ast } + in + Lst.map (output :: outputs) (fun output -> + let impls = impl_visitor#visit_impls env output.ast in + { output with ast = impls }) + : Parse.output list) diff --git a/src/w.ml b/src/w.ml index 9aef9e2..bd86286 100644 --- a/src/w.ml +++ b/src/w.ml @@ -26,9 +26,39 @@ let rec equal (x : t) (y : t) = | List ls, List ly -> (try List.for_all2 equal ls ly with _ -> false) | _ -> false +let rec map l f = + match l with + | [] -> [] + | x1 :: [] -> + let y1 = f x1 in + [ y1 ] + | [ x1; x2 ] -> + let y1 = f x1 in + let y2 = f x2 in + [ y1; y2 ] + | [ x1; x2; x3 ] -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + [ y1; y2; y3 ] + | [ x1; x2; x3; x4 ] -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + let y4 = f x4 in + [ y1; y2; y3; y4 ] + | x1 :: x2 :: x3 :: x4 :: x5 :: tail -> + let y1 = f x1 in + let y2 = f x2 in + let y3 = f x3 in + let y4 = f x4 in + let y5 = f x5 in + y1 :: y2 :: y3 :: y4 :: y5 :: map tail f +[@@tail_mod_cons] + let rec sexp_of_t = function | Atom s -> S.Atom s - | List l -> S.List (List.map sexp_of_t l) + | List l -> S.List (map l sexp_of_t) let char_hex n = Char.unsafe_chr (n + if n < 10 then Char.code '0' else Char.code 'A' - 10) @@ -114,47 +144,39 @@ open struct if not (must_escape str) then pp_print_string ppf str else pp_print_string ppf (esc_str str) - let is_ignored (str : t) ~ignores = - match (ignores, str) with - | [], _ -> false - | _, List (Atom str :: _) -> List.exists (fun x -> x = str) ignores - | _, (Atom _ | List [] | List (List _ :: _)) -> false - - let rec pp_hum_indent ~ignores indent ppf = function + let rec pp_hum_indent indent ppf = function | Atom str -> pp_hum_maybe_esc_str ppf str - | List (Atom _ :: _) as s when is_ignored s ~ignores -> () | List (h :: t) -> pp_open_box ppf indent; pp_print_string ppf "("; - pp_hum_indent ~ignores indent ppf h; - pp_hum_rest ~ignores indent ppf t + pp_hum_indent indent ppf h; + pp_hum_rest indent ppf t | List [] -> pp_print_string ppf "()" - and pp_hum_rest ~ignores indent ppf = function + and pp_hum_rest indent ppf = function | h :: t -> - if not (is_ignored h ~ignores) then ( - pp_print_space ppf (); - pp_hum_indent ~ignores indent ppf h); - pp_hum_rest ~ignores indent ppf t + pp_print_space ppf (); + pp_hum_indent indent ppf h; + pp_hum_rest indent ppf t | [] -> pp_print_string ppf ")"; pp_close_box ppf () - let to_buffer_hum ~ignores ~buf sexp = + let to_buffer_hum ~buf sexp = let indent = !default_indent in let ppf = Format.formatter_of_buffer buf in - Format.fprintf ppf "%a@?" (pp_hum_indent ~ignores indent) sexp + Format.fprintf ppf "%a@?" (pp_hum_indent indent) sexp let buffer () = Buffer.create 1024 end -let to_string ?(ignores = []) = function +let to_string = function | sexp -> let buf = buffer () in - to_buffer_hum sexp ~ignores ~buf; + to_buffer_hum sexp ~buf; Buffer.contents buf -let print ?(ignores = []) s = +let print s = Format.fprintf Format.std_formatter "@[%a@]@." - (pp_hum_indent ~ignores !default_indent) + (pp_hum_indent !default_indent) s diff --git a/src/warnings.ml b/src/warnings.ml index aec8a3c..d5562b4 100644 --- a/src/warnings.ml +++ b/src/warnings.ml @@ -11,6 +11,8 @@ not, see . *) + + type loc = Loc.t type unused_kind = Unused | No_construct | No_read @@ -35,7 +37,7 @@ type kind = | Unused_func of string | Unused_var of { var_name : string; is_toplevel : bool } | Unused_type_declaration of string - | Unused_abstract_type of string + | Unused_abstract_type of { name : string; kind : string } | Unused_tvar of string | Unused_constructor of { constr : string; kind : unused_kind } | Unused_field of string @@ -48,7 +50,11 @@ type kind = | Redundant_modifier of { modifier : string; field : string } | Struct_never_constructed of string | Unused_pat - | Partial_match of string list + | Partial_match of { + hint_cases : string list; + is_let_match : bool; + has_guard : bool; + } | Unreachable | Unresolved_tvar of string | Lowercase_type_name of string @@ -78,8 +84,19 @@ type kind = | Optional_arg_never_supplied of string | Optional_arg_always_supplied of string | Unused_import_value of string - | Deprecated_prefix_label_syntax of string | Reserved_keyword of string + | Loop_label_shadow of string + | Loop_label_unused of string + | Unused_guard + | Closed_map_pattern + | Invalid_attribute of string + | Unused_attribute of string + | Invalid_inline_wasm of string + | Implement_trait_with_method of { + trait : string; + typ : string; + methods : string list; + } include struct let _ = fun (_ : kind) -> () @@ -106,616 +123,798 @@ include struct | Unused_type_declaration arg0__012_ -> let res0__013_ = Moon_sexp_conv.sexp_of_string arg0__012_ in S.List [ S.Atom "Unused_type_declaration"; res0__013_ ] - | Unused_abstract_type arg0__014_ -> - let res0__015_ = Moon_sexp_conv.sexp_of_string arg0__014_ in - S.List [ S.Atom "Unused_abstract_type"; res0__015_ ] - | Unused_tvar arg0__016_ -> - let res0__017_ = Moon_sexp_conv.sexp_of_string arg0__016_ in - S.List [ S.Atom "Unused_tvar"; res0__017_ ] - | Unused_constructor { constr = constr__019_; kind = kind__021_ } -> - let bnds__018_ = ([] : _ Stdlib.List.t) in - let bnds__018_ = - let arg__022_ = sexp_of_unused_kind kind__021_ in - (S.List [ S.Atom "kind"; arg__022_ ] :: bnds__018_ : _ Stdlib.List.t) + | Unused_abstract_type { name = name__015_; kind = kind__017_ } -> + let bnds__014_ = ([] : _ Stdlib.List.t) in + let bnds__014_ = + let arg__018_ = Moon_sexp_conv.sexp_of_string kind__017_ in + (S.List [ S.Atom "kind"; arg__018_ ] :: bnds__014_ : _ Stdlib.List.t) in - let bnds__018_ = - let arg__020_ = Moon_sexp_conv.sexp_of_string constr__019_ in - (S.List [ S.Atom "constr"; arg__020_ ] :: bnds__018_ + let bnds__014_ = + let arg__016_ = Moon_sexp_conv.sexp_of_string name__015_ in + (S.List [ S.Atom "name"; arg__016_ ] :: bnds__014_ : _ Stdlib.List.t) + in + S.List (S.Atom "Unused_abstract_type" :: bnds__014_) + | Unused_tvar arg0__019_ -> + let res0__020_ = Moon_sexp_conv.sexp_of_string arg0__019_ in + S.List [ S.Atom "Unused_tvar"; res0__020_ ] + | Unused_constructor { constr = constr__022_; kind = kind__024_ } -> + let bnds__021_ = ([] : _ Stdlib.List.t) in + let bnds__021_ = + let arg__025_ = sexp_of_unused_kind kind__024_ in + (S.List [ S.Atom "kind"; arg__025_ ] :: bnds__021_ : _ Stdlib.List.t) + in + let bnds__021_ = + let arg__023_ = Moon_sexp_conv.sexp_of_string constr__022_ in + (S.List [ S.Atom "constr"; arg__023_ ] :: bnds__021_ : _ Stdlib.List.t) in - S.List (S.Atom "Unused_constructor" :: bnds__018_) - | Unused_field arg0__023_ -> - let res0__024_ = Moon_sexp_conv.sexp_of_string arg0__023_ in - S.List [ S.Atom "Unused_field"; res0__024_ ] - | Unused_constr_arg { constr = constr__026_; index = index__028_ } -> - let bnds__025_ = ([] : _ Stdlib.List.t) in - let bnds__025_ = - let arg__029_ = Moon_sexp_conv.sexp_of_int index__028_ in - (S.List [ S.Atom "index"; arg__029_ ] :: bnds__025_ + S.List (S.Atom "Unused_constructor" :: bnds__021_) + | Unused_field arg0__026_ -> + let res0__027_ = Moon_sexp_conv.sexp_of_string arg0__026_ in + S.List [ S.Atom "Unused_field"; res0__027_ ] + | Unused_constr_arg { constr = constr__029_; index = index__031_ } -> + let bnds__028_ = ([] : _ Stdlib.List.t) in + let bnds__028_ = + let arg__032_ = Moon_sexp_conv.sexp_of_int index__031_ in + (S.List [ S.Atom "index"; arg__032_ ] :: bnds__028_ : _ Stdlib.List.t) in - let bnds__025_ = - let arg__027_ = Moon_sexp_conv.sexp_of_string constr__026_ in - (S.List [ S.Atom "constr"; arg__027_ ] :: bnds__025_ + let bnds__028_ = + let arg__030_ = Moon_sexp_conv.sexp_of_string constr__029_ in + (S.List [ S.Atom "constr"; arg__030_ ] :: bnds__028_ : _ Stdlib.List.t) in - S.List (S.Atom "Unused_constr_arg" :: bnds__025_) + S.List (S.Atom "Unused_constr_arg" :: bnds__028_) | Unused_constr_field { - constr = constr__031_; - label = label__033_; - is_mutated = is_mutated__035_; + constr = constr__034_; + label = label__036_; + is_mutated = is_mutated__038_; } -> - let bnds__030_ = ([] : _ Stdlib.List.t) in - let bnds__030_ = - let arg__036_ = Moon_sexp_conv.sexp_of_bool is_mutated__035_ in - (S.List [ S.Atom "is_mutated"; arg__036_ ] :: bnds__030_ + let bnds__033_ = ([] : _ Stdlib.List.t) in + let bnds__033_ = + let arg__039_ = Moon_sexp_conv.sexp_of_bool is_mutated__038_ in + (S.List [ S.Atom "is_mutated"; arg__039_ ] :: bnds__033_ : _ Stdlib.List.t) in - let bnds__030_ = - let arg__034_ = Moon_sexp_conv.sexp_of_string label__033_ in - (S.List [ S.Atom "label"; arg__034_ ] :: bnds__030_ + let bnds__033_ = + let arg__037_ = Moon_sexp_conv.sexp_of_string label__036_ in + (S.List [ S.Atom "label"; arg__037_ ] :: bnds__033_ : _ Stdlib.List.t) in - let bnds__030_ = - let arg__032_ = Moon_sexp_conv.sexp_of_string constr__031_ in - (S.List [ S.Atom "constr"; arg__032_ ] :: bnds__030_ + let bnds__033_ = + let arg__035_ = Moon_sexp_conv.sexp_of_string constr__034_ in + (S.List [ S.Atom "constr"; arg__035_ ] :: bnds__033_ : _ Stdlib.List.t) in - S.List (S.Atom "Unused_constr_field" :: bnds__030_) - | Redundant_modifier { modifier = modifier__038_; field = field__040_ } -> - let bnds__037_ = ([] : _ Stdlib.List.t) in - let bnds__037_ = - let arg__041_ = Moon_sexp_conv.sexp_of_string field__040_ in - (S.List [ S.Atom "field"; arg__041_ ] :: bnds__037_ + S.List (S.Atom "Unused_constr_field" :: bnds__033_) + | Redundant_modifier { modifier = modifier__041_; field = field__043_ } -> + let bnds__040_ = ([] : _ Stdlib.List.t) in + let bnds__040_ = + let arg__044_ = Moon_sexp_conv.sexp_of_string field__043_ in + (S.List [ S.Atom "field"; arg__044_ ] :: bnds__040_ : _ Stdlib.List.t) in - let bnds__037_ = - let arg__039_ = Moon_sexp_conv.sexp_of_string modifier__038_ in - (S.List [ S.Atom "modifier"; arg__039_ ] :: bnds__037_ + let bnds__040_ = + let arg__042_ = Moon_sexp_conv.sexp_of_string modifier__041_ in + (S.List [ S.Atom "modifier"; arg__042_ ] :: bnds__040_ : _ Stdlib.List.t) in - S.List (S.Atom "Redundant_modifier" :: bnds__037_) - | Struct_never_constructed arg0__042_ -> - let res0__043_ = Moon_sexp_conv.sexp_of_string arg0__042_ in - S.List [ S.Atom "Struct_never_constructed"; res0__043_ ] + S.List (S.Atom "Redundant_modifier" :: bnds__040_) + | Struct_never_constructed arg0__045_ -> + let res0__046_ = Moon_sexp_conv.sexp_of_string arg0__045_ in + S.List [ S.Atom "Struct_never_constructed"; res0__046_ ] | Unused_pat -> S.Atom "Unused_pat" - | Partial_match arg0__044_ -> - let res0__045_ = - Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string arg0__044_ + | Partial_match + { + hint_cases = hint_cases__048_; + is_let_match = is_let_match__050_; + has_guard = has_guard__052_; + } -> + let bnds__047_ = ([] : _ Stdlib.List.t) in + let bnds__047_ = + let arg__053_ = Moon_sexp_conv.sexp_of_bool has_guard__052_ in + (S.List [ S.Atom "has_guard"; arg__053_ ] :: bnds__047_ + : _ Stdlib.List.t) + in + let bnds__047_ = + let arg__051_ = Moon_sexp_conv.sexp_of_bool is_let_match__050_ in + (S.List [ S.Atom "is_let_match"; arg__051_ ] :: bnds__047_ + : _ Stdlib.List.t) + in + let bnds__047_ = + let arg__049_ = + Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string + hint_cases__048_ + in + (S.List [ S.Atom "hint_cases"; arg__049_ ] :: bnds__047_ + : _ Stdlib.List.t) in - S.List [ S.Atom "Partial_match"; res0__045_ ] + S.List (S.Atom "Partial_match" :: bnds__047_) | Unreachable -> S.Atom "Unreachable" - | Unresolved_tvar arg0__046_ -> - let res0__047_ = Moon_sexp_conv.sexp_of_string arg0__046_ in - S.List [ S.Atom "Unresolved_tvar"; res0__047_ ] - | Lowercase_type_name arg0__048_ -> - let res0__049_ = Moon_sexp_conv.sexp_of_string arg0__048_ in - S.List [ S.Atom "Lowercase_type_name"; res0__049_ ] - | Unused_mutability arg0__050_ -> - let res0__051_ = Moon_sexp_conv.sexp_of_string arg0__050_ in - S.List [ S.Atom "Unused_mutability"; res0__051_ ] + | Unresolved_tvar arg0__054_ -> + let res0__055_ = Moon_sexp_conv.sexp_of_string arg0__054_ in + S.List [ S.Atom "Unresolved_tvar"; res0__055_ ] + | Lowercase_type_name arg0__056_ -> + let res0__057_ = Moon_sexp_conv.sexp_of_string arg0__056_ in + S.List [ S.Atom "Lowercase_type_name"; res0__057_ ] + | Unused_mutability arg0__058_ -> + let res0__059_ = Moon_sexp_conv.sexp_of_string arg0__058_ in + S.List [ S.Atom "Unused_mutability"; res0__059_ ] | Parser_inconsistency { - file_name = file_name__053_; - segment = segment__055_; - is_menhir_succeed = is_menhir_succeed__057_; - is_handrolled_succeed = is_handrolled_succeed__059_; + file_name = file_name__061_; + segment = segment__063_; + is_menhir_succeed = is_menhir_succeed__065_; + is_handrolled_succeed = is_handrolled_succeed__067_; } -> - let bnds__052_ = ([] : _ Stdlib.List.t) in - let bnds__052_ = - let arg__060_ = - Moon_sexp_conv.sexp_of_bool is_handrolled_succeed__059_ + let bnds__060_ = ([] : _ Stdlib.List.t) in + let bnds__060_ = + let arg__068_ = + Moon_sexp_conv.sexp_of_bool is_handrolled_succeed__067_ in - (S.List [ S.Atom "is_handrolled_succeed"; arg__060_ ] :: bnds__052_ + (S.List [ S.Atom "is_handrolled_succeed"; arg__068_ ] :: bnds__060_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__058_ = - Moon_sexp_conv.sexp_of_bool is_menhir_succeed__057_ + let bnds__060_ = + let arg__066_ = + Moon_sexp_conv.sexp_of_bool is_menhir_succeed__065_ in - (S.List [ S.Atom "is_menhir_succeed"; arg__058_ ] :: bnds__052_ + (S.List [ S.Atom "is_menhir_succeed"; arg__066_ ] :: bnds__060_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__056_ = Moon_sexp_conv.sexp_of_string segment__055_ in - (S.List [ S.Atom "segment"; arg__056_ ] :: bnds__052_ + let bnds__060_ = + let arg__064_ = Moon_sexp_conv.sexp_of_string segment__063_ in + (S.List [ S.Atom "segment"; arg__064_ ] :: bnds__060_ : _ Stdlib.List.t) in - let bnds__052_ = - let arg__054_ = Moon_sexp_conv.sexp_of_string file_name__053_ in - (S.List [ S.Atom "file_name"; arg__054_ ] :: bnds__052_ + let bnds__060_ = + let arg__062_ = Moon_sexp_conv.sexp_of_string file_name__061_ in + (S.List [ S.Atom "file_name"; arg__062_ ] :: bnds__060_ : _ Stdlib.List.t) in - S.List (S.Atom "Parser_inconsistency" :: bnds__052_) + S.List (S.Atom "Parser_inconsistency" :: bnds__060_) | Useless_loop -> S.Atom "Useless_loop" | Toplevel_not_left_aligned -> S.Atom "Toplevel_not_left_aligned" - | Unexpected_pragmas arg0__061_ -> - let res0__062_ = Moon_sexp_conv.sexp_of_string arg0__061_ in - S.List [ S.Atom "Unexpected_pragmas"; res0__062_ ] - | Omitted_constr_argument { constr = constr__064_; labels = labels__066_ } + | Unexpected_pragmas arg0__069_ -> + let res0__070_ = Moon_sexp_conv.sexp_of_string arg0__069_ in + S.List [ S.Atom "Unexpected_pragmas"; res0__070_ ] + | Omitted_constr_argument { constr = constr__072_; labels = labels__074_ } -> - let bnds__063_ = ([] : _ Stdlib.List.t) in - let bnds__063_ = - let arg__067_ = + let bnds__071_ = ([] : _ Stdlib.List.t) in + let bnds__071_ = + let arg__075_ = Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string - labels__066_ + labels__074_ in - (S.List [ S.Atom "labels"; arg__067_ ] :: bnds__063_ + (S.List [ S.Atom "labels"; arg__075_ ] :: bnds__071_ : _ Stdlib.List.t) in - let bnds__063_ = - let arg__065_ = Moon_sexp_conv.sexp_of_string constr__064_ in - (S.List [ S.Atom "constr"; arg__065_ ] :: bnds__063_ + let bnds__071_ = + let arg__073_ = Moon_sexp_conv.sexp_of_string constr__072_ in + (S.List [ S.Atom "constr"; arg__073_ ] :: bnds__071_ : _ Stdlib.List.t) in - S.List (S.Atom "Omitted_constr_argument" :: bnds__063_) + S.List (S.Atom "Omitted_constr_argument" :: bnds__071_) | Ambiguous_block -> S.Atom "Ambiguous_block" | Useless_try -> S.Atom "Useless_try" | Useless_error_type -> S.Atom "Useless_error_type" | Useless_catch_all -> S.Atom "Useless_catch_all" | Deprecated_syntax { - old_usage = old_usage__069_; - purpose = purpose__071_; - new_usage = new_usage__073_; + old_usage = old_usage__077_; + purpose = purpose__079_; + new_usage = new_usage__081_; } -> - let bnds__068_ = ([] : _ Stdlib.List.t) in - let bnds__068_ = - let arg__074_ = + let bnds__076_ = ([] : _ Stdlib.List.t) in + let bnds__076_ = + let arg__082_ = Moon_sexp_conv.sexp_of_option Moon_sexp_conv.sexp_of_string - new_usage__073_ + new_usage__081_ in - (S.List [ S.Atom "new_usage"; arg__074_ ] :: bnds__068_ + (S.List [ S.Atom "new_usage"; arg__082_ ] :: bnds__076_ : _ Stdlib.List.t) in - let bnds__068_ = - let arg__072_ = Moon_sexp_conv.sexp_of_string purpose__071_ in - (S.List [ S.Atom "purpose"; arg__072_ ] :: bnds__068_ + let bnds__076_ = + let arg__080_ = Moon_sexp_conv.sexp_of_string purpose__079_ in + (S.List [ S.Atom "purpose"; arg__080_ ] :: bnds__076_ : _ Stdlib.List.t) in - let bnds__068_ = - let arg__070_ = Moon_sexp_conv.sexp_of_string old_usage__069_ in - (S.List [ S.Atom "old_usage"; arg__070_ ] :: bnds__068_ + let bnds__076_ = + let arg__078_ = Moon_sexp_conv.sexp_of_string old_usage__077_ in + (S.List [ S.Atom "old_usage"; arg__078_ ] :: bnds__076_ : _ Stdlib.List.t) in - S.List (S.Atom "Deprecated_syntax" :: bnds__068_) + S.List (S.Atom "Deprecated_syntax" :: bnds__076_) | Todo -> S.Atom "Todo" - | Unused_package { name = name__076_; is_alias = is_alias__078_ } -> - let bnds__075_ = ([] : _ Stdlib.List.t) in - let bnds__075_ = - let arg__079_ = Moon_sexp_conv.sexp_of_bool is_alias__078_ in - (S.List [ S.Atom "is_alias"; arg__079_ ] :: bnds__075_ + | Unused_package { name = name__084_; is_alias = is_alias__086_ } -> + let bnds__083_ = ([] : _ Stdlib.List.t) in + let bnds__083_ = + let arg__087_ = Moon_sexp_conv.sexp_of_bool is_alias__086_ in + (S.List [ S.Atom "is_alias"; arg__087_ ] :: bnds__083_ : _ Stdlib.List.t) in - let bnds__075_ = - let arg__077_ = Moon_sexp_conv.sexp_of_string name__076_ in - (S.List [ S.Atom "name"; arg__077_ ] :: bnds__075_ : _ Stdlib.List.t) + let bnds__083_ = + let arg__085_ = Moon_sexp_conv.sexp_of_string name__084_ in + (S.List [ S.Atom "name"; arg__085_ ] :: bnds__083_ : _ Stdlib.List.t) in - S.List (S.Atom "Unused_package" :: bnds__075_) + S.List (S.Atom "Unused_package" :: bnds__083_) | Empty_package_alias -> S.Atom "Empty_package_alias" - | Optional_arg_never_supplied arg0__080_ -> - let res0__081_ = Moon_sexp_conv.sexp_of_string arg0__080_ in - S.List [ S.Atom "Optional_arg_never_supplied"; res0__081_ ] - | Optional_arg_always_supplied arg0__082_ -> - let res0__083_ = Moon_sexp_conv.sexp_of_string arg0__082_ in - S.List [ S.Atom "Optional_arg_always_supplied"; res0__083_ ] - | Unused_import_value arg0__084_ -> - let res0__085_ = Moon_sexp_conv.sexp_of_string arg0__084_ in - S.List [ S.Atom "Unused_import_value"; res0__085_ ] - | Deprecated_prefix_label_syntax arg0__086_ -> - let res0__087_ = Moon_sexp_conv.sexp_of_string arg0__086_ in - S.List [ S.Atom "Deprecated_prefix_label_syntax"; res0__087_ ] - | Reserved_keyword arg0__088_ -> + | Optional_arg_never_supplied arg0__088_ -> let res0__089_ = Moon_sexp_conv.sexp_of_string arg0__088_ in - S.List [ S.Atom "Reserved_keyword"; res0__089_ ] + S.List [ S.Atom "Optional_arg_never_supplied"; res0__089_ ] + | Optional_arg_always_supplied arg0__090_ -> + let res0__091_ = Moon_sexp_conv.sexp_of_string arg0__090_ in + S.List [ S.Atom "Optional_arg_always_supplied"; res0__091_ ] + | Unused_import_value arg0__092_ -> + let res0__093_ = Moon_sexp_conv.sexp_of_string arg0__092_ in + S.List [ S.Atom "Unused_import_value"; res0__093_ ] + | Reserved_keyword arg0__094_ -> + let res0__095_ = Moon_sexp_conv.sexp_of_string arg0__094_ in + S.List [ S.Atom "Reserved_keyword"; res0__095_ ] + | Loop_label_shadow arg0__096_ -> + let res0__097_ = Moon_sexp_conv.sexp_of_string arg0__096_ in + S.List [ S.Atom "Loop_label_shadow"; res0__097_ ] + | Loop_label_unused arg0__098_ -> + let res0__099_ = Moon_sexp_conv.sexp_of_string arg0__098_ in + S.List [ S.Atom "Loop_label_unused"; res0__099_ ] + | Unused_guard -> S.Atom "Unused_guard" + | Closed_map_pattern -> S.Atom "Closed_map_pattern" + | Invalid_attribute arg0__100_ -> + let res0__101_ = Moon_sexp_conv.sexp_of_string arg0__100_ in + S.List [ S.Atom "Invalid_attribute"; res0__101_ ] + | Unused_attribute arg0__102_ -> + let res0__103_ = Moon_sexp_conv.sexp_of_string arg0__102_ in + S.List [ S.Atom "Unused_attribute"; res0__103_ ] + | Invalid_inline_wasm arg0__104_ -> + let res0__105_ = Moon_sexp_conv.sexp_of_string arg0__104_ in + S.List [ S.Atom "Invalid_inline_wasm"; res0__105_ ] + | Implement_trait_with_method + { trait = trait__107_; typ = typ__109_; methods = methods__111_ } -> + let bnds__106_ = ([] : _ Stdlib.List.t) in + let bnds__106_ = + let arg__112_ = + Moon_sexp_conv.sexp_of_list Moon_sexp_conv.sexp_of_string + methods__111_ + in + (S.List [ S.Atom "methods"; arg__112_ ] :: bnds__106_ + : _ Stdlib.List.t) + in + let bnds__106_ = + let arg__110_ = Moon_sexp_conv.sexp_of_string typ__109_ in + (S.List [ S.Atom "typ"; arg__110_ ] :: bnds__106_ : _ Stdlib.List.t) + in + let bnds__106_ = + let arg__108_ = Moon_sexp_conv.sexp_of_string trait__107_ in + (S.List [ S.Atom "trait"; arg__108_ ] :: bnds__106_ + : _ Stdlib.List.t) + in + S.List (S.Atom "Implement_trait_with_method" :: bnds__106_) : kind -> S.t) let _ = sexp_of_kind let compare_kind = - (fun a__090_ b__091_ -> - if Stdlib.( == ) a__090_ b__091_ then 0 - else - match (a__090_, b__091_) with - | Unused_func _a__092_, Unused_func _b__093_ -> - Stdlib.compare (_a__092_ : string) _b__093_ - | Unused_func _, _ -> -1 - | _, Unused_func _ -> 1 - | Unused_var _a__094_, Unused_var _b__095_ -> ( - match - Stdlib.compare (_a__094_.var_name : string) _b__095_.var_name - with - | 0 -> - Stdlib.compare - (_a__094_.is_toplevel : bool) - _b__095_.is_toplevel - | n -> n) - | Unused_var _, _ -> -1 - | _, Unused_var _ -> 1 - | Unused_type_declaration _a__096_, Unused_type_declaration _b__097_ -> - Stdlib.compare (_a__096_ : string) _b__097_ - | Unused_type_declaration _, _ -> -1 - | _, Unused_type_declaration _ -> 1 - | Unused_abstract_type _a__098_, Unused_abstract_type _b__099_ -> - Stdlib.compare (_a__098_ : string) _b__099_ - | Unused_abstract_type _, _ -> -1 - | _, Unused_abstract_type _ -> 1 - | Unused_tvar _a__100_, Unused_tvar _b__101_ -> - Stdlib.compare (_a__100_ : string) _b__101_ - | Unused_tvar _, _ -> -1 - | _, Unused_tvar _ -> 1 - | Unused_constructor _a__102_, Unused_constructor _b__103_ -> ( - match - Stdlib.compare (_a__102_.constr : string) _b__103_.constr - with - | 0 -> compare_unused_kind _a__102_.kind _b__103_.kind - | n -> n) - | Unused_constructor _, _ -> -1 - | _, Unused_constructor _ -> 1 - | Unused_field _a__104_, Unused_field _b__105_ -> - Stdlib.compare (_a__104_ : string) _b__105_ - | Unused_field _, _ -> -1 - | _, Unused_field _ -> 1 - | Unused_constr_arg _a__106_, Unused_constr_arg _b__107_ -> ( - match - Stdlib.compare (_a__106_.constr : string) _b__107_.constr - with - | 0 -> Stdlib.compare (_a__106_.index : int) _b__107_.index - | n -> n) - | Unused_constr_arg _, _ -> -1 - | _, Unused_constr_arg _ -> 1 - | Unused_constr_field _a__108_, Unused_constr_field _b__109_ -> ( - match - Stdlib.compare (_a__108_.constr : string) _b__109_.constr - with - | 0 -> ( - match - Stdlib.compare (_a__108_.label : string) _b__109_.label - with - | 0 -> - Stdlib.compare - (_a__108_.is_mutated : bool) - _b__109_.is_mutated - | n -> n) - | n -> n) - | Unused_constr_field _, _ -> -1 - | _, Unused_constr_field _ -> 1 - | Redundant_modifier _a__110_, Redundant_modifier _b__111_ -> ( - match - Stdlib.compare (_a__110_.modifier : string) _b__111_.modifier - with - | 0 -> Stdlib.compare (_a__110_.field : string) _b__111_.field - | n -> n) - | Redundant_modifier _, _ -> -1 - | _, Redundant_modifier _ -> 1 - | Struct_never_constructed _a__112_, Struct_never_constructed _b__113_ - -> - Stdlib.compare (_a__112_ : string) _b__113_ - | Struct_never_constructed _, _ -> -1 - | _, Struct_never_constructed _ -> 1 - | Unused_pat, Unused_pat -> 0 - | Unused_pat, _ -> -1 - | _, Unused_pat -> 1 - | Partial_match _a__114_, Partial_match _b__115_ -> - Ppx_base.compare_list - (fun a__116_ b__117_ -> - Stdlib.compare (a__116_ : string) b__117_) - _a__114_ _b__115_ - | Partial_match _, _ -> -1 - | _, Partial_match _ -> 1 - | Unreachable, Unreachable -> 0 - | Unreachable, _ -> -1 - | _, Unreachable -> 1 - | Unresolved_tvar _a__118_, Unresolved_tvar _b__119_ -> - Stdlib.compare (_a__118_ : string) _b__119_ - | Unresolved_tvar _, _ -> -1 - | _, Unresolved_tvar _ -> 1 - | Lowercase_type_name _a__120_, Lowercase_type_name _b__121_ -> - Stdlib.compare (_a__120_ : string) _b__121_ - | Lowercase_type_name _, _ -> -1 - | _, Lowercase_type_name _ -> 1 - | Unused_mutability _a__122_, Unused_mutability _b__123_ -> - Stdlib.compare (_a__122_ : string) _b__123_ - | Unused_mutability _, _ -> -1 - | _, Unused_mutability _ -> 1 - | Parser_inconsistency _a__124_, Parser_inconsistency _b__125_ -> ( - match - Stdlib.compare (_a__124_.file_name : string) _b__125_.file_name - with - | 0 -> ( - match - Stdlib.compare (_a__124_.segment : string) _b__125_.segment - with - | 0 -> ( - match - Stdlib.compare - (_a__124_.is_menhir_succeed : bool) - _b__125_.is_menhir_succeed - with - | 0 -> - Stdlib.compare - (_a__124_.is_handrolled_succeed : bool) - _b__125_.is_handrolled_succeed - | n -> n) - | n -> n) - | n -> n) - | Parser_inconsistency _, _ -> -1 - | _, Parser_inconsistency _ -> 1 - | Useless_loop, Useless_loop -> 0 - | Useless_loop, _ -> -1 - | _, Useless_loop -> 1 - | Toplevel_not_left_aligned, Toplevel_not_left_aligned -> 0 - | Toplevel_not_left_aligned, _ -> -1 - | _, Toplevel_not_left_aligned -> 1 - | Unexpected_pragmas _a__126_, Unexpected_pragmas _b__127_ -> - Stdlib.compare (_a__126_ : string) _b__127_ - | Unexpected_pragmas _, _ -> -1 - | _, Unexpected_pragmas _ -> 1 - | Omitted_constr_argument _a__128_, Omitted_constr_argument _b__129_ - -> ( - match - Stdlib.compare (_a__128_.constr : string) _b__129_.constr - with - | 0 -> - Ppx_base.compare_list - (fun a__130_ b__131_ -> - Stdlib.compare (a__130_ : string) b__131_) - _a__128_.labels _b__129_.labels - | n -> n) - | Omitted_constr_argument _, _ -> -1 - | _, Omitted_constr_argument _ -> 1 - | Ambiguous_block, Ambiguous_block -> 0 - | Ambiguous_block, _ -> -1 - | _, Ambiguous_block -> 1 - | Useless_try, Useless_try -> 0 - | Useless_try, _ -> -1 - | _, Useless_try -> 1 - | Useless_error_type, Useless_error_type -> 0 - | Useless_error_type, _ -> -1 - | _, Useless_error_type -> 1 - | Useless_catch_all, Useless_catch_all -> 0 - | Useless_catch_all, _ -> -1 - | _, Useless_catch_all -> 1 - | Deprecated_syntax _a__132_, Deprecated_syntax _b__133_ -> ( - match - Stdlib.compare (_a__132_.old_usage : string) _b__133_.old_usage - with - | 0 -> ( - match - Stdlib.compare (_a__132_.purpose : string) _b__133_.purpose - with - | 0 -> ( - match (_a__132_.new_usage, _b__133_.new_usage) with - | None, None -> 0 - | None, Some _ -> -1 - | Some _, None -> 1 - | Some __option_x, Some __option_y -> - (fun a__134_ b__135_ -> - Stdlib.compare (a__134_ : string) b__135_) - __option_x __option_y) - | n -> n) - | n -> n) - | Deprecated_syntax _, _ -> -1 - | _, Deprecated_syntax _ -> 1 - | Todo, Todo -> 0 - | Todo, _ -> -1 - | _, Todo -> 1 - | Unused_package _a__136_, Unused_package _b__137_ -> ( - match Stdlib.compare (_a__136_.name : string) _b__137_.name with - | 0 -> Stdlib.compare (_a__136_.is_alias : bool) _b__137_.is_alias - | n -> n) - | Unused_package _, _ -> -1 - | _, Unused_package _ -> 1 - | Empty_package_alias, Empty_package_alias -> 0 - | Empty_package_alias, _ -> -1 - | _, Empty_package_alias -> 1 - | ( Optional_arg_never_supplied _a__138_, - Optional_arg_never_supplied _b__139_ ) -> - Stdlib.compare (_a__138_ : string) _b__139_ - | Optional_arg_never_supplied _, _ -> -1 - | _, Optional_arg_never_supplied _ -> 1 - | ( Optional_arg_always_supplied _a__140_, - Optional_arg_always_supplied _b__141_ ) -> - Stdlib.compare (_a__140_ : string) _b__141_ - | Optional_arg_always_supplied _, _ -> -1 - | _, Optional_arg_always_supplied _ -> 1 - | Unused_import_value _a__142_, Unused_import_value _b__143_ -> - Stdlib.compare (_a__142_ : string) _b__143_ - | Unused_import_value _, _ -> -1 - | _, Unused_import_value _ -> 1 - | ( Deprecated_prefix_label_syntax _a__144_, - Deprecated_prefix_label_syntax _b__145_ ) -> - Stdlib.compare (_a__144_ : string) _b__145_ - | Deprecated_prefix_label_syntax _, _ -> -1 - | _, Deprecated_prefix_label_syntax _ -> 1 - | Reserved_keyword _a__146_, Reserved_keyword _b__147_ -> - Stdlib.compare (_a__146_ : string) _b__147_ + (fun a__113_ -> + fun b__114_ -> + if Stdlib.( == ) a__113_ b__114_ then 0 + else + match (a__113_, b__114_) with + | Unused_func _a__115_, Unused_func _b__116_ -> + Stdlib.compare (_a__115_ : string) _b__116_ + | Unused_func _, _ -> -1 + | _, Unused_func _ -> 1 + | Unused_var _a__117_, Unused_var _b__118_ -> ( + match + Stdlib.compare (_a__117_.var_name : string) _b__118_.var_name + with + | 0 -> + Stdlib.compare + (_a__117_.is_toplevel : bool) + _b__118_.is_toplevel + | n -> n) + | Unused_var _, _ -> -1 + | _, Unused_var _ -> 1 + | Unused_type_declaration _a__119_, Unused_type_declaration _b__120_ + -> + Stdlib.compare (_a__119_ : string) _b__120_ + | Unused_type_declaration _, _ -> -1 + | _, Unused_type_declaration _ -> 1 + | Unused_abstract_type _a__121_, Unused_abstract_type _b__122_ -> ( + match Stdlib.compare (_a__121_.name : string) _b__122_.name with + | 0 -> Stdlib.compare (_a__121_.kind : string) _b__122_.kind + | n -> n) + | Unused_abstract_type _, _ -> -1 + | _, Unused_abstract_type _ -> 1 + | Unused_tvar _a__123_, Unused_tvar _b__124_ -> + Stdlib.compare (_a__123_ : string) _b__124_ + | Unused_tvar _, _ -> -1 + | _, Unused_tvar _ -> 1 + | Unused_constructor _a__125_, Unused_constructor _b__126_ -> ( + match + Stdlib.compare (_a__125_.constr : string) _b__126_.constr + with + | 0 -> compare_unused_kind _a__125_.kind _b__126_.kind + | n -> n) + | Unused_constructor _, _ -> -1 + | _, Unused_constructor _ -> 1 + | Unused_field _a__127_, Unused_field _b__128_ -> + Stdlib.compare (_a__127_ : string) _b__128_ + | Unused_field _, _ -> -1 + | _, Unused_field _ -> 1 + | Unused_constr_arg _a__129_, Unused_constr_arg _b__130_ -> ( + match + Stdlib.compare (_a__129_.constr : string) _b__130_.constr + with + | 0 -> Stdlib.compare (_a__129_.index : int) _b__130_.index + | n -> n) + | Unused_constr_arg _, _ -> -1 + | _, Unused_constr_arg _ -> 1 + | Unused_constr_field _a__131_, Unused_constr_field _b__132_ -> ( + match + Stdlib.compare (_a__131_.constr : string) _b__132_.constr + with + | 0 -> ( + match + Stdlib.compare (_a__131_.label : string) _b__132_.label + with + | 0 -> + Stdlib.compare + (_a__131_.is_mutated : bool) + _b__132_.is_mutated + | n -> n) + | n -> n) + | Unused_constr_field _, _ -> -1 + | _, Unused_constr_field _ -> 1 + | Redundant_modifier _a__133_, Redundant_modifier _b__134_ -> ( + match + Stdlib.compare (_a__133_.modifier : string) _b__134_.modifier + with + | 0 -> Stdlib.compare (_a__133_.field : string) _b__134_.field + | n -> n) + | Redundant_modifier _, _ -> -1 + | _, Redundant_modifier _ -> 1 + | Struct_never_constructed _a__135_, Struct_never_constructed _b__136_ + -> + Stdlib.compare (_a__135_ : string) _b__136_ + | Struct_never_constructed _, _ -> -1 + | _, Struct_never_constructed _ -> 1 + | Unused_pat, Unused_pat -> 0 + | Unused_pat, _ -> -1 + | _, Unused_pat -> 1 + | Partial_match _a__137_, Partial_match _b__138_ -> ( + match + Ppx_base.compare_list + (fun a__139_ -> + fun (b__140_ [@merlin.hide]) -> + (Stdlib.compare (a__139_ : string) b__140_ [@merlin.hide])) + _a__137_.hint_cases _b__138_.hint_cases + with + | 0 -> ( + match + Stdlib.compare + (_a__137_.is_let_match : bool) + _b__138_.is_let_match + with + | 0 -> + Stdlib.compare + (_a__137_.has_guard : bool) + _b__138_.has_guard + | n -> n) + | n -> n) + | Partial_match _, _ -> -1 + | _, Partial_match _ -> 1 + | Unreachable, Unreachable -> 0 + | Unreachable, _ -> -1 + | _, Unreachable -> 1 + | Unresolved_tvar _a__141_, Unresolved_tvar _b__142_ -> + Stdlib.compare (_a__141_ : string) _b__142_ + | Unresolved_tvar _, _ -> -1 + | _, Unresolved_tvar _ -> 1 + | Lowercase_type_name _a__143_, Lowercase_type_name _b__144_ -> + Stdlib.compare (_a__143_ : string) _b__144_ + | Lowercase_type_name _, _ -> -1 + | _, Lowercase_type_name _ -> 1 + | Unused_mutability _a__145_, Unused_mutability _b__146_ -> + Stdlib.compare (_a__145_ : string) _b__146_ + | Unused_mutability _, _ -> -1 + | _, Unused_mutability _ -> 1 + | Parser_inconsistency _a__147_, Parser_inconsistency _b__148_ -> ( + match + Stdlib.compare (_a__147_.file_name : string) _b__148_.file_name + with + | 0 -> ( + match + Stdlib.compare (_a__147_.segment : string) _b__148_.segment + with + | 0 -> ( + match + Stdlib.compare + (_a__147_.is_menhir_succeed : bool) + _b__148_.is_menhir_succeed + with + | 0 -> + Stdlib.compare + (_a__147_.is_handrolled_succeed : bool) + _b__148_.is_handrolled_succeed + | n -> n) + | n -> n) + | n -> n) + | Parser_inconsistency _, _ -> -1 + | _, Parser_inconsistency _ -> 1 + | Useless_loop, Useless_loop -> 0 + | Useless_loop, _ -> -1 + | _, Useless_loop -> 1 + | Toplevel_not_left_aligned, Toplevel_not_left_aligned -> 0 + | Toplevel_not_left_aligned, _ -> -1 + | _, Toplevel_not_left_aligned -> 1 + | Unexpected_pragmas _a__149_, Unexpected_pragmas _b__150_ -> + Stdlib.compare (_a__149_ : string) _b__150_ + | Unexpected_pragmas _, _ -> -1 + | _, Unexpected_pragmas _ -> 1 + | Omitted_constr_argument _a__151_, Omitted_constr_argument _b__152_ + -> ( + match + Stdlib.compare (_a__151_.constr : string) _b__152_.constr + with + | 0 -> + Ppx_base.compare_list + (fun a__153_ -> + fun (b__154_ [@merlin.hide]) -> + (Stdlib.compare + (a__153_ : string) + b__154_ [@merlin.hide])) + _a__151_.labels _b__152_.labels + | n -> n) + | Omitted_constr_argument _, _ -> -1 + | _, Omitted_constr_argument _ -> 1 + | Ambiguous_block, Ambiguous_block -> 0 + | Ambiguous_block, _ -> -1 + | _, Ambiguous_block -> 1 + | Useless_try, Useless_try -> 0 + | Useless_try, _ -> -1 + | _, Useless_try -> 1 + | Useless_error_type, Useless_error_type -> 0 + | Useless_error_type, _ -> -1 + | _, Useless_error_type -> 1 + | Useless_catch_all, Useless_catch_all -> 0 + | Useless_catch_all, _ -> -1 + | _, Useless_catch_all -> 1 + | Deprecated_syntax _a__155_, Deprecated_syntax _b__156_ -> ( + match + Stdlib.compare (_a__155_.old_usage : string) _b__156_.old_usage + with + | 0 -> ( + match + Stdlib.compare (_a__155_.purpose : string) _b__156_.purpose + with + | 0 -> ( + match (_a__155_.new_usage, _b__156_.new_usage) with + | None, None -> 0 + | None, Some _ -> -1 + | Some _, None -> 1 + | Some __option_x, Some __option_y -> + (fun a__157_ -> + fun (b__158_ [@merlin.hide]) -> + (Stdlib.compare + (a__157_ : string) + b__158_ [@merlin.hide])) + __option_x __option_y) + | n -> n) + | n -> n) + | Deprecated_syntax _, _ -> -1 + | _, Deprecated_syntax _ -> 1 + | Todo, Todo -> 0 + | Todo, _ -> -1 + | _, Todo -> 1 + | Unused_package _a__159_, Unused_package _b__160_ -> ( + match Stdlib.compare (_a__159_.name : string) _b__160_.name with + | 0 -> Stdlib.compare (_a__159_.is_alias : bool) _b__160_.is_alias + | n -> n) + | Unused_package _, _ -> -1 + | _, Unused_package _ -> 1 + | Empty_package_alias, Empty_package_alias -> 0 + | Empty_package_alias, _ -> -1 + | _, Empty_package_alias -> 1 + | ( Optional_arg_never_supplied _a__161_, + Optional_arg_never_supplied _b__162_ ) -> + Stdlib.compare (_a__161_ : string) _b__162_ + | Optional_arg_never_supplied _, _ -> -1 + | _, Optional_arg_never_supplied _ -> 1 + | ( Optional_arg_always_supplied _a__163_, + Optional_arg_always_supplied _b__164_ ) -> + Stdlib.compare (_a__163_ : string) _b__164_ + | Optional_arg_always_supplied _, _ -> -1 + | _, Optional_arg_always_supplied _ -> 1 + | Unused_import_value _a__165_, Unused_import_value _b__166_ -> + Stdlib.compare (_a__165_ : string) _b__166_ + | Unused_import_value _, _ -> -1 + | _, Unused_import_value _ -> 1 + | Reserved_keyword _a__167_, Reserved_keyword _b__168_ -> + Stdlib.compare (_a__167_ : string) _b__168_ + | Reserved_keyword _, _ -> -1 + | _, Reserved_keyword _ -> 1 + | Loop_label_shadow _a__169_, Loop_label_shadow _b__170_ -> + Stdlib.compare (_a__169_ : string) _b__170_ + | Loop_label_shadow _, _ -> -1 + | _, Loop_label_shadow _ -> 1 + | Loop_label_unused _a__171_, Loop_label_unused _b__172_ -> + Stdlib.compare (_a__171_ : string) _b__172_ + | Loop_label_unused _, _ -> -1 + | _, Loop_label_unused _ -> 1 + | Unused_guard, Unused_guard -> 0 + | Unused_guard, _ -> -1 + | _, Unused_guard -> 1 + | Closed_map_pattern, Closed_map_pattern -> 0 + | Closed_map_pattern, _ -> -1 + | _, Closed_map_pattern -> 1 + | Invalid_attribute _a__173_, Invalid_attribute _b__174_ -> + Stdlib.compare (_a__173_ : string) _b__174_ + | Invalid_attribute _, _ -> -1 + | _, Invalid_attribute _ -> 1 + | Unused_attribute _a__175_, Unused_attribute _b__176_ -> + Stdlib.compare (_a__175_ : string) _b__176_ + | Unused_attribute _, _ -> -1 + | _, Unused_attribute _ -> 1 + | Invalid_inline_wasm _a__177_, Invalid_inline_wasm _b__178_ -> + Stdlib.compare (_a__177_ : string) _b__178_ + | Invalid_inline_wasm _, _ -> -1 + | _, Invalid_inline_wasm _ -> 1 + | ( Implement_trait_with_method _a__179_, + Implement_trait_with_method _b__180_ ) -> ( + match Stdlib.compare (_a__179_.trait : string) _b__180_.trait with + | 0 -> ( + match Stdlib.compare (_a__179_.typ : string) _b__180_.typ with + | 0 -> + Ppx_base.compare_list + (fun a__181_ -> + fun (b__182_ [@merlin.hide]) -> + (Stdlib.compare + (a__181_ : string) + b__182_ [@merlin.hide])) + _a__179_.methods _b__180_.methods + | n -> n) + | n -> n) : kind -> kind -> int) let _ = compare_kind let equal_kind = - (fun a__148_ b__149_ -> - if Stdlib.( == ) a__148_ b__149_ then true - else - match (a__148_, b__149_) with - | Unused_func _a__150_, Unused_func _b__151_ -> - Stdlib.( = ) (_a__150_ : string) _b__151_ - | Unused_func _, _ -> false - | _, Unused_func _ -> false - | Unused_var _a__152_, Unused_var _b__153_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__152_.var_name : string) _b__153_.var_name) - (Stdlib.( = ) (_a__152_.is_toplevel : bool) _b__153_.is_toplevel) - | Unused_var _, _ -> false - | _, Unused_var _ -> false - | Unused_type_declaration _a__154_, Unused_type_declaration _b__155_ -> - Stdlib.( = ) (_a__154_ : string) _b__155_ - | Unused_type_declaration _, _ -> false - | _, Unused_type_declaration _ -> false - | Unused_abstract_type _a__156_, Unused_abstract_type _b__157_ -> - Stdlib.( = ) (_a__156_ : string) _b__157_ - | Unused_abstract_type _, _ -> false - | _, Unused_abstract_type _ -> false - | Unused_tvar _a__158_, Unused_tvar _b__159_ -> - Stdlib.( = ) (_a__158_ : string) _b__159_ - | Unused_tvar _, _ -> false - | _, Unused_tvar _ -> false - | Unused_constructor _a__160_, Unused_constructor _b__161_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__160_.constr : string) _b__161_.constr) - (equal_unused_kind _a__160_.kind _b__161_.kind) - | Unused_constructor _, _ -> false - | _, Unused_constructor _ -> false - | Unused_field _a__162_, Unused_field _b__163_ -> - Stdlib.( = ) (_a__162_ : string) _b__163_ - | Unused_field _, _ -> false - | _, Unused_field _ -> false - | Unused_constr_arg _a__164_, Unused_constr_arg _b__165_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__164_.constr : string) _b__165_.constr) - (Stdlib.( = ) (_a__164_.index : int) _b__165_.index) - | Unused_constr_arg _, _ -> false - | _, Unused_constr_arg _ -> false - | Unused_constr_field _a__166_, Unused_constr_field _b__167_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__166_.constr : string) _b__167_.constr) - (Stdlib.( && ) - (Stdlib.( = ) (_a__166_.label : string) _b__167_.label) - (Stdlib.( = ) - (_a__166_.is_mutated : bool) - _b__167_.is_mutated)) - | Unused_constr_field _, _ -> false - | _, Unused_constr_field _ -> false - | Redundant_modifier _a__168_, Redundant_modifier _b__169_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__168_.modifier : string) _b__169_.modifier) - (Stdlib.( = ) (_a__168_.field : string) _b__169_.field) - | Redundant_modifier _, _ -> false - | _, Redundant_modifier _ -> false - | Struct_never_constructed _a__170_, Struct_never_constructed _b__171_ - -> - Stdlib.( = ) (_a__170_ : string) _b__171_ - | Struct_never_constructed _, _ -> false - | _, Struct_never_constructed _ -> false - | Unused_pat, Unused_pat -> true - | Unused_pat, _ -> false - | _, Unused_pat -> false - | Partial_match _a__172_, Partial_match _b__173_ -> - Ppx_base.equal_list - (fun a__174_ b__175_ -> Stdlib.( = ) (a__174_ : string) b__175_) - _a__172_ _b__173_ - | Partial_match _, _ -> false - | _, Partial_match _ -> false - | Unreachable, Unreachable -> true - | Unreachable, _ -> false - | _, Unreachable -> false - | Unresolved_tvar _a__176_, Unresolved_tvar _b__177_ -> - Stdlib.( = ) (_a__176_ : string) _b__177_ - | Unresolved_tvar _, _ -> false - | _, Unresolved_tvar _ -> false - | Lowercase_type_name _a__178_, Lowercase_type_name _b__179_ -> - Stdlib.( = ) (_a__178_ : string) _b__179_ - | Lowercase_type_name _, _ -> false - | _, Lowercase_type_name _ -> false - | Unused_mutability _a__180_, Unused_mutability _b__181_ -> - Stdlib.( = ) (_a__180_ : string) _b__181_ - | Unused_mutability _, _ -> false - | _, Unused_mutability _ -> false - | Parser_inconsistency _a__182_, Parser_inconsistency _b__183_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__182_.file_name : string) _b__183_.file_name) - (Stdlib.( && ) - (Stdlib.( = ) (_a__182_.segment : string) _b__183_.segment) - (Stdlib.( && ) - (Stdlib.( = ) - (_a__182_.is_menhir_succeed : bool) - _b__183_.is_menhir_succeed) - (Stdlib.( = ) - (_a__182_.is_handrolled_succeed : bool) - _b__183_.is_handrolled_succeed))) - | Parser_inconsistency _, _ -> false - | _, Parser_inconsistency _ -> false - | Useless_loop, Useless_loop -> true - | Useless_loop, _ -> false - | _, Useless_loop -> false - | Toplevel_not_left_aligned, Toplevel_not_left_aligned -> true - | Toplevel_not_left_aligned, _ -> false - | _, Toplevel_not_left_aligned -> false - | Unexpected_pragmas _a__184_, Unexpected_pragmas _b__185_ -> - Stdlib.( = ) (_a__184_ : string) _b__185_ - | Unexpected_pragmas _, _ -> false - | _, Unexpected_pragmas _ -> false - | Omitted_constr_argument _a__186_, Omitted_constr_argument _b__187_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__186_.constr : string) _b__187_.constr) - (Ppx_base.equal_list - (fun a__188_ b__189_ -> - Stdlib.( = ) (a__188_ : string) b__189_) - _a__186_.labels _b__187_.labels) - | Omitted_constr_argument _, _ -> false - | _, Omitted_constr_argument _ -> false - | Ambiguous_block, Ambiguous_block -> true - | Ambiguous_block, _ -> false - | _, Ambiguous_block -> false - | Useless_try, Useless_try -> true - | Useless_try, _ -> false - | _, Useless_try -> false - | Useless_error_type, Useless_error_type -> true - | Useless_error_type, _ -> false - | _, Useless_error_type -> false - | Useless_catch_all, Useless_catch_all -> true - | Useless_catch_all, _ -> false - | _, Useless_catch_all -> false - | Deprecated_syntax _a__190_, Deprecated_syntax _b__191_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__190_.old_usage : string) _b__191_.old_usage) - (Stdlib.( && ) - (Stdlib.( = ) (_a__190_.purpose : string) _b__191_.purpose) - (match (_a__190_.new_usage, _b__191_.new_usage) with - | None, None -> true - | None, Some _ -> false - | Some _, None -> false - | Some __option_x, Some __option_y -> - (fun a__192_ b__193_ -> - Stdlib.( = ) (a__192_ : string) b__193_) - __option_x __option_y)) - | Deprecated_syntax _, _ -> false - | _, Deprecated_syntax _ -> false - | Todo, Todo -> true - | Todo, _ -> false - | _, Todo -> false - | Unused_package _a__194_, Unused_package _b__195_ -> - Stdlib.( && ) - (Stdlib.( = ) (_a__194_.name : string) _b__195_.name) - (Stdlib.( = ) (_a__194_.is_alias : bool) _b__195_.is_alias) - | Unused_package _, _ -> false - | _, Unused_package _ -> false - | Empty_package_alias, Empty_package_alias -> true - | Empty_package_alias, _ -> false - | _, Empty_package_alias -> false - | ( Optional_arg_never_supplied _a__196_, - Optional_arg_never_supplied _b__197_ ) -> - Stdlib.( = ) (_a__196_ : string) _b__197_ - | Optional_arg_never_supplied _, _ -> false - | _, Optional_arg_never_supplied _ -> false - | ( Optional_arg_always_supplied _a__198_, - Optional_arg_always_supplied _b__199_ ) -> - Stdlib.( = ) (_a__198_ : string) _b__199_ - | Optional_arg_always_supplied _, _ -> false - | _, Optional_arg_always_supplied _ -> false - | Unused_import_value _a__200_, Unused_import_value _b__201_ -> - Stdlib.( = ) (_a__200_ : string) _b__201_ - | Unused_import_value _, _ -> false - | _, Unused_import_value _ -> false - | ( Deprecated_prefix_label_syntax _a__202_, - Deprecated_prefix_label_syntax _b__203_ ) -> - Stdlib.( = ) (_a__202_ : string) _b__203_ - | Deprecated_prefix_label_syntax _, _ -> false - | _, Deprecated_prefix_label_syntax _ -> false - | Reserved_keyword _a__204_, Reserved_keyword _b__205_ -> - Stdlib.( = ) (_a__204_ : string) _b__205_ + (fun a__183_ -> + fun b__184_ -> + if Stdlib.( == ) a__183_ b__184_ then true + else + match (a__183_, b__184_) with + | Unused_func _a__185_, Unused_func _b__186_ -> + Stdlib.( = ) (_a__185_ : string) _b__186_ + | Unused_func _, _ -> false + | _, Unused_func _ -> false + | Unused_var _a__187_, Unused_var _b__188_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__187_.var_name : string) _b__188_.var_name) + (Stdlib.( = ) + (_a__187_.is_toplevel : bool) + _b__188_.is_toplevel) + | Unused_var _, _ -> false + | _, Unused_var _ -> false + | Unused_type_declaration _a__189_, Unused_type_declaration _b__190_ + -> + Stdlib.( = ) (_a__189_ : string) _b__190_ + | Unused_type_declaration _, _ -> false + | _, Unused_type_declaration _ -> false + | Unused_abstract_type _a__191_, Unused_abstract_type _b__192_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__191_.name : string) _b__192_.name) + (Stdlib.( = ) (_a__191_.kind : string) _b__192_.kind) + | Unused_abstract_type _, _ -> false + | _, Unused_abstract_type _ -> false + | Unused_tvar _a__193_, Unused_tvar _b__194_ -> + Stdlib.( = ) (_a__193_ : string) _b__194_ + | Unused_tvar _, _ -> false + | _, Unused_tvar _ -> false + | Unused_constructor _a__195_, Unused_constructor _b__196_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__195_.constr : string) _b__196_.constr) + (equal_unused_kind _a__195_.kind _b__196_.kind) + | Unused_constructor _, _ -> false + | _, Unused_constructor _ -> false + | Unused_field _a__197_, Unused_field _b__198_ -> + Stdlib.( = ) (_a__197_ : string) _b__198_ + | Unused_field _, _ -> false + | _, Unused_field _ -> false + | Unused_constr_arg _a__199_, Unused_constr_arg _b__200_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__199_.constr : string) _b__200_.constr) + (Stdlib.( = ) (_a__199_.index : int) _b__200_.index) + | Unused_constr_arg _, _ -> false + | _, Unused_constr_arg _ -> false + | Unused_constr_field _a__201_, Unused_constr_field _b__202_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__201_.constr : string) _b__202_.constr) + (Stdlib.( && ) + (Stdlib.( = ) (_a__201_.label : string) _b__202_.label) + (Stdlib.( = ) + (_a__201_.is_mutated : bool) + _b__202_.is_mutated)) + | Unused_constr_field _, _ -> false + | _, Unused_constr_field _ -> false + | Redundant_modifier _a__203_, Redundant_modifier _b__204_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__203_.modifier : string) _b__204_.modifier) + (Stdlib.( = ) (_a__203_.field : string) _b__204_.field) + | Redundant_modifier _, _ -> false + | _, Redundant_modifier _ -> false + | Struct_never_constructed _a__205_, Struct_never_constructed _b__206_ + -> + Stdlib.( = ) (_a__205_ : string) _b__206_ + | Struct_never_constructed _, _ -> false + | _, Struct_never_constructed _ -> false + | Unused_pat, Unused_pat -> true + | Unused_pat, _ -> false + | _, Unused_pat -> false + | Partial_match _a__207_, Partial_match _b__208_ -> + Stdlib.( && ) + (Ppx_base.equal_list + (fun a__209_ -> + fun (b__210_ [@merlin.hide]) -> + (Stdlib.( = ) (a__209_ : string) b__210_ [@merlin.hide])) + _a__207_.hint_cases _b__208_.hint_cases) + (Stdlib.( && ) + (Stdlib.( = ) + (_a__207_.is_let_match : bool) + _b__208_.is_let_match) + (Stdlib.( = ) (_a__207_.has_guard : bool) _b__208_.has_guard)) + | Partial_match _, _ -> false + | _, Partial_match _ -> false + | Unreachable, Unreachable -> true + | Unreachable, _ -> false + | _, Unreachable -> false + | Unresolved_tvar _a__211_, Unresolved_tvar _b__212_ -> + Stdlib.( = ) (_a__211_ : string) _b__212_ + | Unresolved_tvar _, _ -> false + | _, Unresolved_tvar _ -> false + | Lowercase_type_name _a__213_, Lowercase_type_name _b__214_ -> + Stdlib.( = ) (_a__213_ : string) _b__214_ + | Lowercase_type_name _, _ -> false + | _, Lowercase_type_name _ -> false + | Unused_mutability _a__215_, Unused_mutability _b__216_ -> + Stdlib.( = ) (_a__215_ : string) _b__216_ + | Unused_mutability _, _ -> false + | _, Unused_mutability _ -> false + | Parser_inconsistency _a__217_, Parser_inconsistency _b__218_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__217_.file_name : string) _b__218_.file_name) + (Stdlib.( && ) + (Stdlib.( = ) (_a__217_.segment : string) _b__218_.segment) + (Stdlib.( && ) + (Stdlib.( = ) + (_a__217_.is_menhir_succeed : bool) + _b__218_.is_menhir_succeed) + (Stdlib.( = ) + (_a__217_.is_handrolled_succeed : bool) + _b__218_.is_handrolled_succeed))) + | Parser_inconsistency _, _ -> false + | _, Parser_inconsistency _ -> false + | Useless_loop, Useless_loop -> true + | Useless_loop, _ -> false + | _, Useless_loop -> false + | Toplevel_not_left_aligned, Toplevel_not_left_aligned -> true + | Toplevel_not_left_aligned, _ -> false + | _, Toplevel_not_left_aligned -> false + | Unexpected_pragmas _a__219_, Unexpected_pragmas _b__220_ -> + Stdlib.( = ) (_a__219_ : string) _b__220_ + | Unexpected_pragmas _, _ -> false + | _, Unexpected_pragmas _ -> false + | Omitted_constr_argument _a__221_, Omitted_constr_argument _b__222_ + -> + Stdlib.( && ) + (Stdlib.( = ) (_a__221_.constr : string) _b__222_.constr) + (Ppx_base.equal_list + (fun a__223_ -> + fun (b__224_ [@merlin.hide]) -> + (Stdlib.( = ) (a__223_ : string) b__224_ [@merlin.hide])) + _a__221_.labels _b__222_.labels) + | Omitted_constr_argument _, _ -> false + | _, Omitted_constr_argument _ -> false + | Ambiguous_block, Ambiguous_block -> true + | Ambiguous_block, _ -> false + | _, Ambiguous_block -> false + | Useless_try, Useless_try -> true + | Useless_try, _ -> false + | _, Useless_try -> false + | Useless_error_type, Useless_error_type -> true + | Useless_error_type, _ -> false + | _, Useless_error_type -> false + | Useless_catch_all, Useless_catch_all -> true + | Useless_catch_all, _ -> false + | _, Useless_catch_all -> false + | Deprecated_syntax _a__225_, Deprecated_syntax _b__226_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__225_.old_usage : string) _b__226_.old_usage) + (Stdlib.( && ) + (Stdlib.( = ) (_a__225_.purpose : string) _b__226_.purpose) + (match (_a__225_.new_usage, _b__226_.new_usage) with + | None, None -> true + | None, Some _ -> false + | Some _, None -> false + | Some __option_x, Some __option_y -> + (fun a__227_ -> + fun (b__228_ [@merlin.hide]) -> + (Stdlib.( = ) + (a__227_ : string) + b__228_ [@merlin.hide])) + __option_x __option_y)) + | Deprecated_syntax _, _ -> false + | _, Deprecated_syntax _ -> false + | Todo, Todo -> true + | Todo, _ -> false + | _, Todo -> false + | Unused_package _a__229_, Unused_package _b__230_ -> + Stdlib.( && ) + (Stdlib.( = ) (_a__229_.name : string) _b__230_.name) + (Stdlib.( = ) (_a__229_.is_alias : bool) _b__230_.is_alias) + | Unused_package _, _ -> false + | _, Unused_package _ -> false + | Empty_package_alias, Empty_package_alias -> true + | Empty_package_alias, _ -> false + | _, Empty_package_alias -> false + | ( Optional_arg_never_supplied _a__231_, + Optional_arg_never_supplied _b__232_ ) -> + Stdlib.( = ) (_a__231_ : string) _b__232_ + | Optional_arg_never_supplied _, _ -> false + | _, Optional_arg_never_supplied _ -> false + | ( Optional_arg_always_supplied _a__233_, + Optional_arg_always_supplied _b__234_ ) -> + Stdlib.( = ) (_a__233_ : string) _b__234_ + | Optional_arg_always_supplied _, _ -> false + | _, Optional_arg_always_supplied _ -> false + | Unused_import_value _a__235_, Unused_import_value _b__236_ -> + Stdlib.( = ) (_a__235_ : string) _b__236_ + | Unused_import_value _, _ -> false + | _, Unused_import_value _ -> false + | Reserved_keyword _a__237_, Reserved_keyword _b__238_ -> + Stdlib.( = ) (_a__237_ : string) _b__238_ + | Reserved_keyword _, _ -> false + | _, Reserved_keyword _ -> false + | Loop_label_shadow _a__239_, Loop_label_shadow _b__240_ -> + Stdlib.( = ) (_a__239_ : string) _b__240_ + | Loop_label_shadow _, _ -> false + | _, Loop_label_shadow _ -> false + | Loop_label_unused _a__241_, Loop_label_unused _b__242_ -> + Stdlib.( = ) (_a__241_ : string) _b__242_ + | Loop_label_unused _, _ -> false + | _, Loop_label_unused _ -> false + | Unused_guard, Unused_guard -> true + | Unused_guard, _ -> false + | _, Unused_guard -> false + | Closed_map_pattern, Closed_map_pattern -> true + | Closed_map_pattern, _ -> false + | _, Closed_map_pattern -> false + | Invalid_attribute _a__243_, Invalid_attribute _b__244_ -> + Stdlib.( = ) (_a__243_ : string) _b__244_ + | Invalid_attribute _, _ -> false + | _, Invalid_attribute _ -> false + | Unused_attribute _a__245_, Unused_attribute _b__246_ -> + Stdlib.( = ) (_a__245_ : string) _b__246_ + | Unused_attribute _, _ -> false + | _, Unused_attribute _ -> false + | Invalid_inline_wasm _a__247_, Invalid_inline_wasm _b__248_ -> + Stdlib.( = ) (_a__247_ : string) _b__248_ + | Invalid_inline_wasm _, _ -> false + | _, Invalid_inline_wasm _ -> false + | ( Implement_trait_with_method _a__249_, + Implement_trait_with_method _b__250_ ) -> + Stdlib.( && ) + (Stdlib.( = ) (_a__249_.trait : string) _b__250_.trait) + (Stdlib.( && ) + (Stdlib.( = ) (_a__249_.typ : string) _b__250_.typ) + (Ppx_base.equal_list + (fun a__251_ -> + fun (b__252_ [@merlin.hide]) -> + (Stdlib.( = ) + (a__251_ : string) + b__252_ [@merlin.hide])) + _a__249_.methods _b__250_.methods)) : kind -> kind -> bool) let _ = equal_kind @@ -727,39 +926,41 @@ include struct let _ = fun (_ : t) -> () let sexp_of_t = - (fun { loc = loc__207_; kind = kind__209_ } -> - let bnds__206_ = ([] : _ Stdlib.List.t) in - let bnds__206_ = - let arg__210_ = sexp_of_kind kind__209_ in - (S.List [ S.Atom "kind"; arg__210_ ] :: bnds__206_ : _ Stdlib.List.t) + (fun { loc = loc__254_; kind = kind__256_ } -> + let bnds__253_ = ([] : _ Stdlib.List.t) in + let bnds__253_ = + let arg__257_ = sexp_of_kind kind__256_ in + (S.List [ S.Atom "kind"; arg__257_ ] :: bnds__253_ : _ Stdlib.List.t) in - let bnds__206_ = - let arg__208_ = Loc.sexp_of_t loc__207_ in - (S.List [ S.Atom "loc"; arg__208_ ] :: bnds__206_ : _ Stdlib.List.t) + let bnds__253_ = + let arg__255_ = Loc.sexp_of_t loc__254_ in + (S.List [ S.Atom "loc"; arg__255_ ] :: bnds__253_ : _ Stdlib.List.t) in - S.List bnds__206_ + S.List bnds__253_ : t -> S.t) let _ = sexp_of_t let compare = - (fun a__211_ b__212_ -> - if Stdlib.( == ) a__211_ b__212_ then 0 - else - match Loc.compare a__211_.loc b__212_.loc with - | 0 -> compare_kind a__211_.kind b__212_.kind - | n -> n + (fun a__258_ -> + fun b__259_ -> + if Stdlib.( == ) a__258_ b__259_ then 0 + else + match Loc.compare a__258_.loc b__259_.loc with + | 0 -> compare_kind a__258_.kind b__259_.kind + | n -> n : t -> t -> int) let _ = compare let equal = - (fun a__213_ b__214_ -> - if Stdlib.( == ) a__213_ b__214_ then true - else - Stdlib.( && ) - (Loc.equal a__213_.loc b__214_.loc) - (equal_kind a__213_.kind b__214_.kind) + (fun a__260_ -> + fun b__261_ -> + if Stdlib.( == ) a__260_ b__261_ then true + else + Stdlib.( && ) + (Loc.equal a__260_.loc b__261_.loc) + (equal_kind a__260_.kind b__261_.kind) : t -> t -> bool) let _ = equal @@ -797,177 +998,268 @@ let number = function | Optional_arg_never_supplied _ -> 31 | Optional_arg_always_supplied _ -> 32 | Unused_import_value _ -> 33 - | Deprecated_prefix_label_syntax _ -> 34 | Reserved_keyword _ -> 35 + | Loop_label_shadow _ -> 36 + | Loop_label_unused _ -> 37 + | Unused_guard -> 38 + | Closed_map_pattern -> 41 + | Invalid_attribute _ -> 42 + | Unused_attribute _ -> 43 + | Invalid_inline_wasm _ -> 44 + | Implement_trait_with_method _ -> 45 -let last_warning_id = 35 +let last_warning_id = 45 -let message ?(as_error = false) (x : kind) : string = - let leading = if as_error then "Error (warning): " else "Warning: " in - let msg = - match x with - | Unused_func s -> ("Unused function '" ^ s ^ "'" : Stdlib.String.t) - | Unused_var { var_name; is_toplevel } -> - if is_toplevel then - ("Unused toplevel variable '" ^ var_name - ^ "'. Note if the body contains side effect, it will not happen. \ - Use `fn init { .. }` to wrap the effect." - : Stdlib.String.t) - else ("Unused variable '" ^ var_name ^ "'" : Stdlib.String.t) - | Unused_type_declaration s -> ("Unused type '" ^ s ^ "'" : Stdlib.String.t) - | Unused_abstract_type s -> - ("Unused abstract type '" ^ s ^ "'" : Stdlib.String.t) - | Unused_tvar s -> - ("Unused generic type variable '" ^ s ^ "'" : Stdlib.String.t) - | Unused_constructor { constr; kind } -> ( - match kind with - | Unused -> ("Variant '" ^ constr ^ "' is unused" : Stdlib.String.t) - | No_construct -> - ("Variant '" ^ constr ^ "' is never constructed" : Stdlib.String.t) - | No_read -> - ("Variant '" ^ constr ^ "' is never read" : Stdlib.String.t)) - | Unused_field s -> ("Field '" ^ s ^ "' is never read" : Stdlib.String.t) - | Unused_constr_arg { constr; index } -> - let index = - match index with - | 0 -> "1st" - | 1 -> "2nd" - | 2 -> "3rd" - | n -> (Int.to_string (n + 1) ^ "th" : Stdlib.String.t) - in - Stdlib.String.concat "" - [ - "The "; - index; - " positional argument of constructor '"; - constr; - "' is unused."; - ] - | Unused_constr_field { constr; label; is_mutated = false } -> - Stdlib.String.concat "" - [ "Field '"; label; "' of constructor '"; constr; "' is unused." ] - | Unused_constr_field { constr; label; is_mutated = true } -> - Stdlib.String.concat "" - [ "Field '"; label; "' of constructor '"; constr; "' is never read." ] - | Redundant_modifier { modifier; field } -> - Stdlib.String.concat "" - [ - "The "; - modifier; - " modifier is redundant here since field "; - field; - " is "; - modifier; - " by default"; - ] - | Struct_never_constructed name -> - ("The struct " ^ name ^ " is never constructed" : Stdlib.String.t) - | Unused_pat -> "Unused pattern" - | Partial_match _-> - "Partial match" - | Unreachable -> "Unreachable code" - | Unresolved_tvar s -> - ("The type of this expression is " ^ s - ^ ", which contains unresolved type variables. The type variable is \ - default to Unit." - : Stdlib.String.t) - | Lowercase_type_name s -> - ("Type name '" ^ s ^ "' should be capitalized." : Stdlib.String.t) - | Unused_mutability s -> - ("The mutability of " ^ s ^ " is never used." : Stdlib.String.t) - | Parser_inconsistency - { file_name; segment; is_menhir_succeed; is_handrolled_succeed } -> - let p x = if x then "succeed" else "failed" in - Stdlib.String.concat "" - [ - "parser consistency check failed at '"; - file_name; - "' "; - segment; - " (menhir parser "; - p is_menhir_succeed; - ", handrolled parser "; - p is_handrolled_succeed; - ")"; - ] - | Useless_loop -> - ("There is no [continue] in this loop expression, so [loop] is useless \ - here." - : Stdlib.String.t) - | Toplevel_not_left_aligned -> - ("Toplevel declaration is not left aligned." : Stdlib.String.t) - | Unexpected_pragmas s -> ("Invalid pragma, " ^ s : Stdlib.String.t) - | Omitted_constr_argument { constr; labels } -> - let labels_str = String.concat "," labels in - Stdlib.String.concat "" - [ - "The argument(s) "; - labels_str; - " of constructor "; - constr; - " are omitted (To ignore them, add \"..\" to the end of argument \ - list)."; - ] - | Ambiguous_block -> - ("Ambiguous block expression. Use `id` directly, or use `{ id, }` to \ - clarify a struct literal." - : Stdlib.String.t) - | Useless_try -> "The body of this try expression never raises any error." - | Useless_error_type -> "The error type of this function is never used." - | Useless_catch_all -> - "The patterns are complete so the usage of `catch!` is useless. Use \ - `catch` instead." - | Deprecated_syntax { old_usage; purpose; new_usage } -> - let new_usage = - match new_usage with - | None -> "" - | Some new_usage -> - (" Use " ^ new_usage ^ " instead." : Stdlib.String.t) - in - Stdlib.String.concat "" - [ - "The syntax "; - old_usage; - " for "; - purpose; - " is deprecated."; - new_usage; - ] - | Todo -> "unfinished code" - | Unused_package { name; is_alias } -> - if is_alias then - ("Unused package alias '" ^ name ^ "'" : Stdlib.String.t) - else ("Unused package '" ^ name ^ "'" : Stdlib.String.t) - | Empty_package_alias -> - "The package alias is empty. The default package alias will be used \ - instead." - | Optional_arg_never_supplied label -> - ("The optional argument '" ^ label ^ "' is never supplied." - : Stdlib.String.t) - | Optional_arg_always_supplied label -> - ("Default value of optional argument '" ^ label ^ "' is unused." - : Stdlib.String.t) - | Unused_import_value name -> - ("The import value " ^ name ^ " is never used directly. " - : Stdlib.String.t) - | Deprecated_prefix_label_syntax label -> - Stdlib.String.concat "" - [ - "The syntax `~"; - label; - "` is deprecated. Use postfix style like `"; - label; - "~` or `"; - label; - "?` instead."; - ] - | Reserved_keyword s -> - ("The word `" ^ s - ^ "` is reserved for possible future use. Please consider using \ - another name." - : Stdlib.String.t) - in - leading ^ msg +let message ?(as_error = false) (x : kind) = + (let leading = if as_error then "Error (warning): " else "Warning: " in + let msg = + match x with + | Unused_func s -> + ("Unused function '" ^ s ^ "'" : Stdlib.String.t) [@merlin.hide] + | Unused_var { var_name; is_toplevel } -> + if is_toplevel then + ("Unused toplevel variable '" ^ var_name + ^ "'. Note if the body contains side effect, it will not happen. \ + Use `fn init { .. }` to wrap the effect." + : Stdlib.String.t) + [@merlin.hide] + else + ("Unused variable '" ^ var_name ^ "'" + : Stdlib.String.t) + [@merlin.hide] + | Unused_type_declaration s -> + ("Unused type '" ^ s ^ "'" : Stdlib.String.t) [@merlin.hide] + | Unused_abstract_type { name; kind } -> + Stdlib.String.concat "" + [ + "The "; + kind; + " '"; + name; + "' does not occur in public signature of current package, \ + consider marking it as `priv`."; + ] [@merlin.hide] + | Unused_tvar s -> + ("Unused generic type variable '" ^ s ^ "'" + : Stdlib.String.t) + [@merlin.hide] + | Unused_constructor { constr; kind } -> ( + match kind with + | Unused -> + ("Variant '" ^ constr ^ "' is unused" + : Stdlib.String.t) + [@merlin.hide] + | No_construct -> + ("Variant '" ^ constr ^ "' is never constructed" + : Stdlib.String.t) + [@merlin.hide] + | No_read -> + ("Variant '" ^ constr ^ "' is never read" + : Stdlib.String.t) + [@merlin.hide]) + | Unused_field s -> + ("Field '" ^ s ^ "' is never read" : Stdlib.String.t) [@merlin.hide] + | Unused_constr_arg { constr; index } -> + let index = + match index with + | 0 -> "1st" + | 1 -> "2nd" + | 2 -> "3rd" + | n -> + (Int.to_string (n + 1) ^ "th" : Stdlib.String.t) [@merlin.hide] + in + (Stdlib.String.concat "" + [ + "The "; + index; + " positional argument of constructor '"; + constr; + "' is unused."; + ] [@merlin.hide]) + | Unused_constr_field { constr; label; is_mutated = false } -> + Stdlib.String.concat "" + [ "Field '"; label; "' of constructor '"; constr; "' is unused." ] + [@merlin.hide] + | Unused_constr_field { constr; label; is_mutated = true } -> + Stdlib.String.concat "" + [ + "Field '"; label; "' of constructor '"; constr; "' is never read."; + ] [@merlin.hide] + | Redundant_modifier { modifier; field } -> + Stdlib.String.concat "" + [ + "The "; + modifier; + " modifier is redundant here since field "; + field; + " is "; + modifier; + " by default"; + ] [@merlin.hide] + | Struct_never_constructed name -> + ("The struct " ^ name ^ " is never constructed" + : Stdlib.String.t) + [@merlin.hide] + | Unused_pat -> "Unused pattern" + | Partial_match { hint_cases = lst; is_let_match; has_guard } -> + let hint_cases = String.concat "\n" lst in + if is_let_match then + ("Partial match, some hints:\n" ^ hint_cases + ^ " \n\ + \ note: You can use guard-let if the missing cases are not \ + expected to happen." + : Stdlib.String.t) + [@merlin.hide] + else if has_guard then + ("Partial match, some hints:\n" ^ hint_cases + ^ "\n note: the compiler won't take guard conditions into account." + : Stdlib.String.t) + [@merlin.hide] + else + ("Partial match, some hints:\n" ^ hint_cases + : Stdlib.String.t) + [@merlin.hide] + | Unreachable -> "Unreachable code" + | Unresolved_tvar s -> + ("The type of this expression is " ^ s + ^ ", which contains unresolved type variables. The type variable is \ + default to Unit." + : Stdlib.String.t) + [@merlin.hide] + | Lowercase_type_name s -> + ("Type name '" ^ s ^ "' should be capitalized." + : Stdlib.String.t) + [@merlin.hide] + | Unused_mutability s -> + ("The mutability of " ^ s ^ " is never used." + : Stdlib.String.t) + [@merlin.hide] + | Parser_inconsistency + { file_name; segment; is_menhir_succeed; is_handrolled_succeed } -> + let p x = if x then "succeed" else "failed" in + (Stdlib.String.concat "" + [ + "parser consistency check failed at '"; + file_name; + "' "; + segment; + " (menhir parser "; + p is_menhir_succeed; + ", handrolled parser "; + p is_handrolled_succeed; + ")"; + ] [@merlin.hide]) + | Useless_loop -> + ("There is no [continue] in this loop expression, so [loop] is \ + useless here." + : Stdlib.String.t) + [@merlin.hide] + | Toplevel_not_left_aligned -> + ("Toplevel declaration is not left aligned." + : Stdlib.String.t) + [@merlin.hide] + | Unexpected_pragmas s -> + ("Invalid pragma, " ^ s : Stdlib.String.t) [@merlin.hide] + | Omitted_constr_argument { constr; labels } -> + let labels_str = String.concat "," labels in + (Stdlib.String.concat "" + [ + "The argument(s) "; + labels_str; + " of constructor "; + constr; + " are omitted (To ignore them, add \"..\" to the end of argument \ + list)."; + ] [@merlin.hide]) + | Ambiguous_block -> + ("Ambiguous block expression. Use `id` directly, or use `{ id, }` to \ + clarify a struct literal." + : Stdlib.String.t) + [@merlin.hide] + | Useless_try -> "The body of this try expression never raises any error." + | Useless_error_type -> "The error type of this function is never used." + | Useless_catch_all -> + "The patterns are complete so the usage of `catch!` is useless. Use \ + `catch` instead." + | Deprecated_syntax { old_usage; purpose; new_usage } -> + let new_usage = + match new_usage with + | None -> "" + | Some new_usage -> + (" Use " ^ new_usage ^ " instead." + : Stdlib.String.t) + [@merlin.hide] + in + (Stdlib.String.concat "" + [ + "The syntax "; + old_usage; + " for "; + purpose; + " is deprecated."; + new_usage; + ] [@merlin.hide]) + | Todo -> "unfinished code" + | Unused_package { name; is_alias } -> + if is_alias then + ("Unused package alias '" ^ name ^ "'" + : Stdlib.String.t) + [@merlin.hide] + else ("Unused package '" ^ name ^ "'" : Stdlib.String.t) [@merlin.hide] + | Empty_package_alias -> + "The package alias is empty. The default package alias will be used \ + instead." + | Optional_arg_never_supplied label -> + ("The optional argument '" ^ label ^ "' is never supplied." + : Stdlib.String.t) + [@merlin.hide] + | Optional_arg_always_supplied label -> + ("Default value of optional argument '" ^ label ^ "' is unused." + : Stdlib.String.t) + [@merlin.hide] + | Unused_import_value name -> + ("The import value " ^ name ^ " is never used directly. " + : Stdlib.String.t) + [@merlin.hide] + | Reserved_keyword s -> + ("The word `" ^ s + ^ "` is reserved for possible future use. Please consider using \ + another name." + : Stdlib.String.t) + [@merlin.hide] + | Loop_label_shadow label -> + ("The label name `" ^ label + ^ "` shadows a label name that is already in scope." + : Stdlib.String.t) + [@merlin.hide] + | Loop_label_unused label -> + ("The label name `" ^ label ^ "` is never used." + : Stdlib.String.t) + [@merlin.hide] + | Unused_guard -> "Useless guard because the pattern is irrefutable." + | Closed_map_pattern -> + "Map patterns are always open, so `..` should be added to this \ + pattern." + | Invalid_attribute s -> s + | Unused_attribute s -> + ("Unused attribute '" ^ s ^ "'." : Stdlib.String.t) [@merlin.hide] + | Invalid_inline_wasm s -> s + | Implement_trait_with_method { trait; typ; methods } -> + let methods = String.concat ", " methods in + (Stdlib.String.concat "" + [ + "Type "; + typ; + " implements trait "; + trait; + " with regular methods "; + methods; + ", this behavior is deprecated and will be removed in the \ + future, write explicit `impl` instead."; + ] [@merlin.hide]) + in + leading ^ msg + : string) type state = { active : bool array; error : bool array } @@ -1050,7 +1342,7 @@ let parse_options errflag s = current := { active; error } let default_warnings = "+a-31-32" -let default_warnings_as_errors = "-a+15+19+23+24" +let default_warnings_as_errors = "-a+11+15+23+24+44" let reset () = parse_options false default_warnings; @@ -1063,12 +1355,13 @@ let descriptions = (1, "Unused function."); (2, "Unused variable."); (3, "Unused type declaration."); - (4, "Redundant case in a pattern matching (unused match case)."); - (5, "Unused function argument."); + (4, "Unused abstract type."); + (5, "Unused type variable."); (6, "Unused constructor."); - (7, "Unused module declaration."); - (8, "Unused struct field."); - (10, "Unused generic type variable."); + (7, "Unused field or constructor argument."); + (8, "Redunant modifier."); + (9, "Unused function declaration."); + (10, "Struct never constructed."); (11, "Partial pattern matching."); (12, "Unreachable code."); (13, "Unresolved type variable."); @@ -1090,10 +1383,21 @@ let descriptions = (31, "Optional argument never supplied."); (32, "Default value of optional argument never used."); (33, "Unused import value"); + (35, "Reserved keyword."); + (36, "Loop label shadows another label."); + (37, "Unused loop label."); + (38, "Useless guard."); + (39, "Duplicated method."); + (40, "Call a qualified method using regular call syntax."); + (41, "Closed map pattern."); + (42, "Invalid attribute."); + (43, "Unused attribute."); + (44, "Invalid inline-wasm."); + (45, "Type implments trait with regular methods."); ] let help_warnings () = print_endline "Available warnings: "; - List.iter (fun (i, s) -> Printf.printf "%3i %s\n" i s) descriptions; + Basic_lst.iter descriptions ~f:(fun (i, s) -> Printf.printf "%3i %s\n" i s); print_endline " A all warnings"; exit 0 diff --git a/src/wasm_lex.ml b/src/wasm_lex.ml index 4ec555c..f0f6f89 100755 --- a/src/wasm_lex.ml +++ b/src/wasm_lex.ml @@ -12,17 +12,18 @@ . *) # 1 "lib/lexers/wasm_lexer/wasm_lex.mll" - + open Sexp_token - +module Lexing = Stdlib.Lexing + type pos = Lexing.position type region = { left : pos; right : pos } exception Syntax of region * string -let region lexbuf = - let left = (Lexing.lexeme_start_p lexbuf) in - let right = (Lexing.lexeme_end_p lexbuf) in +let region (lexbuf : Lexing.lexbuf) = + let left = (Stdlib.Lexing.lexeme_start_p lexbuf) in + let right = (Stdlib.Lexing.lexeme_end_p lexbuf) in {left = left; right = right} let error lexbuf msg = raise (Syntax (region lexbuf, msg)) @@ -36,56 +37,56 @@ let unknown lexbuf = error lexbuf ("unknown operator " ^ Lexing.lexeme lexbuf) -# 27 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 28 "lib/lexers/wasm_lexer/wasm_lex.ml" let __ocaml_lex_tables = { Lexing.lex_base = "\000\000\232\255\000\000\129\000\129\000\193\000\001\001\001\001\ - \065\001\234\255\235\255\224\001\062\002\117\002\241\255\242\255\ - \243\255\068\000\207\002\045\003\139\003\233\003\104\004\072\005\ - \166\005\004\006\098\006\192\006\254\255\133\000\244\255\031\007\ - \243\007\081\008\175\008\013\009\107\009\201\009\039\010\133\010\ - \227\010\065\011\159\011\253\011\091\012\185\012\023\013\117\013\ - \211\013\049\014\102\004\030\007\061\002\032\014\096\014\160\014\ - \160\014\224\014\032\015\096\015\160\015\224\015\032\016\096\016\ - \160\016\224\016\032\017\070\000\176\017\199\017\237\017\042\018\ - \112\018\206\018\044\019\138\019\232\019\070\020\164\020\002\021\ - \096\021\190\021\028\022\122\022\216\022\054\023\148\023\242\023\ - \080\024\174\024\012\025\106\025\200\025\038\026\132\026\226\026\ - \064\027\158\027\252\027\250\255\251\255\090\028\179\028\169\028\ - \045\004\217\028\052\029\116\029\116\029\180\029\116\030\245\030\ - \053\031\117\031\181\031\245\031\053\032\117\032\181\032\245\032\ - \249\255\122\000\103\030\181\033\126\030\168\033\134\034\204\034\ - \042\035\136\035\230\035\068\036\162\036\000\037\094\037\188\037\ - \026\038\120\038\214\038\052\039\146\039\240\039\078\040\172\040\ - \010\041\104\041\198\041\036\042\130\042\224\042\062\043\081\043\ - \246\255\247\255\210\043\180\017\002\044\066\044\130\044\130\044\ - \194\044\002\045\066\045\130\045\194\045\002\046\066\046\130\046\ - \194\046\002\047\158\047\242\047\100\047\070\048\128\047\154\048\ - \238\048\010\049\094\049\184\049\233\255\183\049\247\049\055\050\ - \119\050\183\050\247\050\055\051\119\051\183\051\109\052\250\255\ - \251\255\041\052\241\017\222\052\030\053\094\053\094\053\158\053\ - \252\255\253\255\187\000\206\000\255\255\254\255\222\053\030\054\ - \094\054\158\054\222\054\030\055\094\055\158\055\222\055"; + \065\001\234\255\235\255\224\001\055\002\241\255\242\255\243\255\ + \068\000\145\002\239\002\077\003\171\003\042\004\010\005\104\005\ + \198\005\036\006\130\006\254\255\133\000\244\255\225\006\181\007\ + \019\008\113\008\207\008\045\009\139\009\233\009\071\010\165\010\ + \003\011\097\011\191\011\029\012\123\012\217\012\055\013\149\013\ + \243\013\040\004\224\006\223\001\226\013\034\014\098\014\098\014\ + \162\014\226\014\034\015\098\015\162\015\226\015\034\016\098\016\ + \162\016\226\016\070\000\114\017\137\017\175\017\236\017\050\018\ + \144\018\238\018\076\019\170\019\008\020\102\020\196\020\034\021\ + \128\021\222\021\060\022\154\022\248\022\086\023\180\023\018\024\ + \112\024\206\024\044\025\138\025\232\025\070\026\164\026\002\027\ + \096\027\190\027\250\255\251\255\028\028\117\028\107\028\248\001\ + \155\028\246\028\054\029\054\029\118\029\054\030\183\030\247\030\ + \055\031\119\031\183\031\247\031\055\032\119\032\183\032\249\255\ + \122\000\041\030\119\033\064\030\106\033\072\034\142\034\236\034\ + \074\035\168\035\006\036\100\036\194\036\032\037\126\037\220\037\ + \058\038\152\038\246\038\084\039\178\039\016\040\110\040\204\040\ + \042\041\136\041\230\041\068\042\162\042\000\043\019\043\246\255\ + \247\255\148\043\239\003\196\043\004\044\068\044\068\044\132\044\ + \196\044\004\045\068\045\132\045\196\045\004\046\068\046\132\046\ + \196\046\037\047\097\047\181\047\065\047\009\048\037\048\121\048\ + \205\048\233\048\061\049\145\049\233\255\140\049\204\049\012\050\ + \076\050\140\050\204\050\012\051\076\051\140\051\066\052\250\255\ + \251\255\254\051\118\017\179\052\243\052\051\053\051\053\115\053\ + \252\255\253\255\187\000\206\000\255\255\254\255\179\053\243\053\ + \051\054\115\054\179\054\243\054\051\055\115\055\179\055"; Lexing.lex_backtrk = "\255\255\255\255\023\000\023\000\023\000\023\000\023\000\023\000\ - \023\000\255\255\255\255\020\000\020\000\020\000\255\255\255\255\ - \255\255\020\000\020\000\020\000\020\000\020\000\023\000\020\000\ - \020\000\020\000\002\000\002\000\255\255\000\000\255\255\255\255\ + \023\000\255\255\255\255\020\000\020\000\255\255\255\255\255\255\ + \020\000\020\000\020\000\020\000\020\000\023\000\020\000\020\000\ + \020\000\002\000\002\000\255\255\000\000\255\255\255\255\020\000\ + \002\000\020\000\020\000\002\000\020\000\002\000\020\000\002\000\ \020\000\002\000\020\000\020\000\002\000\020\000\002\000\020\000\ - \002\000\020\000\002\000\020\000\020\000\002\000\020\000\002\000\ - \020\000\020\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \020\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\020\000\ + \020\000\002\000\002\000\020\000\020\000\002\000\020\000\020\000\ + \002\000\020\000\002\000\020\000\020\000\020\000\002\000\020\000\ + \007\000\007\000\002\000\007\000\002\000\007\000\007\000\007\000\ + \002\000\007\000\255\255\255\255\003\000\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \020\000\020\000\002\000\002\000\020\000\020\000\002\000\020\000\ - \020\000\002\000\020\000\002\000\020\000\020\000\020\000\002\000\ - \020\000\007\000\007\000\002\000\007\000\002\000\007\000\007\000\ - \007\000\002\000\007\000\255\255\255\255\003\000\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\006\000\006\000\006\000\255\255\255\255\255\255\007\000\ - \007\000\007\000\007\000\007\000\020\000\007\000\007\000\020\000\ - \020\000\007\000\020\000\007\000\007\000\007\000\007\000\020\000\ - \007\000\007\000\020\000\020\000\007\000\020\000\007\000\010\000\ + \006\000\006\000\006\000\255\255\255\255\255\255\007\000\007\000\ + \007\000\007\000\007\000\020\000\007\000\007\000\020\000\020\000\ + \007\000\020\000\007\000\007\000\007\000\007\000\020\000\007\000\ + \007\000\020\000\020\000\007\000\020\000\007\000\010\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\015\000\255\255\016\000\255\255\017\000\ @@ -96,10 +97,9 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255"; Lexing.lex_default = "\001\000\000\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\000\000\000\000\255\255\255\255\255\255\000\000\000\000\ - \000\000\255\255\255\255\255\255\255\255\255\255\110\000\255\255\ - \255\255\255\255\255\255\255\255\000\000\255\255\000\000\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\000\000\000\000\255\255\255\255\000\000\000\000\000\000\ + \255\255\255\255\255\255\255\255\255\255\109\000\255\255\255\255\ + \255\255\255\255\255\255\000\000\255\255\000\000\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -107,14 +107,15 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\000\000\000\000\255\255\120\000\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\110\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \000\000\255\255\255\255\110\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\000\000\000\000\255\255\119\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\109\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\000\000\ + \255\255\255\255\109\000\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\151\000\ - \000\000\000\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\150\000\000\000\ + \000\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\000\000\255\255\255\255\255\255\ @@ -124,21 +125,21 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255"; Lexing.lex_trans = "\009\000\009\000\009\000\009\000\009\000\009\000\009\000\009\000\ - \009\000\016\000\015\000\009\000\009\000\016\000\009\000\009\000\ + \009\000\015\000\014\000\009\000\009\000\015\000\009\000\009\000\ \009\000\009\000\009\000\009\000\009\000\009\000\009\000\009\000\ \009\000\009\000\009\000\009\000\009\000\009\000\009\000\009\000\ - \016\000\011\000\022\000\011\000\018\000\011\000\011\000\011\000\ - \029\000\028\000\011\000\025\000\013\000\025\000\011\000\011\000\ - \027\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\ - \026\000\026\000\011\000\017\000\011\000\011\000\011\000\011\000\ - \012\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \015\000\011\000\021\000\011\000\017\000\011\000\011\000\011\000\ + \028\000\027\000\011\000\024\000\012\000\024\000\011\000\011\000\ + \026\000\025\000\025\000\025\000\025\000\025\000\025\000\025\000\ + \025\000\025\000\011\000\016\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\010\000\011\000\010\000\011\000\011\000\ - \011\000\020\000\019\000\019\000\019\000\019\000\019\000\019\000\ - \019\000\024\000\019\000\019\000\019\000\019\000\023\000\021\000\ - \019\000\019\000\019\000\019\000\019\000\019\000\019\000\019\000\ - \019\000\019\000\019\000\010\000\011\000\010\000\011\000\151\000\ + \011\000\019\000\018\000\018\000\018\000\018\000\018\000\018\000\ + \018\000\023\000\018\000\018\000\018\000\018\000\022\000\020\000\ + \018\000\018\000\018\000\018\000\018\000\018\000\018\000\018\000\ + \018\000\018\000\018\000\010\000\011\000\010\000\011\000\150\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ @@ -147,15 +148,15 @@ let __ocaml_lex_tables = { \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ - \030\000\069\000\008\000\008\000\008\000\008\000\008\000\008\000\ + \029\000\068\000\008\000\008\000\008\000\008\000\008\000\008\000\ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\ \007\000\005\000\005\000\005\000\005\000\005\000\005\000\005\000\ \005\000\005\000\005\000\005\000\005\000\006\000\005\000\005\000\ - \004\000\002\000\002\000\002\000\003\000\124\000\205\000\204\000\ + \004\000\002\000\002\000\002\000\003\000\123\000\205\000\204\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \014\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ + \013\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ @@ -187,7 +188,7 @@ let __ocaml_lex_tables = { \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ - \180\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \180\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\011\000\011\000\011\000\ @@ -198,89 +199,81 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\170\000\011\000\000\000\011\000\179\000\011\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\000\000\011\000\000\000\011\000\063\000\063\000\063\000\ - \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ - \063\000\063\000\063\000\063\000\063\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\171\000\000\000\171\000\171\000\ + \011\000\011\000\011\000\170\000\011\000\000\000\011\000\062\000\ + \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ + \062\000\062\000\062\000\062\000\062\000\062\000\062\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\169\000\ + \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ + \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\171\000\000\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \150\000\031\000\150\000\150\000\150\000\150\000\150\000\000\000\ - \000\000\150\000\150\000\000\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\000\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\000\000\150\000\000\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\000\000\150\000\000\000\150\000\011\000\031\000\ + \171\000\171\000\149\000\030\000\149\000\149\000\149\000\149\000\ + \149\000\000\000\000\000\149\000\149\000\000\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\000\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\000\000\149\000\000\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\000\000\149\000\000\000\149\000\ + \011\000\030\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \000\000\011\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\000\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\000\000\011\000\000\000\011\000\011\000\030\000\ \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \000\000\011\000\011\000\011\000\011\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \000\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \000\000\011\000\000\000\011\000\011\000\031\000\011\000\011\000\ + \011\000\000\000\011\000\088\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \000\000\011\000\000\000\011\000\088\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\138\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ - \011\000\089\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\000\000\011\000\ - \000\000\011\000\089\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\139\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\000\000\011\000\011\000\000\000\011\000\089\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\000\000\011\000\011\000\011\000\ - \011\000\011\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\000\000\011\000\000\000\011\000\ - \089\000\011\000\089\000\089\000\089\000\089\000\089\000\127\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\000\000\011\000\000\000\011\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\100\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \031\000\000\000\101\000\000\000\000\000\031\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\068\000\068\000\ - \068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\068\000\ - \068\000\068\000\068\000\068\000\068\000\116\000\116\000\116\000\ - \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ - \116\000\116\000\116\000\116\000\116\000\000\000\000\000\000\000\ - \000\000\000\000\031\000\000\000\102\000\000\000\000\000\068\000\ - \068\000\068\000\068\000\068\000\068\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\031\000\000\000\000\000\000\000\ - \031\000\000\000\031\000\067\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\099\000\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \011\000\088\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\000\000\011\000\ + \011\000\011\000\011\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\000\000\011\000\ + \000\000\011\000\088\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\126\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\000\000\011\000\ + \000\000\011\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\099\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\030\000\000\000\100\000\000\000\000\000\030\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\ + \067\000\067\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\067\000\067\000\067\000\067\000\067\000\067\000\165\000\ + \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ + \165\000\165\000\165\000\165\000\165\000\165\000\165\000\000\000\ + \000\000\000\000\000\000\000\000\030\000\000\000\101\000\000\000\ + \000\000\067\000\067\000\067\000\067\000\067\000\067\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\030\000\000\000\ + \000\000\000\000\030\000\000\000\030\000\066\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\098\000\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -288,232 +281,244 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \108\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\107\000\106\000\106\000\ - \105\000\103\000\103\000\103\000\104\000\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\107\000\105\000\105\000\105\000\105\000\105\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\105\000\106\000\ + \105\000\105\000\104\000\102\000\102\000\102\000\103\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \100\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\089\000\011\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\089\000\ - \011\000\092\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\011\000\011\000\011\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\089\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\090\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ - \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\011\000\011\000\075\000\074\000\074\000\074\000\ - \074\000\074\000\074\000\074\000\074\000\074\000\011\000\000\000\ + \255\255\255\255\099\000\011\000\030\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ + \088\000\011\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\088\000\011\000\091\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\088\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\089\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\011\000\011\000\074\000\073\000\ + \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\072\000\ + \011\000\011\000\011\000\011\000\071\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ + \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ + \000\000\011\000\032\000\011\000\025\000\025\000\025\000\025\000\ + \025\000\025\000\025\000\025\000\025\000\025\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\031\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\073\000\011\000\011\000\ - \011\000\011\000\072\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\034\000\011\000\011\000\011\000\011\000\ + \011\000\031\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \033\000\011\000\026\000\026\000\026\000\026\000\026\000\026\000\ - \026\000\026\000\026\000\026\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\032\000\ + \032\000\011\000\025\000\025\000\025\000\025\000\025\000\025\000\ + \025\000\025\000\025\000\025\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\031\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\035\000\011\000\011\000\011\000\011\000\011\000\032\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\034\000\011\000\011\000\011\000\011\000\011\000\031\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\033\000\011\000\011\000\000\000\011\000\000\000\ + \011\000\030\000\030\000\011\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\049\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \000\000\000\000\000\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\055\000\053\000\053\000\053\000\053\000\053\000\053\000\ + \053\000\053\000\053\000\053\000\053\000\053\000\054\000\053\000\ + \053\000\052\000\050\000\050\000\050\000\051\000\011\000\030\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ + \047\000\000\000\047\000\011\000\011\000\046\000\046\000\046\000\ + \046\000\046\000\046\000\046\000\046\000\046\000\046\000\011\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\033\000\011\000\ - \026\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\ - \026\000\026\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\032\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\035\000\ - \011\000\011\000\011\000\011\000\011\000\032\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \034\000\011\000\011\000\000\000\011\000\000\000\011\000\031\000\ - \031\000\011\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\050\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\000\000\000\000\ - \000\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ - \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ - \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ - \057\000\057\000\057\000\057\000\057\000\057\000\057\000\056\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\055\000\054\000\054\000\053\000\ - \051\000\051\000\051\000\052\000\011\000\031\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\000\000\011\000\048\000\000\000\ - \048\000\011\000\011\000\047\000\047\000\047\000\047\000\047\000\ - \047\000\047\000\047\000\047\000\047\000\011\000\000\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ + \011\000\011\000\011\000\044\000\044\000\044\000\044\000\044\000\ + \044\000\044\000\044\000\044\000\044\000\011\000\000\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \031\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \031\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\030\000\011\000\011\000\011\000\011\000\ \011\000\000\000\000\000\011\000\011\000\000\000\011\000\011\000\ - \011\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\ - \045\000\045\000\045\000\011\000\000\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\032\000\011\000\ + \011\000\035\000\035\000\035\000\035\000\035\000\035\000\035\000\ + \035\000\035\000\035\000\011\000\000\000\011\000\011\000\011\000\ + \011\000\011\000\035\000\035\000\035\000\035\000\035\000\035\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\032\000\011\000\ + \011\000\011\000\035\000\035\000\035\000\035\000\035\000\035\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\031\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \000\000\011\000\011\000\000\000\011\000\011\000\011\000\036\000\ - \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\ - \036\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ - \036\000\036\000\036\000\036\000\036\000\036\000\011\000\011\000\ + \011\000\030\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \000\000\011\000\011\000\000\000\011\000\011\000\011\000\025\000\ + \025\000\025\000\025\000\025\000\025\000\025\000\025\000\025\000\ + \025\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\000\000\011\000\000\000\011\000\011\000\011\000\ - \036\000\036\000\036\000\036\000\036\000\036\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\031\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\026\000\026\000\026\000\ - \026\000\026\000\026\000\026\000\026\000\026\000\026\000\011\000\ - \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\030\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ + \011\000\000\000\011\000\037\000\011\000\035\000\035\000\035\000\ + \035\000\035\000\035\000\035\000\035\000\035\000\035\000\011\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\035\000\035\000\ + \035\000\035\000\035\000\035\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\036\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\038\000\011\000\035\000\035\000\ + \035\000\035\000\035\000\035\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\036\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\000\000\011\000\042\000\000\000\ + \042\000\011\000\011\000\041\000\041\000\041\000\041\000\041\000\ + \041\000\041\000\041\000\041\000\041\000\011\000\000\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\031\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ - \011\000\038\000\011\000\036\000\036\000\036\000\036\000\036\000\ - \036\000\036\000\036\000\036\000\036\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\036\000\036\000\036\000\036\000\ - \036\000\036\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\037\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\039\000\011\000\036\000\036\000\036\000\036\000\ - \036\000\036\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\037\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\000\000\011\000\043\000\000\000\043\000\011\000\ - \011\000\042\000\042\000\042\000\042\000\042\000\042\000\042\000\ - \042\000\042\000\042\000\011\000\000\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ + \000\000\011\000\011\000\030\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\000\000\011\000\011\000\000\000\011\000\011\000\ + \011\000\039\000\039\000\039\000\039\000\039\000\039\000\039\000\ + \039\000\039\000\039\000\011\000\000\000\011\000\011\000\011\000\ + \011\000\011\000\039\000\039\000\039\000\039\000\039\000\039\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\036\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ + \011\000\011\000\039\000\039\000\039\000\039\000\039\000\039\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\036\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\031\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \000\000\011\000\011\000\000\000\011\000\011\000\011\000\040\000\ - \040\000\040\000\040\000\040\000\040\000\040\000\040\000\040\000\ - \040\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ - \040\000\040\000\040\000\040\000\040\000\040\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\037\000\ + \011\000\030\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \000\000\011\000\011\000\000\000\011\000\011\000\011\000\035\000\ + \035\000\035\000\035\000\035\000\035\000\035\000\035\000\035\000\ + \035\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \035\000\035\000\035\000\035\000\035\000\035\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\011\000\ - \040\000\040\000\040\000\040\000\040\000\040\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\037\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\031\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\036\000\036\000\036\000\ - \036\000\036\000\036\000\036\000\036\000\036\000\036\000\011\000\ - \000\000\011\000\011\000\011\000\011\000\011\000\036\000\036\000\ - \036\000\036\000\036\000\036\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\011\000\ + \035\000\035\000\035\000\035\000\035\000\035\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\011\000\036\000\036\000\ - \036\000\036\000\036\000\036\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\030\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ + \011\000\000\000\011\000\011\000\011\000\039\000\039\000\039\000\ + \039\000\039\000\039\000\039\000\039\000\039\000\039\000\011\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\039\000\039\000\ + \039\000\039\000\039\000\039\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\036\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\040\000\011\000\039\000\039\000\ + \039\000\039\000\039\000\039\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\036\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\031\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ - \011\000\011\000\011\000\040\000\040\000\040\000\040\000\040\000\ - \040\000\040\000\040\000\040\000\040\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\040\000\040\000\040\000\040\000\ - \040\000\040\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\037\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\039\000\039\000\039\000\039\000\039\000\ + \039\000\039\000\039\000\039\000\039\000\011\000\000\000\011\000\ + \011\000\011\000\011\000\011\000\039\000\039\000\039\000\039\000\ + \039\000\039\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\041\000\011\000\040\000\040\000\040\000\040\000\ - \040\000\040\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\037\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\039\000\039\000\039\000\039\000\ + \039\000\039\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\030\000\011\000\011\000\011\000\011\000\ \011\000\000\000\000\000\011\000\011\000\000\000\011\000\011\000\ - \011\000\040\000\040\000\040\000\040\000\040\000\040\000\040\000\ - \040\000\040\000\040\000\011\000\000\000\011\000\011\000\011\000\ - \011\000\011\000\040\000\040\000\040\000\040\000\040\000\040\000\ + \011\000\041\000\041\000\041\000\041\000\041\000\041\000\041\000\ + \041\000\041\000\041\000\011\000\000\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\011\000\040\000\040\000\040\000\040\000\040\000\040\000\ + \043\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\031\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \000\000\011\000\011\000\000\000\011\000\011\000\011\000\042\000\ - \042\000\042\000\042\000\042\000\042\000\042\000\042\000\042\000\ - \042\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\030\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \000\000\011\000\011\000\000\000\011\000\011\000\011\000\041\000\ + \041\000\041\000\041\000\041\000\041\000\041\000\041\000\041\000\ + \041\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\044\000\011\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\031\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\030\000\ \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\042\000\042\000\042\000\ - \042\000\042\000\042\000\042\000\042\000\042\000\042\000\011\000\ + \011\000\000\000\011\000\011\000\011\000\041\000\041\000\041\000\ + \041\000\041\000\041\000\041\000\041\000\041\000\041\000\011\000\ \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ @@ -522,57 +527,57 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\031\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ - \011\000\011\000\011\000\042\000\042\000\042\000\042\000\042\000\ - \042\000\042\000\042\000\042\000\042\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\044\000\044\000\044\000\044\000\044\000\ + \044\000\044\000\044\000\044\000\044\000\011\000\000\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \031\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\045\000\011\000\011\000\011\000\011\000\011\000\ + \031\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\030\000\011\000\011\000\011\000\011\000\ \011\000\000\000\000\000\011\000\011\000\000\000\011\000\011\000\ - \011\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\ - \045\000\045\000\045\000\011\000\000\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\032\000\011\000\ + \011\000\044\000\044\000\044\000\044\000\044\000\044\000\044\000\ + \044\000\044\000\044\000\011\000\000\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \046\000\011\000\011\000\011\000\011\000\011\000\032\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\031\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \000\000\011\000\011\000\000\000\011\000\011\000\011\000\045\000\ - \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\ - \045\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\030\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \000\000\011\000\011\000\000\000\011\000\011\000\011\000\046\000\ + \046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\ + \046\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\048\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\011\000\000\000\011\000\011\000\031\000\ + \011\000\011\000\000\000\011\000\000\000\011\000\011\000\030\000\ \011\000\011\000\011\000\011\000\011\000\000\000\000\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\047\000\047\000\047\000\ - \047\000\047\000\047\000\047\000\047\000\047\000\047\000\011\000\ + \011\000\000\000\011\000\011\000\011\000\046\000\046\000\046\000\ + \046\000\046\000\046\000\046\000\046\000\046\000\046\000\011\000\ \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\049\000\011\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\011\000\000\000\011\000\011\000\031\000\011\000\011\000\ + \000\000\011\000\000\000\011\000\011\000\030\000\011\000\011\000\ \011\000\011\000\011\000\000\000\000\000\011\000\011\000\000\000\ - \011\000\011\000\011\000\047\000\047\000\047\000\047\000\047\000\ - \047\000\047\000\047\000\047\000\047\000\011\000\000\000\011\000\ + \011\000\011\000\011\000\046\000\046\000\046\000\046\000\046\000\ + \046\000\046\000\046\000\046\000\046\000\011\000\000\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ @@ -581,143 +586,143 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\000\000\011\000\ - \000\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\000\000\011\000\011\000\000\000\011\000\011\000\ - \011\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\ - \047\000\047\000\047\000\011\000\000\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\000\000\011\000\000\000\011\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ - \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ - \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ + \000\000\011\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ + \060\000\060\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ + \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ + \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ + \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ + \059\000\059\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ - \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\031\000\031\000\031\000\031\000\031\000\031\000\070\000\ - \070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\ - \070\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \070\000\070\000\070\000\070\000\070\000\070\000\000\000\000\000\ - \000\000\031\000\031\000\031\000\031\000\031\000\031\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\070\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\070\000\070\000\070\000\000\000\ - \070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\166\000\166\000\166\000\166\000\ - \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ - \166\000\166\000\166\000\166\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\071\000\000\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\070\000\070\000\070\000\070\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\031\000\070\000\070\000\070\000\070\000\070\000\ - \070\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ + \058\000\058\000\057\000\057\000\057\000\057\000\057\000\057\000\ + \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ + \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ + \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ + \057\000\057\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ + \061\000\061\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ + \063\000\063\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ + \065\000\065\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\ + \069\000\069\000\069\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\069\000\069\000\069\000\069\000\069\000\069\000\ + \000\000\000\000\000\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\000\000\000\000\000\000\000\000\000\000\000\000\069\000\ + \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\ + \069\000\000\000\069\000\069\000\069\000\069\000\069\000\069\000\ + \069\000\069\000\069\000\069\000\069\000\069\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ - \211\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\070\000\070\000\070\000\070\000\070\000\ - \070\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \211\000\211\000\211\000\211\000\211\000\211\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\070\000\000\000\ + \069\000\069\000\069\000\069\000\069\000\069\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\069\000\069\000\069\000\069\000\ + \069\000\069\000\069\000\069\000\069\000\069\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\030\000\069\000\069\000\069\000\ + \069\000\069\000\069\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\069\000\069\000\069\000\ + \069\000\069\000\069\000\011\000\030\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ + \011\000\011\000\011\000\081\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\011\000\011\000\011\000\ @@ -725,93 +730,93 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \011\000\082\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\079\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\032\000\011\000\073\000\073\000\ + \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\ \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\076\000\011\000\011\000\ + \011\000\011\000\011\000\031\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\080\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\033\000\011\000\074\000\074\000\074\000\074\000\ - \074\000\074\000\074\000\074\000\074\000\074\000\011\000\000\000\ + \000\000\011\000\032\000\011\000\073\000\073\000\073\000\073\000\ + \073\000\073\000\073\000\073\000\073\000\073\000\011\000\000\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\032\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\031\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\077\000\011\000\011\000\011\000\011\000\ - \011\000\032\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\076\000\011\000\011\000\011\000\011\000\ + \011\000\031\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\075\000\011\000\011\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \033\000\011\000\074\000\074\000\074\000\074\000\074\000\074\000\ - \074\000\074\000\074\000\074\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\032\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\077\000\077\000\077\000\077\000\077\000\077\000\ + \077\000\077\000\077\000\077\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\077\000\077\000\077\000\077\000\077\000\ + \077\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\077\000\011\000\011\000\011\000\011\000\011\000\032\000\ + \011\000\011\000\011\000\077\000\077\000\077\000\077\000\077\000\ + \077\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\076\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \078\000\078\000\078\000\078\000\078\000\078\000\078\000\078\000\ - \078\000\078\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\078\000\078\000\078\000\078\000\078\000\078\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\ + \073\000\073\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \011\000\078\000\078\000\078\000\078\000\078\000\078\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\074\000\074\000\ - \074\000\074\000\074\000\074\000\074\000\074\000\074\000\074\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\037\000\011\000\077\000\077\000\ + \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\077\000\ + \077\000\077\000\077\000\077\000\077\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\036\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\078\000\011\000\077\000\ + \077\000\077\000\077\000\077\000\077\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\036\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\038\000\011\000\078\000\078\000\078\000\078\000\ - \078\000\078\000\078\000\078\000\078\000\078\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\078\000\078\000\078\000\ - \078\000\078\000\078\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\037\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\077\000\077\000\077\000\077\000\ + \077\000\077\000\077\000\077\000\077\000\077\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\077\000\077\000\077\000\ + \077\000\077\000\077\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\079\000\011\000\078\000\078\000\078\000\ - \078\000\078\000\078\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\037\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\011\000\077\000\077\000\077\000\ + \077\000\077\000\077\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\078\000\078\000\078\000\078\000\078\000\078\000\ - \078\000\078\000\078\000\078\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\078\000\078\000\078\000\078\000\078\000\ - \078\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\011\000\078\000\078\000\078\000\078\000\078\000\ - \078\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \080\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\011\000\011\000\011\000\ @@ -819,11 +824,11 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\081\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ \011\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ @@ -832,24 +837,24 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\082\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\083\000\000\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\083\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\084\000\000\000\011\000\011\000\ + \011\000\011\000\084\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\000\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ @@ -858,9 +863,9 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \085\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ @@ -869,251 +874,239 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \085\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\011\000\011\000\086\000\086\000\ + \086\000\086\000\086\000\086\000\086\000\086\000\086\000\086\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\086\000\ + \086\000\086\000\086\000\086\000\086\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\011\000\086\000\ + \086\000\086\000\086\000\086\000\086\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\086\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\011\000\011\000\087\000\087\000\087\000\087\000\ - \087\000\087\000\087\000\087\000\087\000\087\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\087\000\087\000\087\000\ - \087\000\087\000\087\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\086\000\086\000\086\000\086\000\ + \086\000\086\000\086\000\086\000\086\000\086\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\086\000\086\000\086\000\ + \086\000\086\000\086\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\011\000\087\000\087\000\087\000\ - \087\000\087\000\087\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\087\000\011\000\086\000\086\000\086\000\ + \086\000\086\000\086\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\087\000\087\000\087\000\087\000\087\000\087\000\ - \087\000\087\000\087\000\087\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\087\000\087\000\087\000\087\000\087\000\ - \087\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\086\000\086\000\086\000\086\000\086\000\086\000\ + \086\000\086\000\086\000\086\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\086\000\086\000\086\000\086\000\086\000\ + \086\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\088\000\011\000\087\000\087\000\087\000\087\000\087\000\ - \087\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\086\000\086\000\086\000\086\000\086\000\ + \086\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \087\000\087\000\087\000\087\000\087\000\087\000\087\000\087\000\ - \087\000\087\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\087\000\087\000\087\000\087\000\087\000\087\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \011\000\087\000\087\000\087\000\087\000\087\000\087\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\011\000\011\000\011\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\089\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\088\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\011\000\011\000\011\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\090\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\091\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \000\000\011\000\088\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\088\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \089\000\011\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\089\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\089\000\011\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\089\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\093\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \094\000\000\000\011\000\011\000\011\000\011\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\089\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \088\000\011\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\088\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \092\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\093\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\088\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\094\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\011\000\011\000\011\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\095\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \000\000\011\000\088\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\088\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\095\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \089\000\011\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\089\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\096\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\089\000\011\000\ - \097\000\097\000\097\000\097\000\097\000\097\000\097\000\097\000\ - \097\000\097\000\089\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\097\000\097\000\097\000\097\000\097\000\097\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\089\000\ - \011\000\097\000\097\000\097\000\097\000\097\000\097\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\097\000\097\000\ - \097\000\097\000\097\000\097\000\097\000\097\000\097\000\097\000\ - \089\000\000\000\011\000\011\000\011\000\011\000\011\000\097\000\ - \097\000\097\000\097\000\097\000\097\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\098\000\011\000\097\000\ - \097\000\097\000\097\000\097\000\097\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \088\000\011\000\096\000\096\000\096\000\096\000\096\000\096\000\ + \096\000\096\000\096\000\096\000\088\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\096\000\096\000\096\000\096\000\096\000\ + \096\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\088\000\011\000\096\000\096\000\096\000\096\000\096\000\ + \096\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \096\000\096\000\096\000\096\000\096\000\096\000\096\000\096\000\ + \096\000\096\000\088\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\096\000\096\000\096\000\096\000\096\000\096\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\097\000\ + \011\000\096\000\096\000\096\000\096\000\096\000\096\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\096\000\096\000\ + \096\000\096\000\096\000\096\000\096\000\096\000\096\000\096\000\ + \088\000\000\000\011\000\011\000\011\000\011\000\011\000\096\000\ + \096\000\096\000\096\000\096\000\096\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\096\000\ + \096\000\096\000\096\000\096\000\096\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\097\000\097\000\097\000\097\000\ - \097\000\097\000\097\000\097\000\097\000\097\000\089\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\097\000\097\000\097\000\ - \097\000\097\000\097\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\097\000\097\000\097\000\ - \097\000\097\000\097\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\123\000\011\000\000\000\ - \011\000\000\000\123\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\122\000\122\000\122\000\122\000\122\000\ - \122\000\122\000\122\000\122\000\122\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\122\000\122\000\122\000\122\000\ - \122\000\122\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\123\000\ - \000\000\000\000\000\000\000\000\122\000\122\000\122\000\122\000\ - \122\000\122\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\123\000\000\000\000\000\000\000\123\000\000\000\123\000\ - \121\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\122\000\ + \011\000\000\000\011\000\000\000\122\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\121\000\121\000\121\000\ + \121\000\121\000\121\000\121\000\121\000\121\000\121\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\121\000\121\000\ + \121\000\121\000\121\000\121\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\255\255\113\000\113\000\113\000\113\000\ - \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ - \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ + \000\000\122\000\000\000\000\000\000\000\000\000\121\000\121\000\ + \121\000\121\000\121\000\121\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\122\000\000\000\000\000\000\000\122\000\ + \000\000\122\000\120\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ + \117\000\117\000\117\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ - \113\000\113\000\113\000\113\000\112\000\112\000\112\000\112\000\ + \113\000\113\000\113\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\255\255\112\000\112\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ - \112\000\112\000\112\000\112\000\111\000\111\000\111\000\111\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ - \111\000\111\000\111\000\111\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ + \111\000\111\000\111\000\111\000\111\000\111\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\100\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\000\000\000\000\101\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\125\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\000\000\000\000\000\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\000\000\000\000\ - \102\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\099\000\255\255\255\255\255\255\255\255\ + \110\000\110\000\110\000\110\000\110\000\110\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \099\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\000\000\000\000\ + \100\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\124\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\124\000\124\000\124\000\124\000\124\000\124\000\000\000\ + \000\000\000\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \000\000\000\000\101\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\124\000\124\000\124\000\124\000\124\000\124\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\098\000\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -1121,103 +1114,103 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\107\000\105\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ + \105\000\105\000\105\000\106\000\105\000\105\000\104\000\102\000\ + \102\000\102\000\103\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\099\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\108\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\107\000\106\000\106\000\105\000\103\000\103\000\103\000\ - \104\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\100\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\100\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\099\000\099\000\099\000\ - \099\000\099\000\099\000\099\000\099\000\000\000\000\000\101\000\ - \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\ - \125\000\125\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\125\000\125\000\125\000\125\000\125\000\125\000\000\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\099\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ + \098\000\098\000\098\000\098\000\098\000\098\000\098\000\000\000\ + \000\000\100\000\124\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\124\000\124\000\124\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\126\000\ - \000\000\125\000\125\000\125\000\125\000\125\000\125\000\000\000\ - \000\000\102\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\125\000\000\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\000\000\000\000\101\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\110\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\109\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\099\000\255\255\255\255\255\255\ + \000\000\000\000\000\000\000\000\000\000\000\000\098\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -1225,307 +1218,307 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\109\000\108\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\107\000\106\000\106\000\105\000\103\000\103\000\ - \103\000\104\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\100\000\125\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\000\000\000\000\000\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\107\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ + \105\000\105\000\105\000\105\000\106\000\105\000\105\000\104\000\ + \102\000\102\000\102\000\103\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\099\000\ + \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\124\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\124\000\124\000\124\000\124\000\124\000\124\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\125\000\ - \125\000\125\000\125\000\125\000\125\000\011\000\031\000\011\000\ + \000\000\124\000\124\000\124\000\124\000\124\000\124\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\011\000\011\000\011\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\127\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\128\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \000\000\011\000\088\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\088\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\128\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \089\000\011\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\089\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\129\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\089\000\011\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\089\000\ - \011\000\089\000\089\000\089\000\089\000\130\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\011\000\011\000\011\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\089\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\131\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \088\000\011\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\088\000\011\000\088\000\088\000\088\000\088\000\129\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\088\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\130\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\131\000\011\000\011\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\132\000\011\000\011\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\133\000\132\000\132\000\132\000\ + \132\000\132\000\132\000\132\000\132\000\132\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\134\000\133\000\133\000\133\000\133\000\133\000\ - \133\000\133\000\133\000\133\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\132\000\132\000\132\000\132\000\132\000\132\000\ + \132\000\132\000\132\000\132\000\011\000\000\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\135\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \133\000\133\000\133\000\133\000\133\000\133\000\133\000\133\000\ - \133\000\133\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\ + \132\000\132\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\136\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\011\000\000\000\011\000\135\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\133\000\133\000\ - \133\000\133\000\133\000\133\000\133\000\133\000\133\000\133\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \134\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\011\000\011\000\136\000\136\000\ + \136\000\136\000\136\000\136\000\136\000\136\000\136\000\136\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\136\000\ + \136\000\136\000\136\000\136\000\136\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\136\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\011\000\136\000\ + \136\000\136\000\136\000\136\000\136\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\135\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\011\000\011\000\137\000\137\000\137\000\137\000\ - \137\000\137\000\137\000\137\000\137\000\137\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\137\000\137\000\137\000\ - \137\000\137\000\137\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\132\000\132\000\132\000\132\000\ + \132\000\132\000\132\000\132\000\132\000\132\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\011\000\137\000\137\000\137\000\ - \137\000\137\000\137\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\133\000\133\000\133\000\133\000\133\000\133\000\ - \133\000\133\000\133\000\133\000\011\000\000\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ + \011\000\011\000\136\000\136\000\136\000\136\000\136\000\136\000\ + \136\000\136\000\136\000\136\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\136\000\136\000\136\000\136\000\136\000\ + \136\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\137\000\011\000\136\000\136\000\136\000\136\000\136\000\ + \136\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\ - \137\000\137\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\137\000\137\000\137\000\137\000\137\000\137\000\011\000\ + \136\000\136\000\136\000\136\000\136\000\136\000\136\000\136\000\ + \136\000\136\000\011\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\136\000\136\000\136\000\136\000\136\000\136\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\138\000\ - \011\000\137\000\137\000\137\000\137\000\137\000\137\000\011\000\ + \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \011\000\136\000\136\000\136\000\136\000\136\000\136\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\137\000\137\000\ - \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\137\000\ - \137\000\137\000\137\000\137\000\137\000\011\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\088\000\011\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\011\000\011\000\011\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\088\000\011\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\139\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ + \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ + \000\000\011\000\088\000\011\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\088\000\011\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\140\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\000\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ + \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ + \088\000\011\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\088\000\011\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \141\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\000\000\011\000\011\000\000\000\011\000\088\000\011\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\142\000\011\000\011\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\088\000\ + \011\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\088\000\088\000\088\000\088\000\088\000\ + \088\000\088\000\088\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\011\000\011\000\144\000\143\000\ + \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\011\000\137\000\ - \137\000\137\000\137\000\137\000\137\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ - \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\089\000\011\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\089\000\011\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\140\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ - \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \089\000\011\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\089\000\011\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\141\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\089\000\011\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\089\000\ - \011\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\142\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\089\000\011\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\143\000\011\000\011\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\089\000\011\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\ - \089\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\011\000\011\000\145\000\144\000\144\000\144\000\ - \144\000\144\000\144\000\144\000\144\000\144\000\011\000\000\000\ + \000\000\011\000\011\000\011\000\143\000\143\000\143\000\143\000\ + \143\000\143\000\143\000\143\000\143\000\143\000\011\000\000\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\146\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\144\000\144\000\144\000\144\000\144\000\144\000\ - \144\000\144\000\144\000\144\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\143\000\143\000\143\000\143\000\143\000\143\000\ + \143\000\143\000\143\000\143\000\011\000\000\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\147\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\146\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\145\000\011\000\011\000\000\000\011\000\000\000\ + \011\000\011\000\030\000\011\000\011\000\011\000\011\000\011\000\ \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \144\000\144\000\144\000\144\000\144\000\144\000\144\000\144\000\ - \144\000\144\000\011\000\000\000\011\000\011\000\011\000\011\000\ + \147\000\147\000\147\000\147\000\147\000\147\000\147\000\147\000\ + \147\000\147\000\011\000\000\000\011\000\011\000\011\000\011\000\ + \011\000\147\000\147\000\147\000\147\000\147\000\147\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \011\000\147\000\147\000\147\000\147\000\147\000\147\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\147\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ + \030\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ + \011\000\011\000\000\000\011\000\011\000\011\000\143\000\143\000\ + \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\ + \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \146\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \031\000\011\000\011\000\011\000\011\000\011\000\000\000\000\000\ - \011\000\011\000\000\000\011\000\011\000\011\000\148\000\148\000\ - \148\000\148\000\148\000\148\000\148\000\148\000\148\000\148\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\148\000\ - \148\000\148\000\148\000\148\000\148\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\011\000\148\000\ - \148\000\148\000\148\000\148\000\148\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\000\000\011\000\000\000\011\000\011\000\031\000\011\000\ + \011\000\000\000\011\000\000\000\011\000\011\000\030\000\011\000\ \011\000\011\000\011\000\011\000\000\000\000\000\011\000\011\000\ - \000\000\011\000\011\000\011\000\144\000\144\000\144\000\144\000\ - \144\000\144\000\144\000\144\000\144\000\144\000\011\000\000\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \000\000\011\000\011\000\011\000\147\000\147\000\147\000\147\000\ + \147\000\147\000\147\000\147\000\147\000\147\000\011\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\147\000\147\000\147\000\ + \147\000\147\000\147\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\148\000\011\000\147\000\147\000\147\000\ + \147\000\147\000\147\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\000\000\ - \011\000\000\000\011\000\011\000\031\000\011\000\011\000\011\000\ + \011\000\000\000\011\000\011\000\030\000\011\000\011\000\011\000\ \011\000\011\000\000\000\000\000\011\000\011\000\000\000\011\000\ - \011\000\011\000\148\000\148\000\148\000\148\000\148\000\148\000\ - \148\000\148\000\148\000\148\000\011\000\000\000\011\000\011\000\ - \011\000\011\000\011\000\148\000\148\000\148\000\148\000\148\000\ - \148\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\147\000\147\000\147\000\147\000\147\000\147\000\ + \147\000\147\000\147\000\147\000\011\000\000\000\011\000\011\000\ + \011\000\011\000\011\000\147\000\147\000\147\000\147\000\147\000\ + \147\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\149\000\011\000\148\000\148\000\148\000\148\000\148\000\ - \148\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ + \011\000\011\000\011\000\147\000\147\000\147\000\147\000\147\000\ + \147\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\000\000\011\000\000\000\ - \011\000\011\000\031\000\011\000\011\000\011\000\011\000\011\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ - \148\000\148\000\148\000\148\000\148\000\148\000\148\000\148\000\ - \148\000\148\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\148\000\148\000\148\000\148\000\148\000\148\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\000\000\011\000\000\000\011\000\011\000\ - \011\000\148\000\148\000\148\000\148\000\148\000\148\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\152\000\011\000\000\000\011\000\150\000\ - \031\000\150\000\150\000\150\000\150\000\150\000\000\000\000\000\ - \150\000\150\000\000\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\000\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\000\000\150\000\000\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\000\000\150\000\000\000\150\000\000\000\000\000\000\000\ + \011\000\011\000\011\000\011\000\011\000\151\000\011\000\000\000\ + \011\000\149\000\030\000\149\000\149\000\149\000\149\000\149\000\ + \000\000\000\000\149\000\149\000\000\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\000\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\000\000\149\000\000\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ + \149\000\149\000\149\000\000\000\149\000\000\000\149\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \000\000\000\000\000\000\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -1533,203 +1526,206 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\160\000\160\000\160\000\160\000\160\000\ - \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ - \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ - \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ - \160\000\159\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\157\000\157\000\157\000\157\000\158\000\157\000\ - \157\000\156\000\154\000\154\000\154\000\155\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\158\000\156\000\156\000\156\000\156\000\ + \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ + \157\000\156\000\156\000\155\000\153\000\153\000\153\000\154\000\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\153\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\163\000\163\000\163\000\163\000\163\000\163\000\ - \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ - \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ + \255\255\255\255\255\255\152\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \167\000\167\000\167\000\167\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ - \163\000\163\000\162\000\162\000\162\000\162\000\162\000\162\000\ + \163\000\163\000\163\000\163\000\162\000\162\000\162\000\162\000\ + \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ + \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ + \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ - \162\000\162\000\161\000\161\000\161\000\161\000\161\000\161\000\ + \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ + \162\000\162\000\162\000\162\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ - \161\000\161\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\172\000\176\000\000\000\176\000\176\000\176\000\ + \161\000\161\000\161\000\161\000\160\000\160\000\160\000\160\000\ + \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ + \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ + \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ + \160\000\160\000\160\000\160\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \164\000\164\000\164\000\164\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \166\000\166\000\166\000\166\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \168\000\168\000\168\000\168\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\179\000\172\000\179\000\179\000\ + \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \176\000\000\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\176\000\176\000\176\000\176\000\176\000\176\000\175\000\ - \000\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\000\000\000\000\173\000\000\000\173\000\ + \176\000\176\000\176\000\176\000\000\000\000\000\000\000\000\000\ + \173\000\000\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\171\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\171\000\171\000\171\000\171\000\171\000\ + \173\000\173\000\173\000\173\000\171\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\171\000\171\000\171\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\171\000\000\000\000\000\000\000\ - \000\000\171\000\000\000\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \000\000\000\000\000\000\000\000\171\000\000\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\171\000\173\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \174\000\000\000\000\000\000\000\000\000\000\000\000\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \173\000\173\000\173\000\174\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\000\000\000\000\000\000\000\000\173\000\000\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \173\000\173\000\173\000\173\000\000\000\000\000\000\000\000\000\ + \173\000\000\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\175\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \173\000\173\000\173\000\173\000\175\000\000\000\175\000\175\000\ + \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\000\000\000\000\000\000\ - \000\000\175\000\000\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\175\000\000\000\000\000\000\000\000\000\ + \175\000\000\000\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\176\000\000\000\000\000\ + \175\000\175\000\175\000\175\000\176\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\176\000\176\000\176\000\ + \176\000\176\000\176\000\176\000\176\000\176\000\176\000\177\000\ \000\000\000\000\000\000\000\000\000\000\000\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \177\000\000\000\000\000\000\000\000\000\000\000\000\000\176\000\ - \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\000\000\000\000\000\000\000\000\176\000\000\000\176\000\ + \000\000\000\000\000\000\000\000\176\000\000\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\178\000\000\000\178\000\178\000\178\000\178\000\178\000\ + \178\000\000\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\178\000\178\000\178\000\178\000\178\000\000\000\000\000\ + \178\000\178\000\178\000\178\000\178\000\000\000\000\000\000\000\ + \000\000\000\000\000\000\000\000\000\000\178\000\178\000\178\000\ + \178\000\178\000\178\000\178\000\178\000\178\000\178\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ + \000\000\000\000\000\000\000\000\178\000\000\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\000\000\000\000\000\000\000\000\178\000\000\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\011\000\031\000\011\000\011\000\011\000\011\000\179\000\ - \000\000\000\000\011\000\011\000\000\000\011\000\011\000\011\000\ + \179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\011\000\000\000\011\000\011\000\011\000\011\000\ - \011\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\179\000\000\000\000\000\000\000\000\000\ + \179\000\000\000\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\000\000\011\000\000\000\011\000\179\000\ - \011\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\000\000\011\000\000\000\011\000\180\000\ + \179\000\179\000\179\000\179\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ @@ -1753,7 +1749,7 @@ let __ocaml_lex_tables = { \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ - \180\000\180\000\180\000\180\000\180\000\180\000\180\000\185\000\ + \180\000\180\000\180\000\180\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ @@ -1761,7 +1757,7 @@ let __ocaml_lex_tables = { \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ - \185\000\185\000\185\000\185\000\185\000\185\000\185\000\180\000\ + \185\000\185\000\185\000\185\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ @@ -1769,7 +1765,7 @@ let __ocaml_lex_tables = { \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ - \180\000\180\000\180\000\180\000\180\000\180\000\180\000\187\000\ + \180\000\180\000\180\000\180\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ @@ -1777,7 +1773,7 @@ let __ocaml_lex_tables = { \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ - \187\000\187\000\187\000\187\000\187\000\187\000\187\000\180\000\ + \187\000\187\000\187\000\187\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ @@ -1785,7 +1781,7 @@ let __ocaml_lex_tables = { \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ - \180\000\180\000\180\000\180\000\180\000\180\000\180\000\189\000\ + \180\000\180\000\180\000\180\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ @@ -1793,7 +1789,7 @@ let __ocaml_lex_tables = { \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ - \189\000\189\000\189\000\189\000\189\000\189\000\189\000\180\000\ + \189\000\189\000\189\000\189\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ @@ -1801,14 +1797,13 @@ let __ocaml_lex_tables = { \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ \180\000\180\000\180\000\180\000\180\000\180\000\180\000\180\000\ - \180\000\180\000\180\000\180\000\180\000\180\000\180\000\201\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \180\000\180\000\180\000\180\000\201\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\202\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \000\000\000\000\202\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \203\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ + \000\000\000\000\000\000\000\000\000\000\203\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ @@ -1816,7 +1811,8 @@ let __ocaml_lex_tables = { \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ - \213\000\000\000\000\000\000\000\000\000\191\000\191\000\191\000\ + \213\000\213\000\213\000\213\000\213\000\213\000\000\000\000\000\ + \000\000\000\000\191\000\191\000\191\000\191\000\191\000\191\000\ \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ @@ -1824,21 +1820,21 @@ let __ocaml_lex_tables = { \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ - \191\000\191\000\191\000\191\000\191\000\191\000\191\000\199\000\ + \191\000\191\000\191\000\191\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ - \199\000\199\000\199\000\199\000\199\000\198\000\196\000\196\000\ - \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ - \196\000\196\000\197\000\196\000\196\000\195\000\193\000\193\000\ - \193\000\194\000\191\000\191\000\191\000\191\000\191\000\191\000\ - \191\000\191\000\191\000\191\000\191\000\192\000\209\000\209\000\ + \199\000\199\000\198\000\196\000\196\000\196\000\196\000\196\000\ + \196\000\196\000\196\000\196\000\196\000\196\000\196\000\197\000\ + \196\000\196\000\195\000\193\000\193\000\193\000\194\000\191\000\ + \191\000\191\000\191\000\191\000\191\000\191\000\191\000\191\000\ + \191\000\191\000\192\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ - \209\000\209\000\209\000\209\000\209\000\209\000\208\000\208\000\ + \209\000\209\000\209\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ @@ -1846,15 +1842,15 @@ let __ocaml_lex_tables = { \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ - \208\000\208\000\208\000\208\000\208\000\208\000\207\000\207\000\ + \208\000\208\000\208\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ - \207\000\207\000\207\000\207\000\207\000\207\000\206\000\206\000\ + \207\000\207\000\207\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ - \206\000\206\000\206\000\206\000\206\000\206\000\200\000\200\000\ + \206\000\206\000\206\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ @@ -1886,7 +1882,7 @@ let __ocaml_lex_tables = { \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ - \200\000\200\000\200\000\200\000\200\000\200\000\210\000\210\000\ + \200\000\200\000\200\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ @@ -1894,7 +1890,7 @@ let __ocaml_lex_tables = { \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ - \210\000\210\000\210\000\210\000\210\000\210\000\200\000\200\000\ + \210\000\210\000\210\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ @@ -1902,7 +1898,7 @@ let __ocaml_lex_tables = { \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ - \200\000\200\000\200\000\200\000\200\000\200\000\212\000\212\000\ + \200\000\200\000\200\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ @@ -1910,7 +1906,7 @@ let __ocaml_lex_tables = { \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ - \212\000\212\000\212\000\212\000\212\000\212\000\200\000\200\000\ + \212\000\212\000\212\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ @@ -1918,7 +1914,7 @@ let __ocaml_lex_tables = { \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ - \200\000\200\000\200\000\200\000\200\000\200\000\214\000\214\000\ + \200\000\200\000\200\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ @@ -1926,7 +1922,7 @@ let __ocaml_lex_tables = { \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ - \214\000\214\000\214\000\214\000\214\000\214\000\200\000\200\000\ + \214\000\214\000\214\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ @@ -1934,7 +1930,7 @@ let __ocaml_lex_tables = { \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ \200\000\200\000\200\000\200\000\200\000\200\000\200\000\200\000\ - \200\000\200\000\200\000\200\000\200\000\200\000\000\000\000\000\ + \200\000\200\000\200\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ @@ -1942,7 +1938,7 @@ let __ocaml_lex_tables = { \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000"; + \000\000\000\000\000\000\000\000"; Lexing.lex_check = "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ @@ -1959,7 +1955,7 @@ let __ocaml_lex_tables = { \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\000\ + \000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\ \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ @@ -1968,13 +1964,13 @@ let __ocaml_lex_tables = { \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ \002\000\002\000\002\000\002\000\002\000\002\000\002\000\002\000\ - \029\000\067\000\000\000\000\000\000\000\000\000\000\000\000\000\ + \028\000\066\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ - \000\000\000\000\000\000\000\000\000\000\121\000\202\000\203\000\ + \000\000\000\000\000\000\000\000\000\000\120\000\202\000\203\000\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \000\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\ \003\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\ @@ -2019,25 +2015,29 @@ let __ocaml_lex_tables = { \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ \011\000\011\000\011\000\011\000\011\000\011\000\011\000\011\000\ - \011\000\011\000\011\000\255\255\011\000\255\255\011\000\012\000\ - \012\000\012\000\012\000\012\000\012\000\012\000\255\255\255\255\ - \012\000\012\000\255\255\012\000\012\000\012\000\012\000\012\000\ - \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\255\255\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\013\000\012\000\255\255\012\000\012\000\012\000\012\000\ + \011\000\011\000\011\000\012\000\011\000\255\255\011\000\051\000\ + \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ + \051\000\051\000\051\000\051\000\051\000\051\000\051\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\012\000\ + \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ + \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\012\000\255\255\ \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ \012\000\012\000\012\000\012\000\012\000\012\000\012\000\012\000\ - \012\000\255\255\012\000\255\255\012\000\052\000\052\000\052\000\ - \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ - \052\000\052\000\052\000\052\000\052\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\013\000\255\255\013\000\013\000\ - \013\000\013\000\013\000\013\000\013\000\013\000\013\000\013\000\ - \013\000\013\000\013\000\013\000\013\000\013\000\013\000\013\000\ - \013\000\013\000\013\000\013\000\013\000\013\000\013\000\013\000\ + \012\000\012\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\255\255\255\255\017\000\017\000\255\255\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\255\255\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\255\255\017\000\255\255\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\017\000\017\000\017\000\017\000\ + \017\000\017\000\017\000\017\000\255\255\017\000\255\255\017\000\ \018\000\018\000\018\000\018\000\018\000\018\000\018\000\255\255\ \255\255\018\000\018\000\255\255\018\000\018\000\018\000\018\000\ \018\000\018\000\018\000\018\000\018\000\018\000\018\000\018\000\ @@ -2074,49 +2074,49 @@ let __ocaml_lex_tables = { \020\000\020\000\020\000\020\000\020\000\020\000\020\000\020\000\ \020\000\020\000\020\000\020\000\020\000\020\000\255\255\020\000\ \255\255\020\000\021\000\021\000\021\000\021\000\021\000\021\000\ - \021\000\255\255\255\255\021\000\021\000\255\255\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ - \021\000\021\000\021\000\021\000\255\255\021\000\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\049\000\255\255\021\000\255\255\255\255\049\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ + \049\000\049\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\049\000\049\000\049\000\049\000\049\000\049\000\154\000\ + \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ + \154\000\154\000\154\000\154\000\154\000\154\000\154\000\255\255\ + \255\255\255\255\255\255\255\255\049\000\255\255\021\000\255\255\ + \255\255\049\000\049\000\049\000\049\000\049\000\049\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\049\000\255\255\ + \255\255\255\255\049\000\255\255\049\000\049\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ - \021\000\021\000\021\000\021\000\255\255\021\000\255\255\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ - \021\000\021\000\021\000\021\000\255\255\021\000\255\255\021\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \050\000\255\255\022\000\255\255\255\255\050\000\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\050\000\050\000\ - \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\050\000\ - \050\000\050\000\050\000\050\000\050\000\104\000\104\000\104\000\ - \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ - \104\000\104\000\104\000\104\000\104\000\255\255\255\255\255\255\ - \255\255\255\255\050\000\255\255\022\000\255\255\255\255\050\000\ - \050\000\050\000\050\000\050\000\050\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\050\000\255\255\255\255\255\255\ - \050\000\255\255\050\000\050\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ - \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\ + \021\000\021\000\021\000\022\000\022\000\022\000\022\000\022\000\ + \022\000\022\000\255\255\255\255\022\000\022\000\255\255\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ + \022\000\022\000\022\000\022\000\022\000\255\255\022\000\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ + \022\000\022\000\022\000\022\000\022\000\255\255\022\000\255\255\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ \022\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\ + \022\000\022\000\022\000\022\000\022\000\255\255\022\000\255\255\ \022\000\023\000\023\000\023\000\023\000\023\000\023\000\023\000\ \255\255\255\255\023\000\023\000\255\255\023\000\023\000\023\000\ \023\000\023\000\023\000\023\000\023\000\023\000\023\000\023\000\ @@ -2164,45 +2164,45 @@ let __ocaml_lex_tables = { \026\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\ \026\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\ \026\000\026\000\026\000\026\000\026\000\255\255\026\000\255\255\ - \026\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \255\255\255\255\027\000\027\000\255\255\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\255\255\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\255\255\027\000\255\255\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\027\000\027\000\027\000\027\000\027\000\ - \027\000\027\000\027\000\255\255\027\000\255\255\027\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ + \026\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\ + \255\255\255\255\255\255\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\030\000\030\000\ + \030\000\030\000\030\000\030\000\030\000\030\000\031\000\031\000\ + \031\000\031\000\031\000\031\000\031\000\255\255\255\255\031\000\ + \031\000\255\255\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\031\000\031\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\ - \051\000\051\000\051\000\051\000\051\000\051\000\255\255\255\255\ \255\255\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ + \255\255\031\000\255\255\031\000\031\000\031\000\031\000\031\000\ + \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\ - \031\000\031\000\031\000\031\000\032\000\032\000\032\000\032\000\ + \255\255\031\000\255\255\031\000\032\000\032\000\032\000\032\000\ \032\000\032\000\032\000\255\255\255\255\032\000\032\000\255\255\ \032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\ \032\000\032\000\032\000\032\000\032\000\032\000\255\255\032\000\ @@ -2402,40 +2402,37 @@ let __ocaml_lex_tables = { \048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\ \048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\ \048\000\048\000\048\000\048\000\048\000\048\000\255\255\048\000\ - \255\255\048\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\255\255\255\255\049\000\049\000\255\255\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\255\255\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\255\255\049\000\255\255\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\ - \049\000\049\000\049\000\049\000\255\255\049\000\255\255\049\000\ + \255\255\048\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\ + \052\000\052\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ + \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\ + \053\000\053\000\054\000\054\000\054\000\054\000\054\000\054\000\ \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\ - \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\ + \054\000\054\000\055\000\055\000\055\000\055\000\055\000\055\000\ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\ + \055\000\055\000\056\000\056\000\056\000\056\000\056\000\056\000\ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\ + \056\000\056\000\057\000\057\000\057\000\057\000\057\000\057\000\ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ @@ -2443,8 +2440,7 @@ let __ocaml_lex_tables = { \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ - \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\ - \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ + \057\000\057\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ @@ -2452,6 +2448,7 @@ let __ocaml_lex_tables = { \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\ + \058\000\058\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ @@ -2459,8 +2456,7 @@ let __ocaml_lex_tables = { \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ - \059\000\059\000\059\000\059\000\059\000\059\000\059\000\059\000\ - \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ + \059\000\059\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ @@ -2468,6 +2464,7 @@ let __ocaml_lex_tables = { \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ \060\000\060\000\060\000\060\000\060\000\060\000\060\000\060\000\ + \060\000\060\000\061\000\061\000\061\000\061\000\061\000\061\000\ \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ @@ -2475,8 +2472,7 @@ let __ocaml_lex_tables = { \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \061\000\061\000\061\000\061\000\061\000\061\000\061\000\061\000\ - \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ + \061\000\061\000\062\000\062\000\062\000\062\000\062\000\062\000\ \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ @@ -2484,6 +2480,7 @@ let __ocaml_lex_tables = { \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ \062\000\062\000\062\000\062\000\062\000\062\000\062\000\062\000\ + \062\000\062\000\063\000\063\000\063\000\063\000\063\000\063\000\ \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ @@ -2491,8 +2488,7 @@ let __ocaml_lex_tables = { \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ - \063\000\063\000\063\000\063\000\063\000\063\000\063\000\063\000\ - \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \063\000\063\000\064\000\064\000\064\000\064\000\064\000\064\000\ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ @@ -2500,6 +2496,7 @@ let __ocaml_lex_tables = { \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\ + \064\000\064\000\065\000\065\000\065\000\065\000\065\000\065\000\ \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ @@ -2507,37 +2504,40 @@ let __ocaml_lex_tables = { \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \065\000\065\000\065\000\065\000\065\000\065\000\065\000\065\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\ - \068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\ - \068\000\068\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\068\000\068\000\068\000\068\000\068\000\068\000\069\000\ + \065\000\065\000\067\000\067\000\067\000\067\000\067\000\067\000\ + \067\000\067\000\067\000\067\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\067\000\067\000\067\000\067\000\067\000\ + \067\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\ + \068\000\068\000\068\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\068\000\068\000\068\000\068\000\068\000\068\000\ + \255\255\255\255\255\255\067\000\067\000\067\000\067\000\067\000\ + \067\000\255\255\255\255\255\255\255\255\255\255\255\255\069\000\ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\ - \069\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \069\000\255\255\068\000\068\000\068\000\068\000\068\000\068\000\ + \069\000\069\000\069\000\069\000\069\000\069\000\194\000\194\000\ + \194\000\194\000\194\000\194\000\194\000\194\000\194\000\194\000\ + \194\000\194\000\194\000\194\000\194\000\194\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\069\000\255\255\ \069\000\069\000\069\000\069\000\069\000\069\000\255\255\255\255\ - \255\255\068\000\068\000\068\000\068\000\068\000\068\000\255\255\ + \255\255\255\255\255\255\255\255\070\000\070\000\070\000\070\000\ + \070\000\070\000\070\000\070\000\070\000\070\000\255\255\255\255\ + \255\255\255\255\255\255\255\255\069\000\070\000\070\000\070\000\ + \070\000\070\000\070\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\070\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\070\000\070\000\070\000\255\255\ - \069\000\069\000\069\000\069\000\069\000\069\000\070\000\070\000\ - \070\000\070\000\070\000\070\000\155\000\155\000\155\000\155\000\ - \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ - \155\000\155\000\155\000\155\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\070\000\255\255\070\000\070\000\ - \070\000\070\000\070\000\070\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\071\000\071\000\071\000\071\000\071\000\071\000\ - \071\000\071\000\071\000\071\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\070\000\071\000\071\000\071\000\071\000\071\000\ - \071\000\194\000\194\000\194\000\194\000\194\000\194\000\194\000\ - \194\000\194\000\194\000\194\000\194\000\194\000\194\000\194\000\ - \194\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\071\000\071\000\071\000\071\000\071\000\ + \070\000\070\000\070\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\255\255\255\255\071\000\071\000\255\255\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\255\255\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\255\255\071\000\255\255\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\ + \071\000\071\000\071\000\071\000\071\000\255\255\071\000\255\255\ \071\000\072\000\072\000\072\000\072\000\072\000\072\000\072\000\ \255\255\255\255\072\000\072\000\255\255\072\000\072\000\072\000\ \072\000\072\000\072\000\072\000\072\000\072\000\072\000\072\000\ @@ -2843,106 +2843,102 @@ let __ocaml_lex_tables = { \097\000\097\000\097\000\097\000\097\000\097\000\097\000\097\000\ \097\000\097\000\097\000\097\000\097\000\097\000\097\000\097\000\ \097\000\097\000\097\000\097\000\097\000\097\000\097\000\097\000\ - \097\000\255\255\097\000\255\255\097\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\255\255\255\255\098\000\098\000\ - \255\255\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\255\255\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\255\255\ - \098\000\255\255\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\098\000\ - \098\000\098\000\098\000\098\000\098\000\098\000\098\000\255\255\ - \098\000\255\255\098\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\255\255\255\255\101\000\101\000\255\255\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\255\255\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\255\255\101\000\255\255\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\101\000\101\000\101\000\ - \101\000\101\000\101\000\101\000\101\000\102\000\101\000\255\255\ - \101\000\255\255\102\000\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\102\000\102\000\102\000\102\000\102\000\ - \102\000\102\000\102\000\102\000\102\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\102\000\102\000\102\000\102\000\ - \102\000\102\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \097\000\255\255\097\000\255\255\097\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\255\255\255\255\100\000\100\000\ + \255\255\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\255\255\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\255\255\ + \100\000\255\255\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\100\000\ + \100\000\100\000\100\000\100\000\100\000\100\000\100\000\101\000\ + \100\000\255\255\100\000\255\255\101\000\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\101\000\101\000\101\000\ + \101\000\101\000\101\000\101\000\101\000\101\000\101\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\101\000\101\000\ + \101\000\101\000\101\000\101\000\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\102\000\ - \255\255\255\255\255\255\255\255\102\000\102\000\102\000\102\000\ - \102\000\102\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\102\000\255\255\255\255\255\255\102\000\255\255\102\000\ - \102\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\103\000\103\000\103\000\103\000\103\000\103\000\103\000\ - \103\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\101\000\255\255\255\255\255\255\255\255\101\000\101\000\ + \101\000\101\000\101\000\101\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\101\000\255\255\255\255\255\255\101\000\ + \255\255\101\000\101\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\102\000\102\000\102\000\102\000\102\000\ + \102\000\102\000\102\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\104\000\104\000\104\000\104\000\104\000\ + \104\000\104\000\104\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\101\000\105\000\105\000\ \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ - \105\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\102\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\105\000\105\000\ + \105\000\105\000\105\000\105\000\105\000\105\000\106\000\106\000\ \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ \106\000\106\000\106\000\106\000\106\000\106\000\106\000\106\000\ - \106\000\106\000\106\000\106\000\107\000\107\000\107\000\107\000\ + \106\000\106\000\106\000\106\000\106\000\106\000\107\000\107\000\ \107\000\107\000\107\000\107\000\107\000\107\000\107\000\107\000\ \107\000\107\000\107\000\107\000\107\000\107\000\107\000\107\000\ \107\000\107\000\107\000\107\000\107\000\107\000\107\000\107\000\ - \107\000\107\000\107\000\107\000\108\000\108\000\108\000\108\000\ + \107\000\107\000\107\000\107\000\107\000\107\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ - \108\000\108\000\108\000\108\000\109\000\109\000\109\000\109\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\108\000\108\000\ + \108\000\108\000\108\000\108\000\108\000\108\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\255\255\255\255\ + \109\000\121\000\121\000\121\000\121\000\121\000\121\000\121\000\ + \121\000\121\000\121\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\121\000\121\000\121\000\121\000\121\000\121\000\ + \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ + \123\000\123\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\123\000\123\000\123\000\123\000\123\000\123\000\255\255\ + \255\255\255\255\121\000\121\000\121\000\121\000\121\000\121\000\ + \255\255\255\255\109\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\123\000\123\000\123\000\123\000\123\000\123\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ - \109\000\109\000\109\000\109\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\255\255\255\255\110\000\122\000\ - \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ - \122\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \122\000\122\000\122\000\122\000\122\000\122\000\124\000\124\000\ - \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\124\000\ - \124\000\124\000\124\000\124\000\124\000\255\255\255\255\255\255\ - \122\000\122\000\122\000\122\000\122\000\122\000\255\255\255\255\ - \110\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\124\000\ - \124\000\124\000\124\000\124\000\124\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\109\000\ + \109\000\109\000\109\000\109\000\109\000\109\000\109\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ @@ -2950,7 +2946,7 @@ let __ocaml_lex_tables = { \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ \110\000\110\000\110\000\110\000\110\000\110\000\110\000\110\000\ - \110\000\110\000\110\000\110\000\110\000\111\000\111\000\111\000\ + \110\000\110\000\110\000\110\000\110\000\110\000\110\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ @@ -2958,7 +2954,7 @@ let __ocaml_lex_tables = { \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ \111\000\111\000\111\000\111\000\111\000\111\000\111\000\111\000\ - \111\000\111\000\111\000\111\000\111\000\112\000\112\000\112\000\ + \111\000\111\000\111\000\111\000\111\000\111\000\111\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ @@ -2966,7 +2962,7 @@ let __ocaml_lex_tables = { \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ \112\000\112\000\112\000\112\000\112\000\112\000\112\000\112\000\ - \112\000\112\000\112\000\112\000\112\000\113\000\113\000\113\000\ + \112\000\112\000\112\000\112\000\112\000\112\000\112\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ @@ -2974,7 +2970,7 @@ let __ocaml_lex_tables = { \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ \113\000\113\000\113\000\113\000\113\000\113\000\113\000\113\000\ - \113\000\113\000\113\000\113\000\113\000\114\000\114\000\114\000\ + \113\000\113\000\113\000\113\000\113\000\113\000\113\000\114\000\ \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ @@ -2982,7 +2978,7 @@ let __ocaml_lex_tables = { \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ \114\000\114\000\114\000\114\000\114\000\114\000\114\000\114\000\ - \114\000\114\000\114\000\114\000\114\000\115\000\115\000\115\000\ + \114\000\114\000\114\000\114\000\114\000\114\000\114\000\115\000\ \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ @@ -2990,7 +2986,7 @@ let __ocaml_lex_tables = { \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ \115\000\115\000\115\000\115\000\115\000\115\000\115\000\115\000\ - \115\000\115\000\115\000\115\000\115\000\116\000\116\000\116\000\ + \115\000\115\000\115\000\115\000\115\000\115\000\115\000\116\000\ \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ @@ -2998,7 +2994,7 @@ let __ocaml_lex_tables = { \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ \116\000\116\000\116\000\116\000\116\000\116\000\116\000\116\000\ - \116\000\116\000\116\000\116\000\116\000\117\000\117\000\117\000\ + \116\000\116\000\116\000\116\000\116\000\116\000\116\000\117\000\ \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ @@ -3006,7 +3002,7 @@ let __ocaml_lex_tables = { \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ \117\000\117\000\117\000\117\000\117\000\117\000\117\000\117\000\ - \117\000\117\000\117\000\117\000\117\000\118\000\118\000\118\000\ + \117\000\117\000\117\000\117\000\117\000\117\000\117\000\118\000\ \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ @@ -3014,54 +3010,58 @@ let __ocaml_lex_tables = { \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ \118\000\118\000\118\000\118\000\118\000\118\000\118\000\118\000\ - \118\000\118\000\118\000\118\000\118\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\119\000\119\000\119\000\ - \119\000\119\000\119\000\119\000\119\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\255\255\255\255\123\000\ + \118\000\118\000\118\000\118\000\118\000\118\000\118\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\255\255\ + \255\255\122\000\124\000\124\000\124\000\124\000\124\000\124\000\ + \124\000\124\000\124\000\124\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\124\000\124\000\124\000\124\000\124\000\ + \124\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\124\000\255\255\124\000\124\000\124\000\124\000\124\000\ + \124\000\255\255\255\255\122\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\124\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ + \122\000\122\000\122\000\122\000\122\000\122\000\122\000\122\000\ \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\ \125\000\125\000\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\125\000\125\000\125\000\125\000\125\000\125\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\125\000\ - \255\255\125\000\125\000\125\000\125\000\125\000\125\000\255\255\ - \255\255\123\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\125\000\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\123\000\123\000\ - \123\000\123\000\123\000\123\000\123\000\123\000\126\000\126\000\ + \255\255\125\000\125\000\125\000\125\000\125\000\125\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\255\255\255\255\ + \126\000\126\000\255\255\126\000\126\000\126\000\126\000\126\000\ \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\126\000\ - \126\000\126\000\126\000\126\000\126\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\126\000\ - \126\000\126\000\126\000\126\000\126\000\127\000\127\000\127\000\ + \126\000\255\255\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\255\255\126\000\255\255\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\126\000\126\000\126\000\126\000\126\000\126\000\126\000\ + \126\000\255\255\126\000\255\255\126\000\127\000\127\000\127\000\ \127\000\127\000\127\000\127\000\255\255\255\255\127\000\127\000\ \255\255\127\000\127\000\127\000\127\000\127\000\127\000\127\000\ \127\000\127\000\127\000\127\000\127\000\127\000\127\000\255\255\ @@ -3319,7 +3319,7 @@ let __ocaml_lex_tables = { \148\000\148\000\148\000\148\000\148\000\148\000\148\000\148\000\ \148\000\148\000\148\000\148\000\148\000\148\000\148\000\148\000\ \148\000\148\000\148\000\148\000\148\000\148\000\148\000\148\000\ - \148\000\148\000\148\000\148\000\148\000\255\255\148\000\255\255\ + \148\000\148\000\148\000\148\000\148\000\150\000\148\000\255\255\ \148\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ \255\255\255\255\149\000\149\000\255\255\149\000\149\000\149\000\ \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ @@ -3331,68 +3331,64 @@ let __ocaml_lex_tables = { \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ \149\000\149\000\149\000\149\000\149\000\149\000\149\000\149\000\ - \149\000\149\000\149\000\151\000\149\000\255\255\149\000\150\000\ - \150\000\150\000\150\000\150\000\150\000\150\000\255\255\255\255\ - \150\000\150\000\255\255\150\000\150\000\150\000\150\000\150\000\ + \149\000\149\000\149\000\255\255\149\000\255\255\149\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\255\255\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\255\255\150\000\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\255\255\150\000\255\255\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ - \150\000\255\255\150\000\255\255\150\000\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\151\000\151\000\151\000\151\000\151\000\151\000\ - \151\000\151\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\ - \154\000\154\000\156\000\156\000\156\000\156\000\156\000\156\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\150\000\150\000\150\000\150\000\ + \150\000\150\000\150\000\150\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\ + \153\000\153\000\153\000\153\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\155\000\155\000\155\000\155\000\ + \155\000\155\000\155\000\155\000\156\000\156\000\156\000\156\000\ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ - \156\000\156\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ + \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ + \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\ + \156\000\156\000\156\000\156\000\157\000\157\000\157\000\157\000\ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\ - \157\000\157\000\158\000\158\000\158\000\158\000\158\000\158\000\ + \157\000\157\000\157\000\157\000\158\000\158\000\158\000\158\000\ \158\000\158\000\158\000\158\000\158\000\158\000\158\000\158\000\ \158\000\158\000\158\000\158\000\158\000\158\000\158\000\158\000\ \158\000\158\000\158\000\158\000\158\000\158\000\158\000\158\000\ - \158\000\158\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \158\000\158\000\158\000\158\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ - \159\000\159\000\160\000\160\000\160\000\160\000\160\000\160\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\159\000\159\000\159\000\159\000\ + \159\000\159\000\159\000\159\000\160\000\160\000\160\000\160\000\ \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ @@ -3400,7 +3396,7 @@ let __ocaml_lex_tables = { \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ \160\000\160\000\160\000\160\000\160\000\160\000\160\000\160\000\ - \160\000\160\000\161\000\161\000\161\000\161\000\161\000\161\000\ + \160\000\160\000\160\000\160\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ @@ -3408,7 +3404,7 @@ let __ocaml_lex_tables = { \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ \161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\ - \161\000\161\000\162\000\162\000\162\000\162\000\162\000\162\000\ + \161\000\161\000\161\000\161\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ @@ -3416,7 +3412,7 @@ let __ocaml_lex_tables = { \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ \162\000\162\000\162\000\162\000\162\000\162\000\162\000\162\000\ - \162\000\162\000\163\000\163\000\163\000\163\000\163\000\163\000\ + \162\000\162\000\162\000\162\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ @@ -3424,7 +3420,7 @@ let __ocaml_lex_tables = { \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\ - \163\000\163\000\164\000\164\000\164\000\164\000\164\000\164\000\ + \163\000\163\000\163\000\163\000\164\000\164\000\164\000\164\000\ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ @@ -3432,7 +3428,7 @@ let __ocaml_lex_tables = { \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\ - \164\000\164\000\165\000\165\000\165\000\165\000\165\000\165\000\ + \164\000\164\000\164\000\164\000\165\000\165\000\165\000\165\000\ \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ @@ -3440,7 +3436,7 @@ let __ocaml_lex_tables = { \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ \165\000\165\000\165\000\165\000\165\000\165\000\165\000\165\000\ - \165\000\165\000\166\000\166\000\166\000\166\000\166\000\166\000\ + \165\000\165\000\165\000\165\000\166\000\166\000\166\000\166\000\ \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ @@ -3448,7 +3444,7 @@ let __ocaml_lex_tables = { \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ \166\000\166\000\166\000\166\000\166\000\166\000\166\000\166\000\ - \166\000\166\000\167\000\167\000\167\000\167\000\167\000\167\000\ + \166\000\166\000\166\000\166\000\167\000\167\000\167\000\167\000\ \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ @@ -3456,7 +3452,7 @@ let __ocaml_lex_tables = { \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ \167\000\167\000\167\000\167\000\167\000\167\000\167\000\167\000\ - \167\000\167\000\168\000\168\000\168\000\168\000\168\000\168\000\ + \167\000\167\000\167\000\167\000\168\000\168\000\168\000\168\000\ \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ @@ -3464,93 +3460,88 @@ let __ocaml_lex_tables = { \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ \168\000\168\000\168\000\168\000\168\000\168\000\168\000\168\000\ - \168\000\168\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ + \168\000\168\000\168\000\168\000\169\000\170\000\169\000\169\000\ \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\ - \169\000\169\000\170\000\172\000\255\255\172\000\172\000\172\000\ + \172\000\255\255\172\000\172\000\172\000\172\000\172\000\172\000\ \172\000\172\000\172\000\172\000\172\000\172\000\172\000\172\000\ \172\000\172\000\172\000\172\000\172\000\172\000\172\000\172\000\ - \172\000\172\000\172\000\172\000\172\000\172\000\172\000\174\000\ - \255\255\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ - \174\000\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ - \174\000\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ - \174\000\174\000\174\000\255\255\255\255\170\000\255\255\170\000\ - \170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\ + \172\000\172\000\172\000\172\000\255\255\255\255\255\255\255\255\ + \170\000\255\255\170\000\170\000\170\000\170\000\170\000\170\000\ \170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\ \170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\ - \170\000\171\000\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\171\000\171\000\171\000\171\000\171\000\ + \170\000\170\000\170\000\170\000\171\000\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\171\000\171\000\171\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\255\255\ + \255\255\255\255\255\255\255\255\255\255\255\255\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\171\000\255\255\255\255\255\255\ - \255\255\171\000\255\255\171\000\171\000\171\000\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \255\255\255\255\255\255\255\255\171\000\255\255\171\000\171\000\ \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ - \171\000\171\000\171\000\171\000\171\000\173\000\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\173\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\255\255\255\255\255\255\255\255\255\255\255\255\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\ + \173\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \173\000\173\000\173\000\173\000\255\255\255\255\255\255\255\255\ + \255\255\255\255\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\255\255\255\255\255\255\255\255\173\000\255\255\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ + \173\000\173\000\173\000\173\000\255\255\255\255\255\255\255\255\ + \173\000\255\255\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ \173\000\173\000\173\000\173\000\173\000\173\000\173\000\173\000\ - \173\000\175\000\255\255\255\255\255\255\255\255\255\255\255\255\ + \173\000\173\000\173\000\173\000\174\000\255\255\174\000\174\000\ + \174\000\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ + \174\000\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ + \174\000\174\000\174\000\174\000\174\000\174\000\174\000\174\000\ + \175\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\255\255\255\255\255\255\ - \255\255\175\000\255\255\175\000\175\000\175\000\175\000\175\000\ + \175\000\175\000\175\000\175\000\255\255\255\255\255\255\255\255\ + \175\000\255\255\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ \175\000\175\000\175\000\175\000\175\000\175\000\175\000\175\000\ - \175\000\175\000\175\000\175\000\175\000\176\000\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\176\000\176\000\ + \175\000\175\000\175\000\175\000\176\000\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\255\255\255\255\255\255\255\255\255\255\255\255\176\000\ + \255\255\255\255\255\255\255\255\255\255\255\255\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\255\255\255\255\255\255\255\255\176\000\255\255\176\000\ + \255\255\255\255\255\255\255\255\176\000\255\255\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ \176\000\176\000\176\000\176\000\176\000\176\000\176\000\176\000\ - \176\000\177\000\255\255\177\000\177\000\177\000\177\000\177\000\ + \177\000\255\255\177\000\177\000\177\000\177\000\177\000\177\000\ \177\000\177\000\177\000\177\000\177\000\177\000\177\000\177\000\ \177\000\177\000\177\000\177\000\177\000\177\000\177\000\177\000\ - \177\000\177\000\177\000\177\000\177\000\178\000\255\255\255\255\ + \177\000\177\000\177\000\177\000\178\000\255\255\255\255\255\255\ + \255\255\255\255\255\255\255\255\255\255\178\000\178\000\178\000\ + \178\000\178\000\178\000\178\000\178\000\178\000\178\000\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ + \255\255\255\255\255\255\255\255\178\000\255\255\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\255\255\255\255\255\255\255\255\178\000\255\255\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\178\000\178\000\178\000\178\000\178\000\178\000\178\000\ - \178\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \255\255\255\255\179\000\179\000\255\255\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\255\255\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ + \255\255\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\255\255\255\255\255\255\255\255\255\255\ + \255\255\255\255\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\255\255\179\000\255\255\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ + \179\000\179\000\179\000\179\000\255\255\255\255\255\255\255\255\ + \179\000\255\255\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ \179\000\179\000\179\000\179\000\179\000\179\000\179\000\179\000\ - \179\000\179\000\179\000\255\255\179\000\255\255\179\000\181\000\ + \179\000\179\000\179\000\179\000\181\000\181\000\181\000\181\000\ \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ @@ -3558,7 +3549,7 @@ let __ocaml_lex_tables = { \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ \181\000\181\000\181\000\181\000\181\000\181\000\181\000\181\000\ - \181\000\181\000\181\000\181\000\181\000\181\000\181\000\182\000\ + \181\000\181\000\181\000\181\000\182\000\182\000\182\000\182\000\ \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ @@ -3566,7 +3557,7 @@ let __ocaml_lex_tables = { \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\ - \182\000\182\000\182\000\182\000\182\000\182\000\182\000\183\000\ + \182\000\182\000\182\000\182\000\183\000\183\000\183\000\183\000\ \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ @@ -3574,7 +3565,7 @@ let __ocaml_lex_tables = { \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\ - \183\000\183\000\183\000\183\000\183\000\183\000\183\000\184\000\ + \183\000\183\000\183\000\183\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ @@ -3582,7 +3573,7 @@ let __ocaml_lex_tables = { \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\ - \184\000\184\000\184\000\184\000\184\000\184\000\184\000\185\000\ + \184\000\184\000\184\000\184\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ @@ -3590,7 +3581,7 @@ let __ocaml_lex_tables = { \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\ - \185\000\185\000\185\000\185\000\185\000\185\000\185\000\186\000\ + \185\000\185\000\185\000\185\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ @@ -3598,7 +3589,7 @@ let __ocaml_lex_tables = { \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ \186\000\186\000\186\000\186\000\186\000\186\000\186\000\186\000\ - \186\000\186\000\186\000\186\000\186\000\186\000\186\000\187\000\ + \186\000\186\000\186\000\186\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ @@ -3606,7 +3597,7 @@ let __ocaml_lex_tables = { \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ \187\000\187\000\187\000\187\000\187\000\187\000\187\000\187\000\ - \187\000\187\000\187\000\187\000\187\000\187\000\187\000\188\000\ + \187\000\187\000\187\000\187\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ @@ -3614,7 +3605,7 @@ let __ocaml_lex_tables = { \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ \188\000\188\000\188\000\188\000\188\000\188\000\188\000\188\000\ - \188\000\188\000\188\000\188\000\188\000\188\000\188\000\189\000\ + \188\000\188\000\188\000\188\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ @@ -3622,14 +3613,13 @@ let __ocaml_lex_tables = { \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ \189\000\189\000\189\000\189\000\189\000\189\000\189\000\189\000\ - \189\000\189\000\189\000\189\000\189\000\189\000\189\000\190\000\ + \189\000\189\000\189\000\189\000\190\000\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\190\000\255\255\255\255\ + \255\255\255\255\190\000\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \190\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ + \255\255\255\255\255\255\255\255\255\255\190\000\193\000\193\000\ \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ @@ -3637,7 +3627,8 @@ let __ocaml_lex_tables = { \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ \193\000\193\000\193\000\193\000\193\000\193\000\193\000\193\000\ - \193\000\255\255\255\255\255\255\255\255\190\000\190\000\190\000\ + \193\000\193\000\193\000\193\000\193\000\193\000\255\255\255\255\ + \255\255\255\255\190\000\190\000\190\000\190\000\190\000\190\000\ \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ @@ -3653,13 +3644,13 @@ let __ocaml_lex_tables = { \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ \190\000\190\000\190\000\190\000\190\000\190\000\190\000\190\000\ - \190\000\190\000\190\000\190\000\190\000\190\000\195\000\195\000\ + \190\000\190\000\190\000\195\000\195\000\195\000\195\000\195\000\ \195\000\195\000\195\000\195\000\195\000\195\000\195\000\195\000\ \195\000\195\000\195\000\195\000\195\000\195\000\195\000\195\000\ \195\000\195\000\195\000\195\000\195\000\195\000\195\000\195\000\ \195\000\195\000\195\000\195\000\195\000\195\000\195\000\195\000\ \195\000\195\000\195\000\195\000\195\000\195\000\195\000\195\000\ - \195\000\195\000\195\000\195\000\195\000\195\000\196\000\196\000\ + \195\000\195\000\195\000\196\000\196\000\196\000\196\000\196\000\ \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ @@ -3667,15 +3658,15 @@ let __ocaml_lex_tables = { \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ \196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\ - \196\000\196\000\196\000\196\000\196\000\196\000\197\000\197\000\ + \196\000\196\000\196\000\197\000\197\000\197\000\197\000\197\000\ \197\000\197\000\197\000\197\000\197\000\197\000\197\000\197\000\ \197\000\197\000\197\000\197\000\197\000\197\000\197\000\197\000\ \197\000\197\000\197\000\197\000\197\000\197\000\197\000\197\000\ - \197\000\197\000\197\000\197\000\197\000\197\000\198\000\198\000\ + \197\000\197\000\197\000\198\000\198\000\198\000\198\000\198\000\ \198\000\198\000\198\000\198\000\198\000\198\000\198\000\198\000\ \198\000\198\000\198\000\198\000\198\000\198\000\198\000\198\000\ \198\000\198\000\198\000\198\000\198\000\198\000\198\000\198\000\ - \198\000\198\000\198\000\198\000\198\000\198\000\199\000\199\000\ + \198\000\198\000\198\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ @@ -3683,7 +3674,7 @@ let __ocaml_lex_tables = { \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ \199\000\199\000\199\000\199\000\199\000\199\000\199\000\199\000\ - \199\000\199\000\199\000\199\000\199\000\199\000\206\000\206\000\ + \199\000\199\000\199\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ @@ -3691,7 +3682,7 @@ let __ocaml_lex_tables = { \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ \206\000\206\000\206\000\206\000\206\000\206\000\206\000\206\000\ - \206\000\206\000\206\000\206\000\206\000\206\000\207\000\207\000\ + \206\000\206\000\206\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ @@ -3699,7 +3690,7 @@ let __ocaml_lex_tables = { \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ \207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\ - \207\000\207\000\207\000\207\000\207\000\207\000\208\000\208\000\ + \207\000\207\000\207\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ @@ -3707,7 +3698,7 @@ let __ocaml_lex_tables = { \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ \208\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\ - \208\000\208\000\208\000\208\000\208\000\208\000\209\000\209\000\ + \208\000\208\000\208\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ @@ -3715,7 +3706,7 @@ let __ocaml_lex_tables = { \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ \209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\ - \209\000\209\000\209\000\209\000\209\000\209\000\210\000\210\000\ + \209\000\209\000\209\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ @@ -3723,7 +3714,7 @@ let __ocaml_lex_tables = { \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ \210\000\210\000\210\000\210\000\210\000\210\000\210\000\210\000\ - \210\000\210\000\210\000\210\000\210\000\210\000\211\000\211\000\ + \210\000\210\000\210\000\211\000\211\000\211\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ @@ -3731,7 +3722,7 @@ let __ocaml_lex_tables = { \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ \211\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\ - \211\000\211\000\211\000\211\000\211\000\211\000\212\000\212\000\ + \211\000\211\000\211\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ @@ -3739,7 +3730,7 @@ let __ocaml_lex_tables = { \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\ - \212\000\212\000\212\000\212\000\212\000\212\000\213\000\213\000\ + \212\000\212\000\212\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ @@ -3747,7 +3738,7 @@ let __ocaml_lex_tables = { \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ \213\000\213\000\213\000\213\000\213\000\213\000\213\000\213\000\ - \213\000\213\000\213\000\213\000\213\000\213\000\214\000\214\000\ + \213\000\213\000\213\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ @@ -3755,7 +3746,7 @@ let __ocaml_lex_tables = { \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\ - \214\000\214\000\214\000\214\000\214\000\214\000\255\255\255\255\ + \214\000\214\000\214\000\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ @@ -3763,7 +3754,7 @@ let __ocaml_lex_tables = { \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\ - \255\255\255\255\255\255\255\255\255\255\255\255\255\255"; + \255\255\255\255\255\255\255\255"; Lexing.lex_base_code = "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\ @@ -3973,174 +3964,174 @@ let rec token lexbuf = and __ocaml_lex_token_rec lexbuf __ocaml_lex_state = match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with | 0 -> -# 95 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 96 "lib/lexers/wasm_lexer/wasm_lex.mll" ( LPAREN ) -# 3966 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3957 "lib/lexers/wasm_lexer/wasm_lex.ml" | 1 -> -# 96 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 97 "lib/lexers/wasm_lexer/wasm_lex.mll" ( RPAREN ) -# 3971 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3962 "lib/lexers/wasm_lexer/wasm_lex.ml" | 2 -> let -# 99 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 100 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 3977 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3968 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in -# 99 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 100 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Atom s ) -# 3981 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3972 "lib/lexers/wasm_lexer/wasm_lex.ml" | 3 -> let -# 100 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 101 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 3987 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3978 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in -# 100 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 101 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Atom ( s ) ) -# 3991 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3982 "lib/lexers/wasm_lexer/wasm_lex.ml" | 4 -> -# 104 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 105 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "unclosed string literal" ) -# 3996 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3987 "lib/lexers/wasm_lexer/wasm_lex.ml" | 5 -> -# 106 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 107 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "illegal control character in string literal" ) -# 4001 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3992 "lib/lexers/wasm_lexer/wasm_lex.ml" | 6 -> -# 108 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 109 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error_nest (Lexing.lexeme_end_p lexbuf) lexbuf "illegal escape" ) -# 4006 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 3997 "lib/lexers/wasm_lexer/wasm_lex.ml" | 7 -> let -# 113 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 114 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 4012 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4003 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in -# 113 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 114 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Atom s ) -# 4016 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4007 "lib/lexers/wasm_lexer/wasm_lex.ml" | 8 -> -# 115 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 116 "lib/lexers/wasm_lexer/wasm_lex.mll" ( EOF ) -# 4021 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4012 "lib/lexers/wasm_lexer/wasm_lex.ml" | 9 -> -# 116 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 117 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Lexing.new_line lexbuf; token lexbuf ) -# 4026 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4017 "lib/lexers/wasm_lexer/wasm_lex.ml" | 10 -> -# 117 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 118 "lib/lexers/wasm_lexer/wasm_lex.mll" ( token lexbuf (* causes error on following position *) ) -# 4031 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4022 "lib/lexers/wasm_lexer/wasm_lex.ml" | 11 -> -# 118 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 119 "lib/lexers/wasm_lexer/wasm_lex.mll" ( comment (Lexing.lexeme_start_p lexbuf) lexbuf; token lexbuf ) -# 4036 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4027 "lib/lexers/wasm_lexer/wasm_lex.ml" | 12 -> -# 119 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 120 "lib/lexers/wasm_lexer/wasm_lex.mll" ( token lexbuf ) -# 4041 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4032 "lib/lexers/wasm_lexer/wasm_lex.ml" | 13 -> -# 120 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 121 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Lexing.new_line lexbuf; token lexbuf ) -# 4046 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4037 "lib/lexers/wasm_lexer/wasm_lex.ml" | 14 -> -# 121 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 122 "lib/lexers/wasm_lexer/wasm_lex.mll" ( EOF ) -# 4051 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4042 "lib/lexers/wasm_lexer/wasm_lex.ml" | 15 -> let -# 122 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 123 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 4057 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4048 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in -# 122 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 123 "lib/lexers/wasm_lexer/wasm_lex.mll" (ANTIQUOT(`Id,s)) -# 4061 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4052 "lib/lexers/wasm_lexer/wasm_lex.ml" | 16 -> let -# 123 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 124 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 4067 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4058 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_curr_pos in -# 123 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 124 "lib/lexers/wasm_lexer/wasm_lex.mll" (ANTIQUOT(`String, s)) -# 4071 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4062 "lib/lexers/wasm_lexer/wasm_lex.ml" | 17 -> let -# 124 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" fn -# 4077 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4068 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_mem.(0) and -# 124 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 4082 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4073 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_mem.(0) + 1) lexbuf.Lexing.lex_curr_pos in -# 124 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" (ANTIQUOT(`Fn fn, s)) -# 4086 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4077 "lib/lexers/wasm_lexer/wasm_lex.ml" | 18 -> let -# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 126 "lib/lexers/wasm_lexer/wasm_lex.mll" fn -# 4092 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4083 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) lexbuf.Lexing.lex_mem.(0) and -# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 126 "lib/lexers/wasm_lexer/wasm_lex.mll" s -# 4097 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4088 "lib/lexers/wasm_lexer/wasm_lex.ml" = Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_mem.(0) + 1) lexbuf.Lexing.lex_curr_pos in -# 125 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 126 "lib/lexers/wasm_lexer/wasm_lex.mll" (ANTIQUOT(`Sexp_of_fn fn, s)) -# 4101 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4092 "lib/lexers/wasm_lexer/wasm_lex.ml" | 19 -> let -# 126 "lib/lexers/wasm_lexer/wasm_lex.mll" - s -# 4107 "lib/lexers/wasm_lexer/wasm_lex.ml" -= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in -# 126 "lib/lexers/wasm_lexer/wasm_lex.mll" - (ANTIQUOT_SEXP s) -# 4111 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 127 "lib/lexers/wasm_lexer/wasm_lex.mll" + s +# 4098 "lib/lexers/wasm_lexer/wasm_lex.ml" += Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_curr_pos in +# 127 "lib/lexers/wasm_lexer/wasm_lex.mll" + (ANTIQUOT_SEXP s) +# 4102 "lib/lexers/wasm_lexer/wasm_lex.ml" | 20 -> -# 127 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 128 "lib/lexers/wasm_lexer/wasm_lex.mll" ( unknown lexbuf ) -# 4116 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4107 "lib/lexers/wasm_lexer/wasm_lex.ml" | 21 -> -# 128 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 129 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "misplaced control character" ) -# 4121 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4112 "lib/lexers/wasm_lexer/wasm_lex.ml" | 22 -> -# 129 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 130 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "misplaced unicode character" ) -# 4126 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4117 "lib/lexers/wasm_lexer/wasm_lex.ml" | 23 -> -# 130 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 131 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "malformed UTF-8 encoding" ) -# 4131 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4122 "lib/lexers/wasm_lexer/wasm_lex.ml" | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_token_rec lexbuf __ocaml_lex_state @@ -4150,34 +4141,34 @@ and comment start lexbuf = and __ocaml_lex_comment_rec start lexbuf __ocaml_lex_state = match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with | 0 -> -# 133 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 134 "lib/lexers/wasm_lexer/wasm_lex.mll" ( () ) -# 4143 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4134 "lib/lexers/wasm_lexer/wasm_lex.ml" | 1 -> -# 134 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 135 "lib/lexers/wasm_lexer/wasm_lex.mll" ( comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf ) -# 4148 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4139 "lib/lexers/wasm_lexer/wasm_lex.ml" | 2 -> -# 135 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 136 "lib/lexers/wasm_lexer/wasm_lex.mll" ( Lexing.new_line lexbuf; comment start lexbuf ) -# 4153 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4144 "lib/lexers/wasm_lexer/wasm_lex.ml" | 3 -> -# 136 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 137 "lib/lexers/wasm_lexer/wasm_lex.mll" ( comment start lexbuf ) -# 4158 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4149 "lib/lexers/wasm_lexer/wasm_lex.ml" | 4 -> -# 137 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 138 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error_nest start lexbuf "unclosed comment" ) -# 4163 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4154 "lib/lexers/wasm_lexer/wasm_lex.ml" | 5 -> -# 138 "lib/lexers/wasm_lexer/wasm_lex.mll" +# 139 "lib/lexers/wasm_lexer/wasm_lex.mll" ( error lexbuf "malformed UTF-8 encoding" ) -# 4168 "lib/lexers/wasm_lexer/wasm_lex.ml" +# 4159 "lib/lexers/wasm_lexer/wasm_lex.ml" | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comment_rec start lexbuf __ocaml_lex_state diff --git a/src/wasm_of_clam_gc.ml b/src/wasm_of_clam_gc.ml index faed29f..125b8ff 100644 --- a/src/wasm_of_clam_gc.ml +++ b/src/wasm_of_clam_gc.ml @@ -19,75 +19,81 @@ module Lst = Basic_lst module Ltype = Ltype_gc module Ltype_util = Ltype_gc_util module Tid = Basic_ty_ident +module UInt32 = Basic_uint32 +module UInt64 = Basic_uint64 +module Ast = Dwarfsm_ast -module List = struct - include List +type instr = Dwarfsm_ast.instr - let cons = Wasm_util.cons_peephole +let empty_binder = Wasmlinear_constr.empty_binder +and int_const = Wasmlinear_constr.int_const +and i32_const = Wasmlinear_constr.i32_const +and i64_const = Wasmlinear_constr.i64_const +and f32_const = Wasmlinear_constr.f32_const +and f64_const = Wasmlinear_constr.f64_const +and ( @: ) = Wasmlinear_constr.( @: ) +and ( @> ) = Wasmlinear_constr.( @> ) +and call = Wasmlinear_constr.call +and if_ = Wasmlinear_constr.if_ +and block = Wasmlinear_constr.block +and loop = Wasmlinear_constr.loop +and try_table = Wasmlinear_constr.try_table +and catch = Wasmlinear_constr.catch +and br_ = Wasmlinear_constr.br_ +and br = Wasmlinear_constr.br +and func = Wasmlinear_constr.func +and i32 = Wasmlinear_constr.i32 +and i64 = Wasmlinear_constr.i64 +and f32 = Wasmlinear_constr.f32 +and f64 = Wasmlinear_constr.f64 +and export = Wasmlinear_constr.export +and import = Wasmlinear_constr.import +and memory = Wasmlinear_constr.memory +and start = Wasmlinear_constr.start +and immut = Wasmlinear_constr.immut +and mut = Wasmlinear_constr.mut +and externref = Wasmlinear_constr.externref +and funcref = Wasmlinear_constr.funcref - let rec append l1 l2 = - match l1 with [] -> l2 | hd :: tl -> cons hd (append tl l2) -end - -type instr = Wasm_util.instr - -let i32_to_sexp = Wasm_util.i32_to_sexp -let int32_to_sexp = Wasm_util.int32_to_sexp -let i64_to_sexp = Wasm_util.i64_to_sexp -let f32_to_sexp = Wasm_util.f32_to_sexp -let f64_to_sexp = Wasm_util.f64_to_sexp -let u32_to_sexp = Wasm_util.u32_to_sexp -let u64_to_sexp = Wasm_util.u64_to_sexp -let tid_to_string = Transl_type.tid_to_wasm_name -let tid_to_sexp = Transl_type.tid_to_sexp -let ltype_to_sexp = Transl_type.ltype_to_sexp -let id_to_string = Ident.to_wasm_name -let label_to_string = Label.to_wasm_name - -let id_to_sexp (id : Ident.t) = - match id with - | Pident _ | Pmutable_ident _ -> - (List - (List.cons - (Atom "local.get" : W.t) - ([ Atom (id_to_string id) ] : W.t list)) - : W.t) - | Pdot { ty; _ } -> - if Ltype_util.is_non_nullable_ref_type ty then - (List - (List.cons - (Atom "ref.as_non_null" : W.t) - ([ - List - (List.cons - (Atom "global.get" : W.t) - ([ Atom (id_to_string id) ] : W.t list)); - ] - : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "global.get" : W.t) - ([ Atom (id_to_string id) ] : W.t list)) - : W.t) - -let compile_source_type (typ : Ltype.t) = - match typ with - | I32_Int -> Wasm_util.compile_source_type "int" - | I32_Char -> Wasm_util.compile_source_type "char" - | I32_Bool -> Wasm_util.compile_source_type "bool" - | I32_Unit -> Wasm_util.compile_source_type "unit" - | I32_Byte -> Wasm_util.compile_source_type "byte" - | I64 -> Wasm_util.compile_source_type "int64" - | F64 -> Wasm_util.compile_source_type "double" - | F32 -> Wasm_util.compile_source_type "float" - | _ -> [] +let global = Wasmgc_constr.global +and ref_ = Wasmgc_constr.ref_ +and null = Wasmgc_constr.null +and ref_null = Wasmgc_constr.ref_null +and anyref = Wasmgc_constr.anyref +and ref_extern_ = Wasmgc_constr.ref_extern_ +and array_get_u = Wasmgc_constr.array_get_u +and array_set = Wasmgc_constr.array_set +and array_set_ = Wasmgc_constr.array_set_ +and array_get_u_ = Wasmgc_constr.array_get_u_ +and struct_new = Wasmgc_constr.struct_new +and ref_func = Wasmgc_constr.ref_func +and generic_get = Wasmgc_constr.generic_get +and ref_cast = Wasmgc_constr.ref_cast +and global_set = Wasmgc_constr.global_set +and global_get_ = Wasmgc_constr.global_get_ +and local_set = Wasmgc_constr.local_set +and local_get_ = Wasmgc_constr.local_get_ +and result = Wasmgc_constr.result +and param = Wasmgc_constr.param +and local = Wasmgc_constr.local +and struct_get = Wasmgc_constr.struct_get +and struct_set = Wasmgc_constr.struct_set +and call_ref = Wasmgc_constr.call_ref +and local_get = Wasmgc_constr.local_get +and array_copy = Wasmgc_constr.array_copy +and array_fill = Wasmgc_constr.array_fill +and array_new = Wasmgc_constr.array_new +and array_new_ = Wasmgc_constr.array_new_ +and array_new_default = Wasmgc_constr.array_new_default +and array_get = Wasmgc_constr.array_get +and array_get_s = Wasmgc_constr.array_get_s +and array_new_fixed = Wasmgc_constr.array_new_fixed +and struct_new_default = Wasmgc_constr.struct_new_default +and ref_cast_ = Wasmgc_constr.ref_cast_ let addr_to_string = Basic_fn_address.to_wasm_name -let add_cst = Wasm_util.add_cst +let add_cst = Wasmir_util.add_cst let add_dummy_i32 rest = add_cst 0 rest -let int_to_string = string_of_int type loop_info = { params : Ident.t list; break_used : bool ref } @@ -95,2331 +101,893 @@ type ctx = { locals : Ident_set.t ref; loop_info : loop_info Label.Map.t; join_points : Ident.t list Join.Hash.t; + return_type : Ltype.t list; } let ( +> ) (ctx : ctx) id = ctx.locals := Ident_set.add !(ctx.locals) id +let i32_zero : instr = int_const 0 +let i32_minus_one : instr = int_const (-1) +let i64_zero : instr = i64_const 0L +let f32_zero : instr = F32_const ("0", Float.zero) +let f64_zero : instr = F64_const ("0", Float.zero) -type func = W.t - -let i32_zero : W.t = - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) : W.t) - -let i32_minus_one : W.t = - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "-1" ] : W.t list)) : W.t) - -let i64_zero : W.t = - (List (List.cons (Atom "i64.const" : W.t) ([ Atom "0" ] : W.t list)) : W.t) +let zero (t : Ltype.t) = + (match t with + | I64 -> i64_zero + | F32 -> f32_zero + | F64 -> f64_zero + | I32 { kind = I32_Option_Char } -> i32_minus_one + | I32 _ -> i32_zero + | Ref_extern -> ref_null "extern" + | Ref_string -> ref_null "$moonbit.string" + | Ref_bytes -> ref_null "$moonbit.bytes" + | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> + ref_null (Tid.to_wasm_name tid) + | Ref_func -> ref_null "func" + | Ref_any -> ref_null "any" + : instr) -let f32_zero : W.t = - (List (List.cons (Atom "f32.const" : W.t) ([ Atom "0" ] : W.t list)) : W.t) +let compilePrimitive (fn : Primitive.prim) (rest : instr list) = + (match fn with + | Pccall { func_name = "add_string"; _ } -> + call "$moonbit.add_string" @: rest + | Pprintln -> call "$moonbit.println" @: add_dummy_i32 rest + | Pfixedarray_length -> Array_len @: rest + | Pgetbytesitem { safe = _ } -> array_get_u_ "$moonbit.bytes" @: rest + | Psetbytesitem { safe = _ } -> + array_set_ "$moonbit.bytes" @: add_dummy_i32 rest + | Pgetstringitem { safe = _ } -> + (if !Basic_config.use_js_builtin_string then + call "$moonbit.js_string.charCodeAt" + else array_get_u_ "$moonbit.string") + :: rest + | Pbyteslength -> Array_len @: rest + | Pstringlength -> + (if !Basic_config.use_js_builtin_string then + call "$moonbit.js_string.length" + else Array_len) + :: rest + | Pstringequal -> call "$moonbit.string_equal" @: rest + | Pbytesequal -> call "$moonbit.bytes_equal" @: rest + | Pccall { func_name = "int_is_pos"; _ } -> + int_const 0 @: Ast.I32_gt_s @: rest + | Pccall { func_name = "int_is_neg"; _ } -> + int_const 0 @: Ast.I32_lt_s @: rest + | Pccall { func_name = "int_is_non_pos"; _ } -> + int_const 0 @: Ast.I32_le_s @: rest + | Pccall { func_name = "int_is_non_neg"; _ } -> + int_const 0 @: Ast.I32_ge_s @: rest + | Parith { operand_type; operator } -> + Wasmir_util.compile_arith operand_type operator :: rest + | Pconvert { kind; from; to_ } -> + Wasmir_util.compile_convert kind from to_ rest + | Pbitwise { operand_type; operator } -> + Wasmir_util.compile_bitwise operand_type operator rest + | Pcomparison { operand_type; operator } -> + Wasmir_util.compile_comparison operand_type operator :: rest + | Prefeq -> Ref_eq @: rest + | Pignore -> Drop @: int_const 0 @: rest + | Pidentity -> rest + | Pccall { func_name = "default_int" | "default_char" | "default_bool"; _ } + -> + i32_zero :: rest + | Pccall { func_name = "default_int64"; _ } -> i64_zero :: rest + | Pccall { func_name = "default_float"; _ } -> f64_zero :: rest + | Pnot -> I32_eqz @: rest + | Ppanic -> + if !Basic_config.test_mode then call "$throw" @: [ Unreachable ] + else [ Unreachable ] + | Punreachable -> [ Unreachable ] + | Pnull -> ref_null "none" @: rest + | Pnull_string_extern -> ref_null "extern" @: rest + | Pas_non_null -> Ref_as_non_null @: rest + | Pis_null -> Ref_is_null @: rest + | Praw_func_to_func_ref -> rest + | Pfixedarray_make _ | Pfixedarray_get_item _ | Pfixedarray_set_item _ + | Penum_field _ | Pset_enum_field _ | Parray_make | Pintrinsic _ | Pcompare _ + | Pcatch | Pcast _ | Pclosure_to_extern_ref | Pmake_value_or_error _ + | Perror_to_string | Pany_to_string | Pcall_object_method _ | Pmakebytes + | Pget_current_continuation | Prun_async | Pccall _ -> + failwith + (("Unsupported primitive " ^ S.to_string (Primitive.sexp_of_prim fn) + : Stdlib.String.t) + [@merlin.hide]) + : instr list) -let f64_zero : W.t = - (List (List.cons (Atom "f64.const" : W.t) ([ Atom "0" ] : W.t list)) : W.t) - -let zero (t : Ltype.t) : W.t = - match t with - | I64 -> i64_zero - | F32 -> f32_zero - | F64 -> f64_zero - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag -> i32_zero - | I32_Option_Char -> i32_minus_one - | Ref_extern -> - (List (List.cons (Atom "ref.null" : W.t) ([ Atom "extern" ] : W.t list)) - : W.t) - | Ref_string -> - (List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "$moonbit.string" ] : W.t list)) - : W.t) - | Ref_bytes -> - (List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list)) - : W.t) - | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> - (List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - | Ref_func -> - (List (List.cons (Atom "ref.null" : W.t) ([ Atom "func" ] : W.t list)) - : W.t) - | Ref_any -> - (List (List.cons (Atom "ref.null" : W.t) ([ Atom "any" ] : W.t list)) - : W.t) - -let compilePrimitive (fn : Primitive.prim) (rest : instr list) : instr list = - match fn with - | Pccall { func_name = "add_string"; _ } -> - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.add_string" ] : W.t list)) - : W.t) - :: rest - | Pprintln -> - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.println" ] : W.t list)) - : W.t) - :: add_dummy_i32 rest - | Pfixedarray_length -> (List ([ Atom "array.len" ] : W.t list) : W.t) :: rest - | Pgetbytesitem -> - (List - (List.cons - (Atom "array.get_u" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list)) - : W.t) - :: rest - | Psetbytesitem -> - (List - (List.cons - (Atom "array.set" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list)) - : W.t) - :: add_dummy_i32 rest - | Pgetstringitem -> - (if !Basic_config.use_js_builtin_string then - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.js_string.charCodeAt" ] : W.t list)) - : W.t) - else - (List - (List.cons - (Atom "array.get_u" : W.t) - ([ Atom "$moonbit.string" ] : W.t list)) - : W.t)) - :: rest - | Pbyteslength -> - List.cons (List ([ Atom "array.len" ] : W.t list) : W.t) (rest : W.t list) - | Pstringlength -> - (if !Basic_config.use_js_builtin_string then - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.js_string.length" ] : W.t list)) - : W.t) - else (List ([ Atom "array.len" ] : W.t list) : W.t)) - :: rest - | Pstringequal -> - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.string_equal" ] : W.t list)) - : W.t) - :: rest - | Pccall { func_name = "int_is_pos"; _ } -> - List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.gt_s" ] : W.t list) : W.t) - (rest : W.t list)) - | Pccall { func_name = "int_is_neg"; _ } -> - List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.lt_s" ] : W.t list) : W.t) - (rest : W.t list)) - | Pccall { func_name = "int_is_non_pos"; _ } -> - List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.le_s" ] : W.t list) : W.t) - (rest : W.t list)) - | Pccall { func_name = "int_is_non_neg"; _ } -> - List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.ge_s" ] : W.t list) : W.t) - (rest : W.t list)) - | Parith { operand_type; operator } -> - Wasm_util.compile_arith operand_type operator :: rest - | Pconvert { kind; from; to_ } -> Wasm_util.compile_convert kind from to_ rest - | Pbitwise { operand_type; operator } -> - Wasm_util.compile_bitwise operand_type operator rest - | Pcomparison { operand_type; operator } -> - Wasm_util.compile_comparison operand_type operator :: rest - | Prefeq -> - List.cons (List ([ Atom "ref.eq" ] : W.t list) : W.t) (rest : W.t list) - | Pignore -> - List.cons - (List ([ Atom "drop" ] : W.t list) : W.t) - (List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list)) - | Pidentity -> rest - | Pccall { func_name = "default_int" | "default_char" | "default_bool"; _ } -> - i32_zero :: rest - | Pccall { func_name = "default_int64"; _ } -> i64_zero :: rest - | Pccall { func_name = "default_float"; _ } -> f64_zero :: rest - | Psequand | Psequor -> assert false - | Pnot -> - List.cons (List ([ Atom "i32.eqz" ] : W.t list) : W.t) (rest : W.t list) - | Praise -> - List.cons - (List ([ Atom "unreachable" ] : W.t list) : W.t) - (rest : W.t list) - | Ppanic -> - if !Basic_config.test_mode then - List.cons - (List (List.cons (Atom "call" : W.t) ([ Atom "$throw" ] : W.t list)) - : W.t) - ([ List ([ Atom "unreachable" ] : W.t list) ] : W.t list) - else ([ List ([ Atom "unreachable" ] : W.t list) ] : W.t list) - | Punreachable -> ([ List ([ Atom "unreachable" ] : W.t list) ] : W.t list) - | Pnull -> - (List (List.cons (Atom "ref.null" : W.t) ([ Atom "none" ] : W.t list)) - : W.t) - :: rest - | Pnull_string_extern -> - (List (List.cons (Atom "ref.null" : W.t) ([ Atom "extern" ] : W.t list)) - : W.t) - :: rest - | Pas_non_null -> (List ([ Atom "ref.as_non_null" ] : W.t list) : W.t) :: rest - | Pis_null -> (List ([ Atom "ref.is_null" ] : W.t list) : W.t) :: rest - | Pfixedarray_make _ | Pfixedarray_get_item _ | Pfixedarray_set_item _ - | Penum_field _ | Pset_enum_field _ | Parray_make | Pintrinsic _ | Pcompare _ - | Pcatch | Pcast _ | Pclosure_to_extern_ref | Pmake_value_or_error _ - | Perror_to_string | Pany_to_string | Pcall_object_method _ | Pmakebytes - | Pccall _ -> - failwith - ("Unsupported primitive ${fn |> Primitive.sexp_of_prim |> W.to_string}" - : Stdlib.String.t) - -let compileClosure ~(global_ctx : Global_ctx2.t) (it : Clam.closure) rest : - instr list = - match (it.captures, it.address) with - | [], Normal fn_addr -> - Global_ctx2.add_func_ref global_ctx fn_addr; - let tid = it.tid in - List.cons - (List - (List.cons - (Atom "struct.new" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ - List - (List.cons - (Atom "ref.func" : W.t) - ([ Atom (addr_to_string fn_addr) ] : W.t list)); - ] - : W.t list))) - : W.t) - (rest : W.t list) - | captures, Normal address -> - Global_ctx2.add_func_ref global_ctx address; - let tid_capture = it.tid in - let captures = Lst.map captures (fun c : W.t -> id_to_sexp c) in - List.cons - (List - (List.cons - (Atom "struct.new" : W.t) - (List.cons - (Atom (tid_to_string tid_capture) : W.t) - (List.cons - (List - (List.cons - (Atom "ref.func" : W.t) - ([ Atom (addr_to_string address) ] : W.t list)) - : W.t) - (captures : W.t list)))) - : W.t) - (rest : W.t list) - | captures, Object methods -> - let tid = it.tid in - let methods = - Lst.map methods (fun method_addr -> - Global_ctx2.add_func_ref global_ctx method_addr; - (List - (List.cons - (Atom "ref.func" : W.t) - ([ Atom (addr_to_string method_addr) ] : W.t list)) - : W.t)) - in - let captures = Lst.map captures (fun c : W.t -> id_to_sexp c) in - List.cons - (List - (List.cons - (Atom "struct.new" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.append (methods : W.t list) (captures : W.t list)))) - : W.t) - (rest : W.t list) - | _, Well_known_mut_rec -> assert false +let compileClosure ~(global_ctx : Global_ctx2.t) (it : Clam.closure) rest = + (match (it.captures, it.address) with + | [], Normal fn_addr -> + Global_ctx2.add_func_ref global_ctx fn_addr; + let tid = it.tid in + ref_func fn_addr @: struct_new tid @: rest + | captures, Normal address -> + Global_ctx2.add_func_ref global_ctx address; + let tid_capture = it.tid in + let captures = Lst.concat_map captures generic_get in + ref_func address @: captures @> struct_new tid_capture @: rest + | _, Well_known_mut_rec -> assert false + : instr list) let rec compileExpr ~(tail : bool) ~ctx ~global_ctx ~type_defs - (body : Clam.lambda) (rest : instr list) : instr list = - let body_loc = Clam_util.loc_of_lambda body in - let rest = Wasm_util.prepend_end_source_pos body_loc rest in - Wasm_util.prepend_start_source_pos body_loc - (compileExpr0 ~tail ~ctx ~global_ctx ~type_defs body rest) + (body : Clam.lambda) (rest : instr list) = + (let body_loc = Clam_util.loc_of_lambda body in + let rest = Wasmir_util.prepend_end_source_pos body_loc rest in + Wasmir_util.prepend_start_source_pos body_loc + (compileExpr0 ~tail ~ctx ~global_ctx ~type_defs body rest) + : instr list) and compileExpr0 ~(tail : bool) ~ctx ~global_ctx ~type_defs (body : Clam.lambda) - (rest : instr list) : instr list = - let got body rest = - compileExpr ~ctx ~global_ctx ~tail ~type_defs body rest - [@@inline] - in - let gon body rest = - compileExpr ~ctx ~global_ctx ~tail:false ~type_defs body rest - [@@inline] - in - let gos_non_tail args rest = List.fold_right gon args rest [@@inline] in - let new_ident ~ty name = - let ptr = Ident.fresh name ~ty in - ctx +> ptr; - ptr - [@@inline] - in - let new_label name = Label.fresh name [@@inline] in - match body with - | Levent { expr; _ } -> got expr rest - | Lconst constant -> ( - match constant with - | C_int i -> add_cst (Int32.to_int i.v) rest - | C_int64 i -> - let iv = i.v in - (i64_to_sexp iv : W.t) :: rest - | C_uint { v; _ } -> (u32_to_sexp v : W.t) :: rest - | C_uint64 { v; _ } -> (u64_to_sexp v : W.t) :: rest - | C_bool false -> add_cst 0 rest - | C_bool true -> add_cst 1 rest - | C_char c -> - let c = Uchar.to_int c in - (i32_to_sexp c : W.t) :: rest - | C_string s -> Global_ctx2.compile_string_literal ~global_ctx s :: rest - | C_bytes { v; _ } -> - Global_ctx2.compile_bytes_literal ~global_ctx v :: rest - | C_float { v; _ } -> (f32_to_sexp v : W.t) :: rest - | C_double f -> - let fv = f.v in - (f64_to_sexp fv : W.t) :: rest - | C_bigint _ -> assert false) - | Lvar { var } -> List.cons (id_to_sexp var : W.t) (rest : W.t list) - | Llet { name = Pdot _ as name; e; body } -> - let rest = got body rest in - gon e - (List.cons - (List - (List.cons - (Atom "global.set" : W.t) - ([ Atom (id_to_string name) ] : W.t list)) - : W.t) - (rest : W.t list)) - | Llet { name = (Pident _ | Pmutable_ident _) as name; e; body } -> - ctx +> name; - let rest = got body rest in - gon e - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string name) ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lassign { var; e } -> - gon e - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string var) ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list))) - | Lsequence { expr1; expr2 } -> - let rest = got expr2 rest in - gon expr1 - (List.cons (List ([ Atom "drop" ] : W.t list) : W.t) (rest : W.t list)) - | Lif { pred; ifso; ifnot; type_ } -> ( - match (type_, tail) with - | I32_Unit, false -> - let ifso = - gon ifso ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - in - let ifnot = - gon ifnot ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - in - let branches = - if ifnot = [] then - List.cons - (List - (List.cons - (Atom "if" : W.t) - ([ - List (List.cons (Atom "then" : W.t) (ifso : W.t list)); - ] - : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list)) - else - List.cons - (List - (List.cons - (Atom "if" : W.t) - (List.cons - (List (List.cons (Atom "then" : W.t) (ifso : W.t list)) - : W.t) - ([ - List - (List.cons (Atom "else" : W.t) (ifnot : W.t list)); - ] - : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list)) - in - gon pred branches - | _ -> - let ifso = got ifso [] in - let ifnot = got ifnot [] in - gon pred - (List.cons - (List - (List.cons - (Atom "if" : W.t) - (List.cons - (List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons (Atom "then" : W.t) (ifso : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "else" : W.t) - (ifnot : W.t list)); - ] - : W.t list)))) - : W.t) - (rest : W.t list))) - | Lclosure closure -> compileClosure ~global_ctx closure rest - | Lget_field { kind = Enum _; obj; index; tid } -> - let index = index + 1 in - gon obj - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom (int_to_string index) ] : W.t list))) - : W.t) - (rest : W.t list)) - | Lget_field { kind = Tuple | Struct; obj; index; tid } -> - gon obj - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom (int_to_string index) ] : W.t list))) - : W.t) - (rest : W.t list)) - | Lclosure_field { obj; index; tid } -> - let index = - match[@warning "-fragile-match"] Tid.Hash.find_exn type_defs tid with - | Ltype.Ref_closure { fn_sig_tid; captures = _ } -> ( - match Tid.Hash.find_exn type_defs fn_sig_tid with - | Ref_closure_abstract _ -> index + 1 - | Ref_object { methods } -> index + List.length methods - | Ref_struct _ | Ref_late_init_struct _ | Ref_constructor _ - | Ref_array _ | Ref_closure _ -> - assert false) - | _ -> assert false - in - gon obj - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom (int_to_string index) ] : W.t list))) - : W.t) - (rest : W.t list)) - | Lset_field { kind; obj; field; index; tid } -> - let index = match kind with Enum _ -> index + 1 | _ -> index in - gon obj - (gon field - (List.cons - (List - (List.cons - (Atom "struct.set" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom (int_to_string index) ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list)))) - | Lapply { fn = Dynamic fn; args; prim = _ } -> ( - let tid = - match Ident.get_type fn with - | Ref_lazy_init { tid } -> tid - | Ltype.Ref { tid } -> tid - | _ -> assert false - in - let tid_code_ptr = Tid.code_pointer_of_closure tid in - let args = gos_non_tail (Clam.Lvar { var = fn } :: args) [] in - match fn with - | Pident _ | Pdot _ -> - List.append - (args : W.t list) - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.cons - (Atom "0" : W.t) - ([ id_to_sexp fn ] : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "call_ref" : W.t) - ([ Atom (tid_to_string tid_code_ptr) ] : W.t list)) - : W.t) - (rest : W.t list))) - | Pmutable_ident _ -> - let fn_tmp = - new_ident ~ty:(Ref_lazy_init { tid = tid_code_ptr }) "*fn_tmp" - in - List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.cons (Atom "0" : W.t) ([ id_to_sexp fn ] : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string fn_tmp) ] : W.t list)) - : W.t) - (List.append - (args : W.t list) - (List.cons - (List - (List.cons - (Atom "local.get" : W.t) - ([ Atom (id_to_string fn_tmp) ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "call_ref" : W.t) - ([ Atom (tid_to_string tid_code_ptr) ] : W.t list)) - : W.t) - (rest : W.t list)))))) - | Lapply { fn = Object { obj; method_index; method_ty = _ }; args; prim = _ } - -> - let tid = - match Ident.get_type obj with - | Ref_lazy_init { tid } -> tid - | Ref { tid } -> tid - | _ -> assert false - in - let tid_code_ptr = Tid.method_of_object tid method_index in - gos_non_tail - (Clam.Lvar { var = obj } :: args) - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - (List.cons - (Atom (int_to_string method_index) : W.t) - ([ id_to_sexp obj ] : W.t list)))) - : W.t) - (List.cons - (List - (List.cons - (Atom "call_ref" : W.t) - ([ Atom (tid_to_string tid_code_ptr) ] : W.t list)) - : W.t) - (rest : W.t list))) - | Lapply { fn = _; args; prim = Some (FixedArray_copy { src_tid; dst_tid }) } - -> - let rest = add_dummy_i32 rest in - gos_non_tail args - (List.cons - (List - (List.cons - (Atom "array.copy" : W.t) - (List.cons - (Atom (tid_to_string dst_tid) : W.t) - ([ Atom (tid_to_string src_tid) ] : W.t list))) - : W.t) - (rest : W.t list)) - | Lapply { fn = _; args; prim = Some (FixedArray_fill { tid = arr_tid }) } -> - let rest = add_dummy_i32 rest in - gos_non_tail args - (List.cons - (List - (List.cons - (Atom "array.fill" : W.t) - ([ Atom (tid_to_string arr_tid) ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lapply { fn = StaticFn addr; args; prim = _ } -> - gos_non_tail args - (List.cons - (List - (List.cons - (Atom "call" : W.t) - ([ Atom (addr_to_string addr) ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lstub_call { fn = func_stubs; params_ty; return_ty; args } -> - let name = - match func_stubs with - | Import { module_name; func_name } -> - Global_ctx2.add_import global_ctx - { module_name; func_name; params_ty; return_ty } - | Internal { func_name } -> (func_name : Stdlib.String.t) - | Inline_code_sexp { language; func_body } -> - if language <> "wasm" then - failwith - ("extern \"" ^ language - ^ "\" is not supported in wasm-gc backend" - : Stdlib.String.t); - Global_ctx2.add_inline global_ctx func_body - | Inline_code_text _ -> assert false - in - let rest = - match return_ty with None -> add_dummy_i32 rest | _ -> rest - in - gos_non_tail args - (List.cons - (List (List.cons (Atom "call" : W.t) ([ Atom name ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lprim { fn = Parith { operand_type = I32; operator = Neg }; args = a :: [] } - -> - let a = gon a [] in - List.cons - (List (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.append - (a : W.t list) - (List.cons - (List ([ Atom "i32.sub" ] : W.t list) : W.t) - (rest : W.t list))) - | Lprim { fn = Parith { operand_type = I64; operator = Neg }; args = a :: [] } - -> - let a = gon a [] in - List.cons - (List (List.cons (Atom "i64.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (List.append - (a : W.t list) - (List.cons - (List ([ Atom "i64.sub" ] : W.t list) : W.t) - (rest : W.t list))) - | Lprim { fn = Psequand; args } -> ( - match[@warning "-fragile-match"] args with - | [ a; b ] -> - let a = gon a [] in - let b = got b [] in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (List.append - (a : W.t list) - (List.cons - (List ([ Atom "i32.eqz" ] : W.t list) : W.t) - (List.cons - (List - (List.cons - (Atom "br_if" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "drop" ] : W.t list) : W.t) - (b : W.t list)))))))) - : W.t) - (rest : W.t list) - | _ -> assert false) - | Lprim { fn = Psequor; args } -> ( - match[@warning "-fragile-match"] args with - | [ a; b ] -> - let a = gon a [] in - let b = got b [] in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (List - (List.cons - (Atom "result" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "1" ] : W.t list)) - : W.t) - (List.append - (a : W.t list) - (List.cons - (List - (List.cons - (Atom "br_if" : W.t) - ([ Atom "0" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "drop" ] : W.t list) : W.t) - (b : W.t list))))))) - : W.t) - (rest : W.t list) - | _ -> assert false) - | Lprim { fn = Pcompare operand_type; args = [ a1; a2 ] } -> - let compile_arg (arg : Clam.lambda) k = - match arg with - | Lvar _ | Lconst _ -> ( - match[@warning "-fragile-match"] gon arg [] with - | v :: [] -> k v - | _ -> assert false) - | _ -> - let ty : Ltype.t = - match operand_type with - | I32 | U32 -> I32_Int - | I64 | U64 -> I64 - | F32 -> F32 - | F64 -> F64 - | U8 -> assert false - in - let tmp = Ident.fresh ~ty "tmp" in - ctx +> tmp; - gon arg - ((List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string tmp) ] : W.t list)) - : W.t) - :: k (id_to_sexp tmp)) - in - compile_arg a1 (fun v1 -> - compile_arg a2 (fun v2 -> - Wasm_util.compile_compare operand_type v1 v2 :: rest)) - | Lmake_array { kind = LenAndInit; tid; elems } -> ( - match[@warning "-fragile-match"] elems with - | [ len; init ] -> - let init = gon init [] in - let len = gon len [] in - List.append - (init : W.t list) - (List.append - (len : W.t list) - (List.cons - (List - (List.cons - (Atom "array.new" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (rest : W.t list))) - | _ -> assert false) - | Lmake_array { kind = Uninit; tid; elems } -> ( - match[@warning "-fragile-match"] elems with - | len :: [] -> ( - let len = gon len [] in - match Global_ctx2.find_default_elem global_ctx type_defs tid with - | Some id -> - List.cons - (List - (List.cons - (Atom "global.get" : W.t) - ([ Atom id ] : W.t list)) - : W.t) - (List.append - (len : W.t list) - (List.cons - (List - (List.cons - (Atom "array.new" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (rest : W.t list))) - | None -> - List.append - (len : W.t list) - (List.cons - (List - (List.cons - (Atom "array.new_default" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (rest : W.t list))) - | _ -> assert false) - | Larray_get_item { arr; index; tid; kind; need_non_null_cast } -> ( - let has_default_elem tid = - match Global_ctx2.find_default_elem global_ctx type_defs tid with - | Some _ -> true - | None -> false - in - let is_non_nullable_elem tid = - match Tid.Hash.find_opt type_defs tid with - | Some (Ref_array { elem = Ref_nullable _ }) -> false - | _ -> true - in - let rest = - if - need_non_null_cast - && (not (has_default_elem tid)) - && is_non_nullable_elem tid - then - List.cons - (List - (List.cons - (Atom "array.get" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "ref.as_non_null" ] : W.t list) : W.t) - (rest : W.t list)) - else - List.cons - (List - (List.cons - (Atom "array.get" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (rest : W.t list) - in - match kind with - | Safe | Unsafe -> gon arr (gon index rest) - | Rev_unsafe -> - let arr = gon arr [] in - let rev_index = gon index [] in - List.append - (arr : W.t list) - (List.cons - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "array.len" : W.t) - (arr : W.t list)) - : W.t) - (rev_index : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "1" ] : W.t list)); - ] - : W.t list))) - : W.t) - (rest : W.t list))) - | Larray_set_item { tid; kind = Null; arr; index; item = _ } -> ( - let elem_type = Ltype_util.get_arr_elem tid type_defs in - match elem_type with - | I32_Unit | I32_Int | I32_Char | I32_Bool | I32_Byte | I32_Tag - | I32_Option_Char | I64 | F32 | F64 -> - add_dummy_i32 rest - | Ref _ | Ref_string | Ref_bytes | Ref_func | Ref_any | Ref_nullable _ - | Ref_lazy_init _ | Ref_extern -> - let arr = gon arr [] in - let index = gon index [] in - let zero = - match Global_ctx2.find_default_elem global_ctx type_defs tid with - | Some id -> - (List - (List.cons - (Atom "global.get" : W.t) - ([ Atom id ] : W.t list)) - : W.t) - | None -> zero elem_type - in - let rest = add_dummy_i32 rest in - List.append - (arr : W.t list) - (List.append - (index : W.t list) - (List.cons - (zero : W.t) - (List.cons - (List - (List.cons - (Atom "array.set" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (rest : W.t list))))) - | Larray_set_item { tid; kind = Value | Unsafe; arr; index; item } -> - let item = Option.get item in - gos_non_tail [ arr; index; item ] - (List.cons - (List - (List.cons - (Atom "array.set" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list))) - | Larray_set_item { tid; kind = Default; arr; index; item = _ } -> - let default = - match Global_ctx2.find_default_elem global_ctx type_defs tid with - | Some id -> - (List (List.cons (Atom "global.get" : W.t) ([ Atom id ] : W.t list)) - : W.t) - | None -> - let elem_type = Ltype_util.get_arr_elem tid type_defs in - let zero = zero elem_type in - (zero : W.t) - in - gos_non_tail [ arr; index ] - (default - :: (List - (List.cons - (Atom "array.set" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - :: add_dummy_i32 rest) - | Lallocate { kind = Enum { tag }; fields = []; tid = _ } -> - let tag = tag.index in - Global_ctx2.compile_constant_constr ~global_ctx ~tag :: rest - | Lallocate { kind; fields; tid } -> - let fields = gos_non_tail fields [] in - let fields = - match kind with - | Enum { tag = { index; _ } } -> - List.cons (i32_to_sexp index : W.t) (fields : W.t list) - | _ -> fields - in - List.cons - (List - (List.cons - (Atom "struct.new" : W.t) - (List.cons (Atom (tid_to_string tid) : W.t) (fields : W.t list))) - : W.t) - (rest : W.t list) - | Lmake_array { kind = EverySingleElem; tid; elems } -> - let exception Not_constant in - let n = List.length elems in - let normal () = - if n > 100 then - let init = gon (List.hd elems) [] in - let arr_id = new_ident ~ty:(Ref { tid }) "arr" in - let rest = - (List - (List.cons - (Atom "local.get" : W.t) - ([ Atom (id_to_string arr_id) ] : W.t list)) - : W.t) - :: rest - in - let set_elem = - Lst.flat_mapi_append (List.tl elems) ~init:rest ~f:(fun i a -> - let arg = gon a [] in - let i = i + 1 in - List.cons - (List - (List.cons - (Atom "local.get" : W.t) - ([ Atom (id_to_string arr_id) ] : W.t list)) - : W.t) - (List.cons - (i32_to_sexp i : W.t) - (List.append - (arg : W.t list) - ([ - List - (List.cons - (Atom "array.set" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)); - ] - : W.t list)))) - in - List.append - (init : W.t list) - (List.cons - (i32_to_sexp n : W.t) - (List.cons - (List - (List.cons - (Atom "array.new" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string arr_id) ] : W.t list)) - : W.t) - (set_elem : W.t list)))) - else - gos_non_tail elems - (List.cons - (List - (List.cons - (Atom "array.new_fixed" : W.t) - (List.cons - (Atom (tid_to_string tid) : W.t) - ([ Atom (int_to_string n) ] : W.t list))) - : W.t) - (rest : W.t list)) - [@@local] - in - if n >= 5 then - let t = Ltype_util.get_arr_elem tid type_defs in - match t with - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Tag -> ( - match - Lst.map elems (fun x -> - match Clam_util.no_located x with - | Lconst (C_int { v; repr = _ }) -> v - | _ -> raise_notrace Not_constant) - with - | xs -> - Global_ctx2.compile_int32_array_literal ~global_ctx xs tid - :: rest - | exception Not_constant -> normal ()) - | I64 -> ( - match - Lst.map elems (fun x -> - match Clam_util.no_located x with - | Lconst (C_int64 { v; repr = _ }) -> v - | _ -> raise_notrace Not_constant) - with - | xs -> - Global_ctx2.compile_int64_array_literal ~global_ctx xs tid - :: rest - | exception Not_constant -> normal ()) - | I32_Byte -> ( - let buf = Buffer.create 16 in - match - Lst.map elems (fun x -> - match Clam_util.no_located x with - | Lconst (C_int { v; repr = _ }) -> - Buffer.add_int8 buf (Int32.to_int v) - | _ -> raise_notrace Not_constant) - with - | _ -> - Global_ctx2.compile_bytes_literal ~global_ctx - (Buffer.contents buf) - :: rest - | exception Not_constant -> normal ()) - | _ -> normal () - else normal () - | Lprim { fn = Pclosure_to_extern_ref; args = Lvar { var; _ } :: [] } -> - let closure_ffi_name = - Global_ctx2.add_import global_ctx Global_ctx2.Import.make_closure - in - let tid = - match Ident.get_type var with - | Ref_lazy_init { tid } | Ltype.Ref { tid } -> tid - | _ -> assert false - in - let tid_base = tid in - List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid_base) : W.t) - (List.cons (Atom "0" : W.t) ([ id_to_sexp var ] : W.t list)))) - : W.t) - (List.cons - (id_to_sexp var : W.t) - (List.cons - (List - (List.cons - (Atom "call" : W.t) - ([ Atom closure_ffi_name ] : W.t list)) - : W.t) - (rest : W.t list))) - | Lcast { expr; target_type = Ref_any } -> got expr rest - | Lcast { expr; target_type } -> - gon expr - (List.cons - (List - (List.cons - (Atom "ref.cast" : W.t) - ([ ltype_to_sexp target_type ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lcatch { body; on_exception; type_ } -> - assert !Basic_config.test_mode; - let body = gon body [] in - let on_exception = gon on_exception [] in - let label_exit = new_label "exit" in - let label_catch = new_label "catch" in - let tag = Ltype.tag_name in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom (label_to_string label_exit) : W.t) - (List.cons - (List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)) - : W.t) - (List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom (label_to_string label_catch) : W.t) - ([ - List - (List.cons - (Atom "try_table" : W.t) - (List.cons - (List - (List.cons - (Atom "catch" : W.t) - (List.cons - (Atom tag : W.t) - ([ - Atom - (label_to_string - label_catch); - ] - : W.t list))) - : W.t) - (List.append - (body : W.t list) - ([ - List - (List.cons - (Atom "br" : W.t) - ([ - Atom - (label_to_string - label_exit); - ] - : W.t list)); - ] - : W.t list)))); - ] - : W.t list))) - : W.t) - (on_exception : W.t list))))) - : W.t) - (rest : W.t list) - | Lprim { fn = Pmakebytes; args } -> ( - match[@warning "-fragile-match"] args with - | [ size; v ] -> - let size = gon size [] in - let v = gon v [] in - List.append - (v : W.t list) - (List.append - (size : W.t list) - (List.cons - (List - (List.cons - (Atom "array.new" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list)) - : W.t) - (rest : W.t list))) - | _ -> assert false) - | Lprim { fn; args } -> gos_non_tail args (compilePrimitive fn rest) - | Lswitch { obj; cases; default; type_ } -> - let push_drop = match type_ with I32_Unit -> not tail | _ -> false in - let compile_branch branch = - if push_drop then - gon branch ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - else got branch [] - [@@inline] - in - let tag = new_ident ~ty:I32_Tag "tag" in - let obj_tag = (id_to_sexp tag : W.t) in - let default = compile_branch default in - let cases = - Lst.map cases (fun (tag, action) -> (tag.index, compile_branch action)) - in - let switches = - Wasm_util.compile_int_switch - ~result_ty: - (if push_drop then [] - else - ([ - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)); - ] - : W.t list)) - ~obj:obj_tag ~cases ~default - (if push_drop then add_cst 0 rest else rest) - in - let tid_enum = Ltype.tid_enum in - List.cons - (id_to_sexp obj : W.t) - (List.cons - (List - (List.cons - (Atom "struct.get" : W.t) - (List.cons - (Atom (tid_to_string tid_enum) : W.t) - ([ Atom "0" ] : W.t list))) - : W.t) - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string tag) ] : W.t list)) - : W.t) - (switches : W.t list))) - | Lswitchint { obj; cases; default; type_ } -> - let push_drop = match type_ with I32_Unit -> not tail | _ -> false in - let compile_branch branch = - if push_drop then - gon branch ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - else got branch [] - [@@inline] - in - Wasm_util.compile_int_switch - ~result_ty: - (if push_drop then [] + (rest : instr list) = + (let got body rest = + compileExpr ~ctx ~global_ctx ~tail ~type_defs body rest + [@@inline] + in + let gon body rest = + compileExpr ~ctx ~global_ctx ~tail:false ~type_defs body rest + [@@inline] + in + let gos_non_tail args rest = Lst.fold_right args rest gon [@@inline] in + let new_ident ~ty name = + let ptr = Ident.fresh name ~ty in + ctx +> ptr; + ptr + [@@inline] + in + let new_label name = Label.fresh name [@@inline] in + match body with + | Levent { expr; _ } -> got expr rest + | Lconst constant -> ( + match constant with + | C_int i -> add_cst (Int32.to_int i.v) rest + | C_byte b -> add_cst b.v rest + | C_int64 i -> + let iv = i.v in + i64_const iv :: rest + | C_uint { v; _ } -> + let v = UInt32.to_int32 v in + i32_const v :: rest + | C_uint64 { v; _ } -> + let v = UInt64.to_int64 v in + i64_const v :: rest + | C_bool false -> add_cst 0 rest + | C_bool true -> add_cst 1 rest + | C_char c -> + let c = Uchar.to_int c in + int_const c :: rest + | C_string s -> Global_ctx2.compile_string_literal ~global_ctx s @> rest + | C_bytes { v; _ } -> + Global_ctx2.compile_bytes_literal ~global_ctx v @> rest + | C_float { v; _ } -> f32_const v @: rest + | C_double f -> + let fv = f.v in + f64_const fv @: rest + | C_bigint _ -> assert false) + | Lvar { var } -> generic_get var @> rest + | Llet { name = Pdot _ as name; e; body } -> + let rest = got body rest in + gon e (global_set name @: rest) + | Llet { name = (Pident _ | Pmutable_ident _) as name; e; body } -> + ctx +> name; + let rest = got body rest in + gon e (local_set name @: rest) + | Lassign { var; e } -> gon e (local_set var @: int_const 0 @: rest) + | Lsequence { exprs; last_expr } -> + let rest = got last_expr rest in + Lst.fold_left (List.rev exprs) rest (fun acc -> + fun expr -> + let acc = Drop @: acc in + gon expr acc) + | Lif { pred; ifso; ifnot; type_ } -> ( + match (type_, tail) with + | I32 { kind = I32_Unit }, false -> + let ifso = gon ifso [ Drop ] in + let ifnot = gon ifnot [ Drop ] in + let branches = + if_ ~then_:ifso ~else_:ifnot () @> int_const 0 @: rest + in + gon pred branches + | _ -> + let ifso = got ifso [] in + let ifnot = got ifnot [] in + let result_ty = [ result type_ ] in + gon pred (if_ ~result_ty ~then_:ifso ~else_:ifnot () @> rest)) + | Lclosure closure -> compileClosure ~global_ctx closure rest + | Lget_raw_func addr -> + Global_ctx2.add_func_ref global_ctx addr; + ref_func addr @: rest + | Lget_field { kind; obj; index; tid } -> + let index = + match kind with + | Tuple | Struct -> index + | Enum -> index + 1 + | Object { number_of_methods } -> index + number_of_methods + in + gon obj (struct_get tid index @: rest) + | Lclosure_field { obj; index; tid } -> + let index = index + 1 in + gon obj (struct_get tid index @: rest) + | Lset_field { kind; obj; field; index; tid } -> + let index = match kind with Enum -> index + 1 | Struct -> index in + gon obj (gon field (struct_set tid index @: int_const 0 @: rest)) + | Lapply { fn = Dynamic fn; args; prim = _ } -> ( + let tid = + match Ident.get_type fn with + | Ref_lazy_init { tid } -> tid + | Ltype.Ref { tid } -> tid + | _ -> assert false + in + let tid_code_ptr = Tid.code_pointer_of_closure tid in + let args = gos_non_tail (Clam.Lvar { var = fn } :: args) [] in + match fn with + | Pident _ | Pdot _ -> + args @> generic_get fn @> struct_get tid 0 @: call_ref tid_code_ptr + @: rest + | Pmutable_ident _ -> + let fn_tmp = + new_ident ~ty:(Ref_lazy_init { tid = tid_code_ptr }) "*fn_tmp" + in + generic_get fn @> struct_get tid 0 @: local_set fn_tmp @: args + @> local_get fn_tmp @: call_ref tid_code_ptr @: rest) + | Lapply { fn = Object { obj; method_index; method_ty = _ }; args; prim = _ } + -> + let tid = + match Ident.get_type obj with + | Ref_lazy_init { tid } -> tid + | Ref { tid } -> tid + | _ -> assert false + in + let tid_code_ptr = Tid.method_of_object tid method_index in + gos_non_tail + (Clam.Lvar { var = obj } :: args) + (generic_get obj + @> struct_get tid method_index + @: call_ref tid_code_ptr @: rest) + | Lapply { fn = _; args; prim = Some (FixedArray_copy { src_tid; dst_tid }) } + -> + let rest = add_dummy_i32 rest in + gos_non_tail args (array_copy ~dst_tid ~src_tid @: rest) + | Lapply { fn = _; args; prim = Some (FixedArray_fill { tid = arr_tid }) } -> + let rest = add_dummy_i32 rest in + gos_non_tail args (array_fill arr_tid @: rest) + | Lapply { fn = _; args; prim = Some Char_to_string } -> + gos_non_tail args (call "$moonbit.js_string.fromCodePoint" @: rest) + | Lapply { fn = StaticFn addr; args; prim = _ } -> + gos_non_tail args (call (addr_to_string addr) @: rest) + | Lstub_call { fn = func_stubs; params_ty; return_ty; args } -> + let name = + match func_stubs with + | Import { module_name; func_name } -> + Global_ctx2.add_import global_ctx + { module_name; func_name; params_ty; return_ty } + | Internal { func_name } -> + (func_name : Stdlib.String.t) [@merlin.hide] + | Inline_code_sexp { language; func_body } -> + if language <> "wasm" then + failwith + (("extern \"" ^ language + ^ "\" is not supported in wasm-gc backend" + : Stdlib.String.t) + [@merlin.hide]); + Global_ctx2.add_inline global_ctx func_body + | Inline_code_text _ -> assert false + in + let rest = + match return_ty with None -> add_dummy_i32 rest | _ -> rest + in + gos_non_tail args (call name @: rest) + | Lprim + { fn = Parith { operand_type = I32; operator = Neg }; args = a :: [] } -> + let a = gon a [] in + int_const 0 @: a @> I32_sub @: rest + | Lprim + { fn = Parith { operand_type = I64; operator = Neg }; args = a :: [] } -> + let a = gon a [] in + i64_const 0L @: a @> I64_sub @: rest + | Lprim { fn = Pcompare operand_type; args = [ a1; a2 ] } -> + let compile_compare (ty : Primitive.operand_type) x y rest = + match ty with + | I32 -> x @: y @: I32_ge_s @: x @: y @: I32_le_s @: I32_sub @: rest + | U32 -> x @: y @: I32_ge_u @: x @: y @: I32_le_u @: I32_sub @: rest + | I64 -> x @: y @: I64_ge_s @: x @: y @: I64_le_s @: I32_sub @: rest + | U64 -> x @: y @: I64_ge_u @: x @: y @: I64_le_u @: I32_sub @: rest + | F32 -> x @: y @: F32_ge @: x @: y @: F32_le @: I32_sub @: rest + | F64 -> x @: y @: F64_ge @: x @: y @: F64_le @: I32_sub @: rest + | U8 | U16 | I16 -> assert false + [@@inline] + in + let compile_arg (arg : Clam.lambda) k = + match arg with + | Lvar _ | Lconst _ -> ( + match[@warning "-fragile-match"] gon arg [] with + | v :: [] -> k v + | _ -> assert false) + | _ -> + let ty : Ltype.t = + match operand_type with + | I32 | U32 -> Ltype.i32_int + | I64 | U64 -> I64 + | F32 -> F32 + | F64 -> F64 + | U8 | U16 | I16 -> assert false + in + let tmp = Ident.fresh ~ty "tmp" in + ctx +> tmp; + gon arg (local_set tmp @: k (local_get tmp)) + in + compile_arg a1 (fun v1 -> + compile_arg a2 (fun v2 -> compile_compare operand_type v1 v2 rest)) + | Lmake_array { kind = LenAndInit; tid; elems } -> ( + match[@warning "-fragile-match"] elems with + | [ len; init ] -> + let init = gon init [] in + let len = gon len [] in + init @> len @> array_new tid @: rest + | _ -> assert false) + | Lmake_array { kind = Uninit; tid; elems } -> ( + match[@warning "-fragile-match"] elems with + | len :: [] -> ( + let len = gon len [] in + match Global_ctx2.find_default_elem global_ctx type_defs tid with + | Some id -> global_get_ id @: len @> array_new tid @: rest + | None -> len @> array_new_default ~id:tid () @: rest) + | _ -> assert false) + | Larray_get_item { arr; index; tid; kind; extra } -> ( + let has_default_elem tid = + match Global_ctx2.find_default_elem global_ctx type_defs tid with + | Some _ -> true + | None -> false + in + let is_non_nullable_elem tid = + match Tid.Hash.find_opt type_defs tid with + | Some (Ref_array { elem = Ref_nullable _ }) -> false + | _ -> true + in + let rest = + match extra with + | Need_non_null_cast + when (not (has_default_elem tid)) && is_non_nullable_elem tid -> + array_get tid @: Ref_as_non_null @: rest + | Need_signed_info { signed = true } -> array_get_s tid @: rest + | Need_signed_info { signed = false } -> array_get_u tid @: rest + | _ -> array_get tid @: rest + in + match kind with + | Safe | Unsafe -> gon arr (gon index rest) + | Rev_unsafe -> + let arr = gon arr [] in + let rev_index = gon index [] in + arr @> arr @> Array_len @: rev_index @> I32_sub @: int_const 1 + @: I32_sub @: rest) + | Larray_set_item { tid; kind = Null; arr; index; item = _ } -> ( + let elem_type = Ltype_util.get_arr_elem tid type_defs in + match elem_type with + | I32 _ | I64 | F32 | F64 -> add_dummy_i32 rest + | Ref _ | Ref_string | Ref_bytes | Ref_func | Ref_any | Ref_nullable _ + | Ref_lazy_init _ | Ref_extern -> + let arr = gon arr [] in + let index = gon index [] in + let zero = + match Global_ctx2.find_default_elem global_ctx type_defs tid with + | Some id -> [ global_get_ id ] + | None -> [ zero elem_type ] + in + let rest = add_dummy_i32 rest in + arr @> index @> zero @> array_set tid @: rest) + | Larray_set_item { tid; kind = Value | Unsafe; arr; index; item } -> + let item = Option.get item in + gos_non_tail [ arr; index; item ] (array_set tid @: int_const 0 @: rest) + | Larray_set_item { tid; kind = Default; arr; index; item = _ } -> + let default = + match Global_ctx2.find_default_elem global_ctx type_defs tid with + | Some id -> [ global_get_ id ] + | None -> + let elem_type = Ltype_util.get_arr_elem tid type_defs in + [ zero elem_type ] + in + gos_non_tail [ arr; index ] + (default @> array_set tid @: add_dummy_i32 rest) + | Lallocate { kind = Enum { tag }; fields = []; tid = _ } -> + let tag = tag.index in + Global_ctx2.compile_constant_constr ~global_ctx ~tag :: rest + | Lallocate { kind; fields; tid } -> + let fields = gos_non_tail fields [] in + let fields = + match kind with + | Enum { tag = { index; _ } } -> int_const index @: fields + | Object { methods } -> + Lst.map_append methods fields (fun method_addr -> + Global_ctx2.add_func_ref global_ctx method_addr; + ref_func method_addr) + | Tuple | Struct -> fields + in + fields @> struct_new tid @: rest + | Lmake_array { kind = EverySingleElem; tid; elems } -> + let exception Not_constant in + let n = List.length elems in + let normal () = + if n > 100 then + let init = gon (List.hd elems) [] in + let arr_id = new_ident ~ty:(Ref { tid }) "arr" in + let rest = local_get arr_id @: rest in + let set_elem = + Lst.flat_mapi_append (List.tl elems) ~init:rest ~f:(fun i -> + fun a -> + let arg = gon a [] in + let i = i + 1 in + local_get arr_id @: int_const i @: arg @> [ array_set tid ]) + in + init @> int_const n @: array_new tid @: local_set arr_id @: set_elem + else gos_non_tail elems (array_new_fixed ~id:tid ~size:n @: rest) + [@@local] + in + if n >= 5 then + let t = Ltype_util.get_arr_elem tid type_defs in + match t with + | I32 { kind = I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Tag } + -> ( + match + Lst.map elems (fun x -> + match Clam_util.no_located x with + | Lconst (C_int { v; repr = _ }) -> v + | _ -> raise_notrace Not_constant) + with + | xs -> + Global_ctx2.compile_int32_array_literal ~global_ctx xs tid + @> rest + | exception Not_constant -> normal ()) + | I64 -> ( + match + Lst.map elems (fun x -> + match Clam_util.no_located x with + | Lconst (C_int64 { v; repr = _ }) -> v + | _ -> raise_notrace Not_constant) + with + | xs -> + Global_ctx2.compile_int64_array_literal ~global_ctx xs tid + @> rest + | exception Not_constant -> normal ()) + | I32 { kind = I32_Byte } -> ( + let buf = Buffer.create 16 in + match + Lst.map elems (fun x -> + match Clam_util.no_located x with + | Lconst (C_int { v; repr = _ }) -> + Buffer.add_int8 buf (Int32.to_int v) + | _ -> raise_notrace Not_constant) + with + | _ -> + Global_ctx2.compile_bytes_literal ~global_ctx + (Buffer.contents buf) + @> rest + | exception Not_constant -> normal ()) + | _ -> normal () + else normal () + | Lprim { fn = Pclosure_to_extern_ref; args = Lvar { var; _ } :: [] } -> + let closure_ffi_name = + Global_ctx2.add_import global_ctx Global_ctx2.Import.make_closure + in + let tid = + match Ident.get_type var with + | Ref_lazy_init { tid } | Ltype.Ref { tid } -> tid + | _ -> assert false + in + let tid_base = tid in + generic_get var @> struct_get tid_base 0 @: generic_get var + @> call closure_ffi_name @: rest + | Lcast { expr; target_type = Ref_any } -> got expr rest + | Lcast { expr; target_type } -> + gon expr (ref_cast (result target_type) @: rest) + | Lcatch { body; on_exception; type_ } -> + assert !Basic_config.test_mode; + let body = gon body [] in + let on_exception = gon on_exception [] in + let label_exit = new_label "exit" in + let label_catch = new_label "catch" in + let tag = Ltype.tag_name in + block ~label:label_exit + ~result_ty:[ result type_ ] + (block ~label:label_catch + [ + try_table + ~catchs:[ catch ~tag ~label:label_catch ] + (body @> [ br_ label_exit ]); + ] + @: on_exception) + @: rest + | Lprim { fn = Pmakebytes; args } -> ( + match[@warning "-fragile-match"] args with + | [ size; v ] -> + let size = gon size [] in + let v = gon v [] in + v @> size @> array_new_ "$moonbit.bytes" @: rest + | _ -> assert false) + | Lprim { fn; args } -> gos_non_tail args (compilePrimitive fn rest) + | Lswitch { obj; cases; default; type_ } -> + let push_drop = + match type_ with I32 { kind = I32_Unit } -> not tail | _ -> false + in + let compile_branch branch = + if push_drop then gon branch [ Drop ] else got branch [] + [@@inline] + in + let tag = new_ident ~ty:Ltype.i32_tag "tag" in + let obj_tag = local_get tag in + let default = compile_branch default in + let cases = + Lst.map cases (fun (tag, action) -> (tag.index, compile_branch action)) + in + let switches = + Wasmir_util.compile_int_switch + ~result_ty:(if push_drop then [] else [ result type_ ]) + ~obj:obj_tag ~cases ~default + (if push_drop then add_cst 0 rest else rest) + in + let tid_enum = Ltype.tid_enum in + generic_get obj @> struct_get tid_enum 0 @: local_set tag @: switches + | Lswitchint { obj; cases; default; type_ } -> + let push_drop = + match type_ with I32 { kind = I32_Unit } -> not tail | _ -> false + in + let compile_branch branch = + if push_drop then gon branch [ Drop ] else got branch [] + [@@inline] + in + Wasmir_util.compile_int_switch + ~result_ty:(if push_drop then [] else [ result type_ ]) + ~obj:(local_get obj) + ~cases:(Lst.map cases (fun (c, action) -> (c, compile_branch action))) + ~default:(compile_branch default) + (if push_drop then add_cst 0 rest else rest) + | Lswitchstring { obj; cases; default; type_ } -> + let push_drop = + match type_ with I32 { kind = I32_Unit } -> not tail | _ -> false + in + let result_ty = if push_drop then [] else [ result type_ ] in + let compile_branch branch = + if push_drop then gon branch [ Drop ] else got branch [] + [@@inline] + in + let tag = new_ident ~ty:Ref_string "tag" in + let obj_tag = local_get tag in + let switches = + Lst.fold_right cases (compile_branch default) + (fun ((tag : string), act) -> + fun acc -> + let act = compile_branch act in + let tagExpr = + Global_ctx2.compile_string_literal ~global_ctx tag + in + obj_tag @: tagExpr + @> call "$moonbit.string_equal" + @: if_ ~result_ty ~then_:act ~else_:acc ()) + in + let rest = if push_drop then add_cst 0 rest else rest in + gon obj (local_set tag @: switches @> rest) + | Lletrec { names = name :: []; fns = closure :: []; body } -> + ctx +> name; + let rest = got body rest in + compileClosure ~global_ctx closure (local_set name @: rest) + | Lletrec { names; fns; body } -> + Lst.iter names ~f:(fun name -> ctx +> name); + let names_fns = List.combine names fns in + let rest = got body rest in + let alloc_closure = + Lst.concat_map names_fns (fun (name, { address; _ }) -> + let tid_capture = + match address with + | Normal address -> Tid.capture_of_function address + | Well_known_mut_rec -> ( + match Ident.get_type name with + | Ref { tid } -> tid + | _ -> assert false) + in + struct_new_default tid_capture @: [ local_set name ]) + in + let write_closure = + Lst.concat_map names_fns (fun (name, { captures; address; tid }) -> + let tid_capture = tid in + match address with + | Normal address -> + Global_ctx2.add_func_ref global_ctx address; + let closure = generic_get name @> [ ref_cast_ tid_capture ] in + closure @> ref_func address + @: struct_set tid_capture 0 + :: Lst.concat + (Lst.mapi captures (fun i -> + fun c -> + let i = i + 1 in + closure @> generic_get c + @> [ struct_set tid_capture i ])) + | Well_known_mut_rec -> + Lst.concat + (Lst.mapi captures (fun i -> + fun c -> + let closure = + generic_get name @> [ ref_cast_ tid_capture ] + in + closure @> generic_get c + @> [ struct_set tid_capture i ]))) + in + alloc_closure @> write_closure @> rest + | Ljoinlet { name; e; body; params; kind = _; type_ } -> + Lst.iter params ~f:(fun param -> ctx +> param); + let result_param_types = + Lst.map params (fun id -> result (Ident.get_type id)) + in + let result_types = Lst.map type_ result in + let label_ = Join.to_wasm_label name in + Join.Hash.add ctx.join_points name params; + let def e = + Lst.fold_left params e (fun acc -> + fun param_name -> local_set param_name @: acc) + in + if tail then + let body = got body [ Return ] in + let e = def (got e rest) in + block ~label_ ~result_ty:result_param_types body @: e + else + let outer_label = Label.to_wasm_name (Label.fresh "outer") in + let body = gon body [ br outer_label ] in + let e = def (gon e []) in + block ~label_:outer_label ~result_ty:result_types + (block ~label_ ~result_ty:result_param_types body @: e) + @: rest + | Ljoinapply { name; args } -> + let label = Join.to_wasm_label name in + let jump = [ br label ] in + gos_non_tail args jump + | Lbreak { arg; label = loop_label } -> ( + let label = Label.to_wasm_label_break loop_label in + let loop_info = Label.Map.find_exn ctx.loop_info loop_label in + loop_info.break_used := true; + match arg with None -> [ br label ] | Some arg -> gon arg [ br label ]) + | Lcontinue { args; label = loop_label } -> ( + let label = Label.to_wasm_label_loop loop_label in + match Label.Map.find_exn ctx.loop_info loop_label with + | { params; _ } -> + if !Basic_config.use_block_params then gos_non_tail args [ br label ] else - ([ - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)); - ] - : W.t list)) - ~obj:(id_to_sexp obj : W.t) - ~cases:(List.map (fun (c, action) -> (c, compile_branch action)) cases) - ~default:(compile_branch default) - (if push_drop then add_cst 0 rest else rest) - | Lswitchstring { obj; cases; default; type_ } -> - let push_drop = match type_ with I32_Unit -> not tail | _ -> false in - let result_ty = - if push_drop then [] - else - ([ - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)); - ] - : W.t list) - in - let compile_branch branch = - if push_drop then - gon branch ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - else got branch [] - [@@inline] - in - let tag = new_ident ~ty:Ref_string "tag" in - let obj_tag = (id_to_sexp tag : W.t) in - let switches = - List.fold_right - (fun ((tag : string), act) acc -> - let act = compile_branch act in - let tagExpr = Global_ctx2.compile_string_literal ~global_ctx tag in - List.cons - (obj_tag : W.t) - (List.cons - (tagExpr : W.t) - (List.cons - (List - (List.cons - (Atom "call" : W.t) - ([ Atom "$moonbit.string_equal" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "if" : W.t) - (List.append - (result_ty : W.t list) - (List.cons - (List - (List.cons - (Atom "then" : W.t) - (act : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "else" : W.t) - (acc : W.t list)); - ] - : W.t list)))); - ] - : W.t list)))) - cases (compile_branch default) - in - let rest = if push_drop then add_cst 0 rest else rest in - gon obj - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string tag) ] : W.t list)) - : W.t) - (List.append (switches : W.t list) (rest : W.t list))) - | Lletrec { names = name :: []; fns = closure :: []; body } -> - ctx +> name; - let rest = got body rest in - compileClosure ~global_ctx closure - (List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string name) ] : W.t list)) - : W.t) - (rest : W.t list)) - | Lletrec { names; fns; body } -> - Lst.iter names (fun name -> ctx +> name); - let names_fns = List.combine names fns in - let rest = got body rest in - let alloc_closure = - Lst.concat_map names_fns (fun (name, { address; _ }) -> - let tid_capture = - match address with - | Normal address -> Tid.capture_of_function address - | Well_known_mut_rec -> ( - match Ident.get_type name with - | Ref { tid } -> tid - | _ -> assert false) - | Object _ -> assert false - in - List.cons - (List - (List.cons - (Atom "struct.new_default" : W.t) - ([ Atom (tid_to_string tid_capture) ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string name) ] : W.t list)); - ] - : W.t list)) - in - let write_closure = - Lst.concat_map names_fns (fun (name, { captures; address; tid }) -> - let tid_capture = tid in - match address with - | Normal address -> - Global_ctx2.add_func_ref global_ctx address; - let closure = - (List - (List.cons - (Atom "ref.cast" : W.t) - (List.cons - (tid_to_sexp tid_capture : W.t) - ([ id_to_sexp name ] : W.t list))) - : W.t) - in - (List - (List.cons - (Atom "struct.set" : W.t) - (List.cons - (Atom (tid_to_string tid_capture) : W.t) - (List.cons - (Atom "0" : W.t) - (List.cons - (closure : W.t) - ([ - List - (List.cons - (Atom "ref.func" : W.t) - ([ Atom (addr_to_string address) ] - : W.t list)); - ] - : W.t list))))) - : W.t) - :: Lst.mapi captures (fun i c -> - let i = i + 1 in - (List - (List.cons - (Atom "struct.set" : W.t) - (List.cons - (Atom (tid_to_string tid_capture) : W.t) - (List.cons - (Atom (int_to_string i) : W.t) - (List.cons - (closure : W.t) - ([ id_to_sexp c ] : W.t list))))) - : W.t)) - | Well_known_mut_rec -> - Lst.mapi captures (fun i c -> - let closure = - (List - (List.cons - (Atom "ref.cast" : W.t) - (List.cons - (tid_to_sexp tid_capture : W.t) - ([ id_to_sexp name ] : W.t list))) - : W.t) - in - (List - (List.cons - (Atom "struct.set" : W.t) - (List.cons - (Atom (tid_to_string tid_capture) : W.t) - (List.cons - (Atom (int_to_string i) : W.t) - (List.cons - (closure : W.t) - ([ id_to_sexp c ] : W.t list))))) - : W.t)) - | Object _ -> assert false) - in - List.append - (alloc_closure : W.t list) - (List.append (write_closure : W.t list) (rest : W.t list)) - | Ljoinlet { name; e; body; params; kind = _; type_ } -> - Lst.iter params (fun param -> ctx +> param); - let result_param_types = - Lst.map params (fun id -> - let t = Transl_type.ltype_to_sexp (Ident.get_type id) in - (List (List.cons (Atom "result" : W.t) ([ t ] : W.t list)) : W.t)) - in - let result_types = - Lst.map type_ (fun t : W.t -> - List - (List.cons (Atom "result" : W.t) ([ ltype_to_sexp t ] : W.t list))) - in - let label = Join.to_wasm_label name in - Join.Hash.add ctx.join_points name params; - let def e = - Lst.fold_left params e (fun acc param_name -> - List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string param_name) ] : W.t list)) - : W.t) - (acc : W.t list)) - in - if tail then - let body = - got body ([ List ([ Atom "return" ] : W.t list) ] : W.t list) - in - let e = def (got e rest) in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom label : W.t) - (List.append - (result_param_types : W.t list) - (body : W.t list)))) - : W.t) - (e : W.t list) - else - let body = - gon body - ([ List (List.cons (Atom "br" : W.t) ([ Atom "1" ] : W.t list)) ] - : W.t list) - in - let e = def (gon e []) in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.append - (result_types : W.t list) - (List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom label : W.t) - (List.append - (result_param_types : W.t list) - (body : W.t list)))) - : W.t) - (e : W.t list)))) - : W.t) - (rest : W.t list) - | Ljoinapply { name; args } -> - let label = Join.to_wasm_label name in - let jump = - ([ List (List.cons (Atom "br" : W.t) ([ Atom label ] : W.t list)) ] - : W.t list) - in - gos_non_tail args jump - | Lbreak { arg; label = loop_label } -> ( - let label = Label.to_wasm_label_break loop_label in - let loop_info = Label.Map.find_exn ctx.loop_info loop_label in - loop_info.break_used := true; - match arg with - | None -> - ([ List (List.cons (Atom "br" : W.t) ([ Atom label ] : W.t list)) ] - : W.t list) - | Some arg -> - gon arg - ([ List (List.cons (Atom "br" : W.t) ([ Atom label ] : W.t list)) ] - : W.t list)) - | Lcontinue { args; label = loop_label } -> ( - let label = Label.to_wasm_label_loop loop_label in - match Label.Map.find_exn ctx.loop_info loop_label with - | { params; _ } -> - if !Basic_config.use_block_params then - gos_non_tail args - ([ - List (List.cons (Atom "br" : W.t) ([ Atom label ] : W.t list)); - ] - : W.t list) - else - let set_params = - Lst.fold_left params [] (fun acc param -> - List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string param) ] : W.t list)) - : W.t) - (acc : W.t list)) - in - gos_non_tail args - (List.append - (set_params : W.t list) - ([ - List - (List.cons (Atom "br" : W.t) ([ Atom label ] : W.t list)); - ] - : W.t list))) - | Lreturn e -> - if tail then got e rest - else gon e ([ List ([ Atom "return" ] : W.t list) ] : W.t list) - | Lloop { params; body; args; label = loop_label; type_ } -> - Lst.iter params (fun param -> ctx +> param); - let break_label = Label.to_wasm_label_break loop_label in - let label = Label.to_wasm_label_loop loop_label in - let args = gos_non_tail args [] in - let no_value = type_ = I32_Unit in - let break_used = ref false in - let new_loop_info = - Label.Map.add ctx.loop_info loop_label { params; break_used } - in - let new_ctx = { ctx with loop_info = new_loop_info } in - let body = - compileExpr ~global_ctx ~ctx:new_ctx body [] ~tail:false ~type_defs - in - let body = - if no_value then - List.append - (body : W.t list) - ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - else body - in - let result = - if no_value then [] - else - ([ - List - (List.cons - (Atom "result" : W.t) - ([ ltype_to_sexp type_ ] : W.t list)); - ] - : W.t list) - in - let set_params = - Lst.fold_left params [] (fun acc param -> - List.cons - (List - (List.cons - (Atom "local.set" : W.t) - ([ Atom (id_to_string param) ] : W.t list)) - : W.t) - (acc : W.t list)) - in - let loop = - if !Basic_config.use_block_params then - let param_types = - Lst.map params (fun param -> - let t = Transl_type.ltype_to_sexp (Ident.get_type param) in - (List (List.cons (Atom "param" : W.t) ([ t ] : W.t list)) : W.t)) - in - List.append - (args : W.t list) - ([ - List - (List.cons - (Atom "loop" : W.t) - (List.cons - (Atom label : W.t) - (List.append - (param_types : W.t list) - (List.append - (result : W.t list) - (List.append - (set_params : W.t list) - (body : W.t list)))))); - ] - : W.t list) - else - List.append - (args : W.t list) - (List.append - (set_params : W.t list) - ([ - List - (List.cons - (Atom "loop" : W.t) - (List.cons - (Atom label : W.t) - (List.append (result : W.t list) (body : W.t list)))); - ] - : W.t list)) - in - let loop = - if !break_used then - ([ - List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom break_label : W.t) - (List.append (result : W.t list) (loop : W.t list)))); - ] - : W.t list) - else loop - in - if no_value then - List.append - (loop : W.t list) - (List.cons - (List - (List.cons (Atom "i32.const" : W.t) ([ Atom "0" ] : W.t list)) - : W.t) - (rest : W.t list)) - else List.append (loop : W.t list) (rest : W.t list) + let set_params = + Lst.fold_left params [] (fun acc -> + fun param -> local_set param @: acc) + in + gos_non_tail args (set_params @> [ br label ])) + | Lreturn e -> ( + match ctx.return_type with + | [] -> [ Return ] + | _ :: _ -> if tail then got e rest else got e [ Return ]) + | Lloop { params; body; args; label = loop_label; type_ } -> + Lst.iter params ~f:(fun param -> ctx +> param); + let break_label = Label.to_wasm_label_break loop_label in + let label_ = Label.to_wasm_label_loop loop_label in + let args = gos_non_tail args [] in + let no_value = + match type_ with I32 { kind = I32_Unit } -> true | _ -> false + in + let break_used = ref false in + let new_loop_info = + Label.Map.add ctx.loop_info loop_label { params; break_used } + in + let new_ctx = { ctx with loop_info = new_loop_info } in + let body = + compileExpr ~global_ctx ~ctx:new_ctx body [] ~tail:false ~type_defs + in + let body = if no_value then body @> [ Drop ] else body in + let result_ty = if no_value then [] else [ result type_ ] in + let set_params = + Lst.fold_left params [] (fun acc -> + fun param -> local_set param @: acc) + in + let loop = + if !Basic_config.use_block_params then + let params = + Lst.map params (fun p -> + let t = Ident.get_type p in + param t) + in + args @> [ loop ~label_ ~params ~result_ty (set_params @> body) ] + else args @> set_params @> [ loop ~label_ ~result_ty body ] + in + let loop = + if !break_used then [ block ~label_:break_label ~result_ty loop ] + else loop + in + if no_value then loop @> int_const 0 @: rest else loop @> rest + : instr list) let compileFunc ~(global_ctx : Global_ctx2.t) (top : Clam.top_func_item) - ~type_defs : func list = - let addr = top.binder in - let ({ body = fn_body; params = fn_params; return_type_; _ } : Clam.fn) = - top.fn - in - let ctx = - { - locals = ref Ident_set.empty; - loop_info = Label.Map.empty; - join_points = Join.Hash.create 17; - } - in - let body = compileExpr ~ctx ~global_ctx fn_body [] ~tail:true ~type_defs in - let locals = - Ident_set.map_to_list !(ctx.locals) (fun local -> - let ty = Ident.get_type local in - let source_name = - Wasm_util.compile_source_name (Ident.source_name local) + ~type_defs = + (let addr = top.binder in + let ({ body = fn_body; params = fn_params; return_type_; _ } : Clam.fn) = + top.fn + in + let ctx = + { + locals = ref Ident_set.empty; + loop_info = Label.Map.empty; + join_points = Join.Hash.create 17; + return_type = return_type_; + } + in + let body = + let rest = match return_type_ with [] -> [ Ast.Drop ] | _ :: _ -> [] in + compileExpr ~ctx ~global_ctx fn_body rest ~tail:true ~type_defs + in + let locals = + Ident_set.map_to_list !(ctx.locals) (fun id -> + let ty = Ident.get_type id in + local ~id ty) + in + let params = + Lst.map fn_params (fun id -> + let ty = Ident.get_type id in + param ~id ty) + in + let results = Lst.map return_type_ result in + let export = match top.fn_kind_ with Top_pub s -> s | Top_private -> "" in + let source_name = Wasmir_util.compile_fn_source_name top.binder in + let prologue_end = Wasmir_util.compile_prologue_end () in + let type_ = + match top.tid with None -> None | Some tid -> Some (Tid.to_wasm_name tid) + in + match return_type_ with + | I32 { kind = I32_Unit } :: [] when export <> "" -> + let addr_ = addr_to_string addr in + let name_wrapper = + Basic_fn_address.fresh (Basic_fn_address.to_string addr ^ "_wrapper") + in + (let args = + Lst.map params (fun p -> + match[@warning "-fragile-match"] p.id with + | { id = Some name; _ } -> local_get_ name + | _ -> assert false) in - let source_type = compile_source_type ty in - (List - (List.cons - (Atom "local" : W.t) - (List.cons - (Atom (id_to_string local) : W.t) - (List.append - (source_name : W.t list) - (List.append - (source_type : W.t list) - ([ ltype_to_sexp ty ] : W.t list))))) - : W.t)) - in - let params = - Lst.map fn_params (fun x -> - let ty = Ident.get_type x in - let source_name = Wasm_util.compile_source_name (Ident.source_name x) in - let source_type = compile_source_type ty in - (List - (List.cons - (Atom "param" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.append - (source_name : W.t list) - (List.append - (source_type : W.t list) - ([ ltype_to_sexp ty ] : W.t list))))) - : W.t)) - in - let result = - Lst.map return_type_ (fun x : W.t -> - List (List.cons (Atom "result" : W.t) ([ ltype_to_sexp x ] : W.t list))) - in - let export = - match top.fn_kind_ with - | Top_pub s -> - let s = Basic_strutil.esc_quote s in - ([ List (List.cons (Atom "export" : W.t) ([ Atom s ] : W.t list)) ] - : W.t list) - | Top_private -> [] - in - let source_name = Wasm_util.compile_fn_source_name top.binder in - let prologue_end = Wasm_util.compile_prologue_end () in - let type_ = - match top.tid with - | None -> [] - | Some tid -> - ([ - List - (List.cons - (Atom "type" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)); - ] - : W.t list) - in - match return_type_ with - | I32_Unit :: [] when export <> [] -> - let name_wrapper = - Basic_fn_address.fresh (Basic_fn_address.to_string addr ^ "_wrapper") - in - let args = - Lst.mapi params (fun i _ -> - let i = Int.to_string i in - (List (List.cons (Atom "local.get" : W.t) ([ Atom i ] : W.t list)) - : W.t)) - in - List.cons - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom (addr_to_string name_wrapper) : W.t) - (List.append - (export : W.t list) - (List.append - (params : W.t list) - (List.cons - (List - (List.cons - (Atom "call" : W.t) - (List.cons - (Atom (addr_to_string addr) : W.t) - (args : W.t list))) - : W.t) - ([ List ([ Atom "drop" ] : W.t list) ] : W.t list)))))) - : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom (addr_to_string addr) : W.t) - (List.append - (source_name : W.t list) - (List.append - (type_ : W.t list) - (List.append - (params : W.t list) - (List.append - (result : W.t list) - (List.append - (locals : W.t list) - (List.append - (prologue_end : W.t list) - (body : W.t list))))))))); - ] - : W.t list) - | _ -> - ([ - List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom (addr_to_string addr) : W.t) - (List.append - (source_name : W.t list) - (List.append - (export : W.t list) - (List.append - (type_ : W.t list) - (List.append - (params : W.t list) - (List.append - (result : W.t list) - (List.append - (locals : W.t list) - (List.append - (prologue_end : W.t list) - (body : W.t list)))))))))); - ] - : W.t list) + func ~name:name_wrapper ~export ~params (args @> call addr_ @: [ Drop ])) + @ func ~name:addr ~source_name ~type_ ~params ~results ~locals + (prologue_end @> body) + | _ -> + func ~name:addr ~source_name ~export ~type_ ~params ~results ~locals + (prologue_end @> body) + : Ast.modulefield list) -let compile (prog : Clam.prog) : W.t list = - let global_ctx = Global_ctx2.create () in - let fns : W.t list = - Lst.concat_map prog.fns (fun top -> - compileFunc ~global_ctx top ~type_defs:prog.type_defs) - in - let compile_expr addr body = - let ctx = - { - locals = ref Ident_set.empty; - loop_info = Label.Map.empty; - join_points = Join.Hash.create 17; - } - in - let body = - compileExpr ~ctx ~global_ctx body - ([ List ([ Atom "drop" ] : W.t list) ] : W.t list) - ~tail:false ~type_defs:prog.type_defs - in - let locals = - Ident_set.map_to_list !(ctx.locals) (fun local -> - let ty = Ident.get_type local in - let source_name = - Wasm_util.compile_source_name (Ident.source_name local) - in - let source_type = compile_source_type ty in - (List - (List.cons - (Atom "local" : W.t) - (List.cons - (Atom (id_to_string local) : W.t) - (List.append - (source_name : W.t list) - (List.append - (source_type : W.t list) - ([ ltype_to_sexp ty ] : W.t list))))) - : W.t)) - in - let prologue_end = Wasm_util.compile_prologue_end () in - (List - (List.cons - (Atom "func" : W.t) - (List.cons - (Atom (addr_to_string addr) : W.t) - (List.append - (locals : W.t list) - (List.append (prologue_end : W.t list) (body : W.t list))))) - : W.t) - in - let main = - match prog.main with - | Some main_code -> - let main = Basic_fn_address.main () in - let main_code = compile_expr main main_code in - List.cons - (main_code : W.t) - ([ - List - (List.cons - (Atom "export" : W.t) - (List.cons - (Atom "\"_start\"" : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - ([ Atom (addr_to_string main) ] : W.t list)); - ] - : W.t list))); - ] - : W.t list) - | None -> [] - in - let init = Basic_fn_address.init () in - let init_code = compile_expr init prog.init in - let types = Transl_type.compile_group_type_defs prog.type_defs in - let data_section = Global_ctx2.compile_to_data global_ctx in - let table = Global_ctx2.compile_func_ref_declare global_ctx in - let custom_imports = Global_ctx2.compile_imports global_ctx in - let inline_wasm = Global_ctx2.compile_inlines global_ctx in - let runtime = - match - if !Basic_config.use_js_builtin_string then - Runtime_gc_js_string_api.runtime_gc_sexp - else Runtime_gc.runtime_gc_sexp - with - | (List (Atom "module" :: body) : W.t) -> body - | _ -> assert false - in - let globals = - Lst.map prog.globals (fun (x, initial) -> - match initial with - | Some (C_bool false) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons (Atom "i32" : W.t) ([ i32_zero ] : W.t list)))) - : W.t) - | Some (C_bool true) -> - let i = 1 in - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i32" : W.t) - ([ i32_to_sexp i ] : W.t list)))) - : W.t) - | Some (C_char c) -> - let i = Uchar.to_int c in - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i32" : W.t) - ([ i32_to_sexp i ] : W.t list)))) - : W.t) - | Some (C_int { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i32" : W.t) - ([ int32_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_int64 { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i64" : W.t) - ([ i64_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_uint { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i32" : W.t) - ([ u32_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_uint64 { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "i64" : W.t) - ([ u64_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_double { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "f64" : W.t) - ([ f64_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_float { v; _ }) -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (Atom "f32" : W.t) - ([ f32_to_sexp v ] : W.t list)))) - : W.t) - | Some (C_string s) -> - let v = Global_ctx2.compile_string_literal ~global_ctx s in - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "ref" : W.t) - ([ Atom "extern" ] : W.t list)) - : W.t) - ([ v ] : W.t list)))) - : W.t) - | Some (C_bytes _) | Some (C_bigint _) -> assert false - | None -> ( - match Ident.get_type x with - | I32_Int | I32_Char | I32_Bool | I32_Unit | I32_Byte | I32_Tag - | I32_Option_Char -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "i32" ] : W.t list)) - : W.t) - ([ i32_zero ] : W.t list)))) - : W.t) - | I64 -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "i64" ] : W.t list)) - : W.t) - ([ i64_zero ] : W.t list)))) - : W.t) - | F32 -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "f32" ] : W.t list)) - : W.t) - ([ f32_zero ] : W.t list)))) - : W.t) - | F64 -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "f64" ] : W.t list)) - : W.t) - ([ f64_zero ] : W.t list)))) - : W.t) - | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom (tid_to_string tid) ] - : W.t list))); - ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom (tid_to_string tid) ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Ref_extern -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "externref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "extern" ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Ref_string -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom "$moonbit.string" ] - : W.t list))); - ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "$moonbit.string" ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Ref_bytes -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ - List - (List.cons - (Atom "ref" : W.t) - (List.cons - (Atom "null" : W.t) - ([ Atom "$moonbit.bytes" ] - : W.t list))); - ] - : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "$moonbit.bytes" ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Ref_func -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "funcref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "func" ] : W.t list)); - ] - : W.t list)))) - : W.t) - | Ref_any -> - (List - (List.cons - (Atom "global" : W.t) - (List.cons - (Atom (id_to_string x) : W.t) - (List.cons - (List - (List.cons - (Atom "mut" : W.t) - ([ Atom "anyref" ] : W.t list)) - : W.t) - ([ - List - (List.cons - (Atom "ref.null" : W.t) - ([ Atom "any" ] : W.t list)); - ] - : W.t list)))) - : W.t))) - in - let global_ctx_section = Global_ctx2.compile_to_globals global_ctx in - let tags = - if !Basic_config.test_mode then - let tag = Ltype.tag_name in - List.cons - (List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"exception\"" : W.t) - (List.cons - (Atom "\"tag\"" : W.t) - ([ - List - (List.cons - (Atom "tag" : W.t) - ([ Atom tag ] : W.t list)); - ] - : W.t list)))) - : W.t) - ([ - List - (List.cons - (Atom "import" : W.t) - (List.cons - (Atom "\"exception\"" : W.t) - (List.cons - (Atom "\"throw\"" : W.t) - ([ - List - (List.cons - (Atom "func" : W.t) - ([ Atom "$throw" ] : W.t list)); - ] - : W.t list)))); - ] - : W.t list) - else [] - in - let mem = - let export = - match !Basic_config.export_memory_name with - | Some mem_name -> - let s = Basic_strutil.esc_quote mem_name in - ([ List (List.cons (Atom "export" : W.t) ([ Atom s ] : W.t list)) ] - : W.t list) - | None -> [] - in - let import = - match - (!Basic_config.import_memory_module, !Basic_config.import_memory_name) - with - | Some module_name, Some mem_name -> - let s1 = Basic_strutil.esc_quote module_name in - let s2 = Basic_strutil.esc_quote mem_name in - ([ - List - (List.cons - (Atom "import" : W.t) - (List.cons (Atom s1 : W.t) ([ Atom s2 ] : W.t list))); - ] - : W.t list) - | _ -> [] - in - ([ - List - (List.cons - (Atom "memory" : W.t) - (List.cons - (Atom "$moonbit.memory" : W.t) - (List.append - (export : W.t list) - (List.append (import : W.t list) ([ Atom "1" ] : W.t list))))); - ] - : W.t list) - in - List.append - (data_section : W.t list) - (List.append - (tags : W.t list) - (List.append - (custom_imports : W.t list) - (List.append - (mem : W.t list) - (List.append - (runtime : W.t list) - (List.append - (types : W.t list) - (List.append - (table : W.t list) - (List.append - (globals : W.t list) - (List.append - (global_ctx_section : W.t list) - (List.append - (inline_wasm : W.t list) - (List.append - (fns : W.t list) - (List.cons - (List - (List.cons - (Atom "start" : W.t) - ([ Atom (addr_to_string init) ] - : W.t list)) - : W.t) - (List.cons - (init_code : W.t) - (main : W.t list))))))))))))) +let compile (prog : Clam.prog) = + (let global_ctx = Global_ctx2.create () in + let fns : Ast.modulefield list = + Lst.concat_map prog.fns (fun top -> + compileFunc ~global_ctx top ~type_defs:prog.type_defs) + in + let compile_expr addr body = + let ctx = + { + locals = ref Ident_set.empty; + loop_info = Label.Map.empty; + join_points = Join.Hash.create 17; + return_type = [ Ltype.i32_unit ]; + } + in + let body = + compileExpr ~ctx ~global_ctx body [ Drop ] ~tail:false + ~type_defs:prog.type_defs + in + let locals = + Ident_set.map_to_list !(ctx.locals) (fun id -> + let ty = Ident.get_type id in + local ~id ty) + in + let prologue_end = Wasmir_util.compile_prologue_end () in + func ~name:addr ~locals (prologue_end @> body) + in + let main = + match prog.main with + | Some main_code -> + let main = Basic_fn_address.main () in + let main_code = compile_expr main main_code in + main_code @ export ~name:"_start" ~func:main () + | None -> [] + in + let init = Basic_fn_address.init () in + let init_code = compile_expr init prog.init in + let types = Transl_type.compile_group_type_defs prog.type_defs in + let data_section = Global_ctx2.compile_to_data global_ctx in + let table = Global_ctx2.compile_func_ref_declare global_ctx in + let custom_imports = Global_ctx2.compile_imports global_ctx in + let inline_wasm = Global_ctx2.compile_inlines global_ctx in + let runtime = + if !Basic_config.use_js_builtin_string then + Runtime_gc_js_string_api.runtime_gc + else Runtime_gc.runtime_gc + in + let runtime = runtime.fields in + let globals = + Lst.map prog.globals (fun (id, initial) -> + match initial with + | Some (C_bool false) -> global ~id (immut i32) [ i32_const 0l ] + | Some (C_bool true) -> + let i = 1l in + global ~id (immut i32) [ i32_const i ] + | Some (C_char c) -> + let i = Uchar.to_int c in + global ~id (immut i32) [ int_const i ] + | Some (C_int { v; _ }) -> global ~id (immut i32) [ i32_const v ] + | Some (C_byte { v; _ }) -> + global ~id (immut i32) [ i32_const (Int32.of_int v) ] + | Some (C_int64 { v; _ }) -> global ~id (immut i64) [ i64_const v ] + | Some (C_uint { v; _ }) -> + let v = UInt32.to_int32 v in + global ~id (immut i32) [ i32_const v ] + | Some (C_uint64 { v; _ }) -> + let v = UInt64.to_int64 v in + global ~id (immut i64) [ i64_const v ] + | Some (C_double { v; _ }) -> global ~id (immut f64) [ f64_const v ] + | Some (C_float { v; _ }) -> global ~id (immut f32) [ f32_const v ] + | Some (C_string s) -> + let v = Global_ctx2.compile_string_literal ~global_ctx s in + global ~id (immut ref_extern_) v + | Some (C_bytes _) -> assert false + | Some (C_bigint _) -> assert false + | None -> ( + match Ident.get_type id with + | I32 _ -> global ~id (mut i32) [ i32_const 0l ] + | I64 -> global ~id (mut i64) [ i64_const 0L ] + | F32 -> global ~id (mut f32) [ Ast.F32_const ("0", Float.zero) ] + | F64 -> global ~id (mut f64) [ Ast.F64_const ("0", Float.zero) ] + | Ref_lazy_init { tid } | Ref { tid } | Ref_nullable { tid } -> + global ~id + (mut (ref_ ~null ~id:tid ())) + [ ref_null (Tid.to_wasm_name tid) ] + | Ref_extern -> global ~id (mut externref) [ ref_null "extern" ] + | Ref_string -> + if !Basic_config.use_js_builtin_string then + global ~id (mut externref) [ ref_null "extern" ] + else + global ~id + (mut (ref_ ~null ~id_:"$moonbit.string" ())) + [ ref_null "$moonbit.string" ] + | Ref_bytes -> + global ~id + (mut (ref_ ~null ~id_:"$moonbit.bytes" ())) + [ ref_null "$moonbit.bytes" ] + | Ref_func -> global ~id (mut funcref) [ ref_null "func" ] + | Ref_any -> global ~id (mut anyref) [ ref_null "any" ])) + in + let global_ctx_section, import_js_string = + Global_ctx2.compile_to_globals global_ctx + in + let tags = + if !Basic_config.test_mode then + let exntag = Ltype.tag_name in + let tag = Wasmlinear_constr.import_tag in + let func = Wasmlinear_constr.import_func in + import ~module_:"exception" ~name:"tag" (tag exntag) + @ import ~module_:"exception" ~name:"throw" (func "$throw") + else [] + in + let mem = + let export = !Basic_config.export_memory_name in + let import = + match + (!Basic_config.import_memory_module, !Basic_config.import_memory_name) + with + | Some module_name, Some mem_name -> Some (module_name, mem_name) + | _ -> None + in + let limits : Ast.limits = + let min = + match !Basic_config.memory_limits_min with + | None -> 1l + | Some min -> Int32.of_int min + in + match !Basic_config.memory_limits_max with + | None -> { min; max = None } + | Some max -> { min; max = Some (Int32.of_int max) } + in + let shared = if !Basic_config.shared_memory then true else false in + memory ~name:Ast.default_memory_name ~export ~import ~shared limits + in + let fields = + data_section @ tags @ custom_imports @ import_js_string @ runtime @ mem + @ types @ table @ globals @ global_ctx_section @ inline_wasm @ fns + @ start ~init @ init_code @ main + in + { id = empty_binder (); fields } + : Ast.module_) diff --git a/src/wasm_util.ml b/src/wasm_util.ml deleted file mode 100644 index 645fc06..0000000 --- a/src/wasm_util.ml +++ /dev/null @@ -1,908 +0,0 @@ -(* - Copyright (C) 2024 International Digital Economy Academy. - This program is licensed under the MoonBit Public Source - License as published by the International Digital Economy Academy, - either version 1 of the License, or (at your option) any later - version. This program is distributed in the hope that it will be - useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit - Public Source License for more details. You should have received a - copy of the MoonBit Public Source License along with this program. If - not, see - . -*) - - -module Config = Basic_config -module Fn_address = Basic_fn_address -module UInt32 = Basic_uint32 -module UInt64 = Basic_uint64 -module Lst = Basic_lst -module Hash_int = Basic_hash_int - -type instr = W.t - -let cons_peephole instr rest = - match (instr, rest) with - | ( ( (List [ Atom "i32.const"; _ ] : W.t) - | (List [ Atom "local.get"; _ ] : W.t) ), - (List (Atom "drop" :: []) : W.t) :: rest ) -> - rest - | ( (List [ Atom "local.set"; id ] : W.t), - (List [ Atom "local.get"; id2 ] : W.t) :: rest ) - when W.equal id id2 -> - List.cons - (List (List.cons (Atom "local.tee" : W.t) ([ id ] : W.t list)) : W.t) - (rest : W.t list) - | (List [ Atom "br"; _ ] : W.t), _ -> [ instr ] - | _ -> List.cons instr rest - -module List = struct - include List - - let cons = cons_peephole -end - -let int32_to_sexp (i : int32) : instr = - let int32_to_string = Int32.to_string in - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom (int32_to_string i) ] : W.t list)) - : W.t) - -let i32_to_sexp (i : int) : instr = - let int_to_string = string_of_int in - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom (int_to_string i) ] : W.t list)) - : W.t) - -let i64_to_sexp (i : int64) : instr = - let int64_to_string = Int64.to_string in - (List - (List.cons - (Atom "i64.const" : W.t) - ([ Atom (int64_to_string i) ] : W.t list)) - : W.t) - -let f32_to_sexp (f : float) : instr = - if f = Float.infinity then - (List (List.cons (Atom "f32.const" : W.t) ([ Atom "inf" ] : W.t list)) - : W.t) - else if f = Float.neg_infinity then - (List (List.cons (Atom "f32.const" : W.t) ([ Atom "-inf" ] : W.t list)) - : W.t) - else - let float_to_string = Printf.sprintf "%h" in - (List - (List.cons - (Atom "f32.const" : W.t) - ([ Atom (float_to_string f) ] : W.t list)) - : W.t) - -let f64_to_sexp (f : float) : instr = - if f = Float.infinity then - (List (List.cons (Atom "f64.const" : W.t) ([ Atom "inf" ] : W.t list)) - : W.t) - else if f = Float.neg_infinity then - (List (List.cons (Atom "f64.const" : W.t) ([ Atom "-inf" ] : W.t list)) - : W.t) - else - let float_to_string = Printf.sprintf "%h" in - (List - (List.cons - (Atom "f64.const" : W.t) - ([ Atom (float_to_string f) ] : W.t list)) - : W.t) - -let u32_to_sexp i = - let uint32_to_string = UInt32.to_string in - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom (uint32_to_string i) ] : W.t list)) - : W.t) - -let u64_to_sexp i = - let uint64_to_string = UInt64.to_string in - (List - (List.cons - (Atom "i64.const" : W.t) - ([ Atom (uint64_to_string i) ] : W.t list)) - : W.t) - -let str_to_sexp (s : string) : instr = W.Atom ("\"" ^ W.escaped s ^ "\"") -let offset_to_string : int -> string = Printf.sprintf "offset=%d" - -let add_cst i rest = - match (i, rest) with - | _, (List (Atom "drop" :: []) : W.t) :: rest -> rest - | _, _ -> List.cons (i32_to_sexp i : W.t) (rest : W.t list) - -let compile_arith (ty : Primitive.operand_type) (op : Primitive.arith_operator) - = - match ty with - | I32 -> ( - match op with - | Add -> (List ([ Atom "i32.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "i32.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "i32.mul" ] : W.t list) : W.t) - | Div -> (List ([ Atom "i32.div_s" ] : W.t list) : W.t) - | Mod -> (List ([ Atom "i32.rem_s" ] : W.t list) : W.t) - | Neg | Sqrt -> assert false) - | I64 -> ( - match op with - | Add -> (List ([ Atom "i64.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "i64.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "i64.mul" ] : W.t list) : W.t) - | Div -> (List ([ Atom "i64.div_s" ] : W.t list) : W.t) - | Mod -> (List ([ Atom "i64.rem_s" ] : W.t list) : W.t) - | Neg | Sqrt -> assert false) - | U32 -> ( - match op with - | Div -> (List ([ Atom "i32.div_u" ] : W.t list) : W.t) - | Mod -> (List ([ Atom "i32.rem_u" ] : W.t list) : W.t) - | Add -> (List ([ Atom "i32.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "i32.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "i32.mul" ] : W.t list) : W.t) - | Neg | Sqrt -> assert false) - | U64 -> ( - match op with - | Div -> (List ([ Atom "i64.div_u" ] : W.t list) : W.t) - | Mod -> (List ([ Atom "i64.rem_u" ] : W.t list) : W.t) - | Add -> (List ([ Atom "i64.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "i64.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "i64.mul" ] : W.t list) : W.t) - | Neg | Sqrt -> assert false) - | F32 -> ( - match op with - | Add -> (List ([ Atom "f32.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "f32.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "f32.mul" ] : W.t list) : W.t) - | Div -> (List ([ Atom "f32.div" ] : W.t list) : W.t) - | Mod -> assert false - | Sqrt -> (List ([ Atom "f32.sqrt" ] : W.t list) : W.t) - | Neg -> (List ([ Atom "f32.neg" ] : W.t list) : W.t)) - | F64 -> ( - match op with - | Add -> (List ([ Atom "f64.add" ] : W.t list) : W.t) - | Sub -> (List ([ Atom "f64.sub" ] : W.t list) : W.t) - | Mul -> (List ([ Atom "f64.mul" ] : W.t list) : W.t) - | Div -> (List ([ Atom "f64.div" ] : W.t list) : W.t) - | Mod -> assert false - | Sqrt -> (List ([ Atom "f64.sqrt" ] : W.t list) : W.t) - | Neg -> (List ([ Atom "f64.neg" ] : W.t list) : W.t)) - | U8 -> assert false - -let compile_convert (kind : Primitive.convert_kind) - (from : Primitive.operand_type) (to_ : Primitive.operand_type) - (rest : W.t list) = - match kind with - | Convert -> ( - match from with - | I32 -> ( - match to_ with - | I32 -> assert false - | I64 -> (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) :: rest - | F32 -> - (List ([ Atom "f32.convert_i32_s" ] : W.t list) : W.t) :: rest - | F64 -> - (List ([ Atom "f64.convert_i32_s" ] : W.t list) : W.t) :: rest - | U8 -> - List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "255" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list)) - | U64 | U32 -> assert false) - | I64 -> ( - match to_ with - | I32 -> (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) :: rest - | I64 -> assert false - | F32 -> - (List ([ Atom "f32.convert_i64_s" ] : W.t list) : W.t) :: rest - | F64 -> - (List ([ Atom "f64.convert_i64_s" ] : W.t list) : W.t) :: rest - | U8 -> - List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "255" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list))) - | U64 | U32 -> assert false) - | F32 -> ( - match to_ with - | I32 -> (List ([ Atom "i32.trunc_f32_s" ] : W.t list) : W.t) :: rest - | I64 -> (List ([ Atom "i64.trunc_f32_s" ] : W.t list) : W.t) :: rest - | U32 -> (List ([ Atom "i32.trunc_f32_u" ] : W.t list) : W.t) :: rest - | U64 -> (List ([ Atom "i64.trunc_f32_u" ] : W.t list) : W.t) :: rest - | F32 -> assert false - | F64 -> (List ([ Atom "f64.promote_f32" ] : W.t list) : W.t) :: rest - | U8 -> - List.cons - (List ([ Atom "i32.trunc_f32_s" ] : W.t list) : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "255" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list)))) - | F64 -> ( - match to_ with - | I32 -> (List ([ Atom "i32.trunc_f64_s" ] : W.t list) : W.t) :: rest - | I64 -> (List ([ Atom "i64.trunc_f64_s" ] : W.t list) : W.t) :: rest - | U32 -> (List ([ Atom "i32.trunc_f64_u" ] : W.t list) : W.t) :: rest - | U64 -> (List ([ Atom "i64.trunc_f64_u" ] : W.t list) : W.t) :: rest - | F32 -> (List ([ Atom "f32.demote_f64" ] : W.t list) : W.t) :: rest - | F64 -> assert false - | U8 -> - List.cons - (List ([ Atom "i32.trunc_f64_s" ] : W.t list) : W.t) - (List.cons - (List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "255" ] : W.t list)) - : W.t) - (List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list)))) - | U8 -> ( - match to_ with - | I32 -> rest - | I64 -> (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) :: rest - | F64 -> - (List ([ Atom "f64.convert_i32_s" ] : W.t list) : W.t) :: rest - | F32 -> - (List ([ Atom "f32.convert_i32_s" ] : W.t list) : W.t) :: rest - | U64 | U32 | U8 -> assert false) - | U32 -> ( - match to_ with - | U32 -> assert false - | F32 -> - (List ([ Atom "f32.convert_i32_u" ] : W.t list) : W.t) :: rest - | F64 -> - (List ([ Atom "f64.convert_i32_u" ] : W.t list) : W.t) :: rest - | U64 | I64 -> - (List ([ Atom "i64.extend_i32_u" ] : W.t list) : W.t) :: rest - | I32 | U8 -> assert false) - | U64 -> ( - match to_ with - | F32 -> - (List ([ Atom "f32.convert_i64_u" ] : W.t list) : W.t) :: rest - | F64 -> - (List ([ Atom "f64.convert_i64_u" ] : W.t list) : W.t) :: rest - | U32 | I32 -> - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) :: rest - | U64 | I64 | U8 -> assert false)) - | Reinterpret -> ( - match from with - | F32 -> ( - match to_ with - | I32 -> - (List ([ Atom "i32.reinterpret_f32" ] : W.t list) : W.t) :: rest - | I64 | F32 | F64 | U64 | U32 | U8 -> assert false) - | F64 -> ( - match to_ with - | I64 -> - (List ([ Atom "i64.reinterpret_f64" ] : W.t list) : W.t) :: rest - | I32 | F32 | F64 | U64 | U32 | U8 -> assert false) - | I64 -> ( - match to_ with - | F64 -> - (List ([ Atom "f64.reinterpret_i64" ] : W.t list) : W.t) :: rest - | U64 -> rest - | I32 | I64 | F32 | U32 | U8 -> assert false) - | U64 -> ( - match to_ with - | I64 -> rest - | I32 | F32 | F64 | U64 | U32 | U8 -> assert false) - | I32 -> ( - match to_ with - | F32 -> - (List ([ Atom "f32.reinterpret_i32" ] : W.t list) : W.t) :: rest - | U32 -> rest - | I32 | I64 | U8 | F64 | U64 -> assert false) - | U32 -> ( - match to_ with - | I32 -> rest - | U32 | I64 | U8 | F32 | F64 | U64 -> assert false) - | U8 -> assert false) - -let compile_bitwise (ty : Primitive.operand_type) - (op : Primitive.bitwise_operator) (rest : W.t list) = - match ty with - | I32 -> ( - match op with - | Not -> - List.cons - (List - (List.cons - (Atom "i32.xor" : W.t) - ([ - List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "-1" ] : W.t list)); - ] - : W.t list)) - : W.t) - (rest : W.t list) - | And -> - List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list) - | Or -> - List.cons - (List ([ Atom "i32.or" ] : W.t list) : W.t) - (rest : W.t list) - | Xor -> - List.cons - (List ([ Atom "i32.xor" ] : W.t list) : W.t) - (rest : W.t list) - | Shl -> - List.cons - (List ([ Atom "i32.shl" ] : W.t list) : W.t) - (rest : W.t list) - | Shr -> - List.cons - (List ([ Atom "i32.shr_s" ] : W.t list) : W.t) - (rest : W.t list) - | Clz -> - List.cons - (List ([ Atom "i32.clz" ] : W.t list) : W.t) - (rest : W.t list) - | Ctz -> - List.cons - (List ([ Atom "i32.ctz" ] : W.t list) : W.t) - (rest : W.t list) - | Popcnt -> - List.cons - (List ([ Atom "i32.popcnt" ] : W.t list) : W.t) - (rest : W.t list)) - | I64 -> ( - match op with - | Not -> - List.cons - (List - (List.cons - (Atom "i64.xor" : W.t) - ([ - List - (List.cons - (Atom "i64.const" : W.t) - ([ Atom "-1" ] : W.t list)); - ] - : W.t list)) - : W.t) - (rest : W.t list) - | And -> - List.cons - (List ([ Atom "i64.and" ] : W.t list) : W.t) - (rest : W.t list) - | Or -> - List.cons - (List ([ Atom "i64.or" ] : W.t list) : W.t) - (rest : W.t list) - | Xor -> - List.cons - (List ([ Atom "i64.xor" ] : W.t list) : W.t) - (rest : W.t list) - | Shl -> - List.cons - (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i64.shl" ] : W.t list) : W.t) - (rest : W.t list)) - | Shr -> - List.cons - (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i64.shr_s" ] : W.t list) : W.t) - (rest : W.t list)) - | Clz -> - List.cons - (List ([ Atom "i64.clz" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list)) - | Ctz -> - List.cons - (List ([ Atom "i64.ctz" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list)) - | Popcnt -> - List.cons - (List ([ Atom "i64.popcnt" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list))) - | F32 -> assert false - | F64 -> assert false - | U8 -> assert false - | U32 -> ( - match op with - | Not -> - List.cons - (List - (List.cons - (Atom "i32.xor" : W.t) - ([ - List - (List.cons - (Atom "i32.const" : W.t) - ([ Atom "-1" ] : W.t list)); - ] - : W.t list)) - : W.t) - (rest : W.t list) - | And -> - List.cons - (List ([ Atom "i32.and" ] : W.t list) : W.t) - (rest : W.t list) - | Or -> - List.cons - (List ([ Atom "i32.or" ] : W.t list) : W.t) - (rest : W.t list) - | Xor -> - List.cons - (List ([ Atom "i32.xor" ] : W.t list) : W.t) - (rest : W.t list) - | Shl -> - List.cons - (List ([ Atom "i32.shl" ] : W.t list) : W.t) - (rest : W.t list) - | Shr -> - List.cons - (List ([ Atom "i32.shr_u" ] : W.t list) : W.t) - (rest : W.t list) - | Clz -> - List.cons - (List ([ Atom "i32.clz" ] : W.t list) : W.t) - (rest : W.t list) - | Ctz -> - List.cons - (List ([ Atom "i32.ctz" ] : W.t list) : W.t) - (rest : W.t list) - | Popcnt -> - List.cons - (List ([ Atom "i32.popcnt" ] : W.t list) : W.t) - (rest : W.t list)) - | U64 -> ( - match op with - | Not -> - List.cons - (List - (List.cons - (Atom "i64.xor" : W.t) - ([ - List - (List.cons - (Atom "i64.const" : W.t) - ([ Atom "-1" ] : W.t list)); - ] - : W.t list)) - : W.t) - (rest : W.t list) - | And -> - List.cons - (List ([ Atom "i64.and" ] : W.t list) : W.t) - (rest : W.t list) - | Or -> - List.cons - (List ([ Atom "i64.or" ] : W.t list) : W.t) - (rest : W.t list) - | Xor -> - List.cons - (List ([ Atom "i64.xor" ] : W.t list) : W.t) - (rest : W.t list) - | Shl -> - List.cons - (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i64.shl" ] : W.t list) : W.t) - (rest : W.t list)) - | Shr -> - List.cons - (List ([ Atom "i64.extend_i32_s" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i64.shr_u" ] : W.t list) : W.t) - (rest : W.t list)) - | Clz -> - List.cons - (List ([ Atom "i64.clz" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list)) - | Ctz -> - List.cons - (List ([ Atom "i64.ctz" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list)) - | Popcnt -> - List.cons - (List ([ Atom "i64.popcnt" ] : W.t list) : W.t) - (List.cons - (List ([ Atom "i32.wrap_i64" ] : W.t list) : W.t) - (rest : W.t list))) - -let compile_comparison (ty : Primitive.operand_type) (op : Primitive.comparison) - = - match ty with - | I32 -> ( - match op with - | Lt -> (List ([ Atom "i32.lt_s" ] : W.t list) : W.t) - | Le -> (List ([ Atom "i32.le_s" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "i32.gt_s" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "i32.ge_s" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "i32.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "i32.ne" ] : W.t list) : W.t)) - | I64 -> ( - match op with - | Lt -> (List ([ Atom "i64.lt_s" ] : W.t list) : W.t) - | Le -> (List ([ Atom "i64.le_s" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "i64.gt_s" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "i64.ge_s" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "i64.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "i64.ne" ] : W.t list) : W.t)) - | F32 -> ( - match op with - | Lt -> (List ([ Atom "f32.lt" ] : W.t list) : W.t) - | Le -> (List ([ Atom "f32.le" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "f32.gt" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "f32.ge" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "f32.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "f32.ne" ] : W.t list) : W.t)) - | F64 -> ( - match op with - | Lt -> (List ([ Atom "f64.lt" ] : W.t list) : W.t) - | Le -> (List ([ Atom "f64.le" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "f64.gt" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "f64.ge" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "f64.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "f64.ne" ] : W.t list) : W.t)) - | U8 -> ( - match op with - | Lt -> (List ([ Atom "i32.lt_s" ] : W.t list) : W.t) - | Le -> (List ([ Atom "i32.le_s" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "i32.gt_s" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "i32.ge_s" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "i32.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "i32.ne" ] : W.t list) : W.t)) - | U32 -> ( - match op with - | Lt -> (List ([ Atom "i32.lt_u" ] : W.t list) : W.t) - | Le -> (List ([ Atom "i32.le_u" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "i32.gt_u" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "i32.ge_u" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "i32.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "i32.ne" ] : W.t list) : W.t)) - | U64 -> ( - match op with - | Lt -> (List ([ Atom "i64.lt_u" ] : W.t list) : W.t) - | Le -> (List ([ Atom "i64.le_u" ] : W.t list) : W.t) - | Gt -> (List ([ Atom "i64.gt_u" ] : W.t list) : W.t) - | Ge -> (List ([ Atom "i64.ge_u" ] : W.t list) : W.t) - | Eq -> (List ([ Atom "i64.eq" ] : W.t list) : W.t) - | Ne -> (List ([ Atom "i64.ne" ] : W.t list) : W.t)) - -let compile_compare (ty : Primitive.operand_type) x y = - match ty with - | I32 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "i32.ge_s" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "i32.le_s" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | U32 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "i32.ge_u" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "i32.le_u" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | I64 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "i64.ge_s" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "i64.le_s" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | U64 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "i64.ge_u" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "i64.le_u" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | F32 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "f32.ge" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "f32.le" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | F64 -> - (List - (List.cons - (Atom "i32.sub" : W.t) - (List.cons - (List - (List.cons - (Atom "f64.ge" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))) - : W.t) - ([ - List - (List.cons - (Atom "f64.le" : W.t) - (List.cons (x : W.t) ([ y ] : W.t list))); - ] - : W.t list))) - : W.t) - | U8 -> assert false - -let compile_int_switch ~(result_ty : W.t list) ~(obj : W.t) - ~(cases : (int * W.t list) list) ~(default : W.t list) (rest : W.t list) = - let label_to_string = Label.to_wasm_name in - let cases_len = List.length cases in - let min_index, max_index = - Lst.fold_left cases (Int.max_int, Int.min_int) (fun (min, max) (tag, _) -> - (Int.min min tag, Int.max max tag)) - in - if cases_len >= 3 && max_index - min_index + 1 = cases_len then - let exit_label = Label.fresh "switch_int" in - let default_label = Label.fresh "switch_default" in - let label_table = Hash_int.create 17 in - let labels = - List.init cases_len (fun i -> - let label = - Label.fresh ("switch_int_" ^ Int.to_string i : Stdlib.String.t) - in - Hash_int.add label_table i label; - (Atom (label_to_string label) : W.t)) - in - let br_table = - let br_table = - ([ - List - (List.cons - (Atom "br_table" : W.t) - (List.append - (labels : W.t list) - ([ Atom (label_to_string default_label) ] : W.t list))); - ] - : W.t list) - in - if min_index = 0 then List.cons (obj : W.t) (br_table : W.t list) - else - List.cons - (obj : W.t) - (List.cons - (i32_to_sexp min_index : W.t) - (List.cons - (List ([ Atom "i32.sub" ] : W.t list) : W.t) - (br_table : W.t list))) - in - let blocks = - Lst.fold_left cases br_table (fun acc (lhs, act) -> - let label = Hash_int.find_exn label_table (lhs - min_index) in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom (label_to_string label) : W.t) - (acc : W.t list))) - : W.t) - (List.append - (act : W.t list) - ([ - List - (List.cons - (Atom "br" : W.t) - ([ Atom (label_to_string exit_label) ] : W.t list)); - ] - : W.t list))) - in - let blocks_with_default = - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom (label_to_string default_label) : W.t) - (blocks : W.t list))) - : W.t) - (List.append - (default : W.t list) - ([ - List - (List.cons - (Atom "br" : W.t) - ([ Atom (label_to_string exit_label) ] : W.t list)); - ] - : W.t list)) - in - List.cons - (List - (List.cons - (Atom "block" : W.t) - (List.cons - (Atom (label_to_string exit_label) : W.t) - (List.append - (result_ty : W.t list) - (blocks_with_default : W.t list)))) - : W.t) - (rest : W.t list) - else - let switches = - List.fold_right - (fun (lhs, act) acc : W.t list -> - [ - List - (List.cons - (Atom "if" : W.t) - (List.append - (result_ty : W.t list) - (List.cons - (List - (List.cons - (Atom "i32.eq" : W.t) - (List.cons - (obj : W.t) - ([ i32_to_sexp lhs ] : W.t list))) - : W.t) - (List.cons - (List (List.cons (Atom "then" : W.t) (act : W.t list)) - : W.t) - ([ - List - (List.cons (Atom "else" : W.t) (acc : W.t list)); - ] - : W.t list))))); - ]) - cases default - in - List.append (switches : W.t list) (rest : W.t list) - -let compile_source_pos ~pkg (pos : Lexing.position) = - let file = pos.pos_fname in - let line = pos.pos_lnum in - let column = pos.pos_cnum - pos.pos_bol in - let string_to_sexp s = W.Atom s in - let int_to_sexp x = W.Atom (string_of_int x) in - (List - (List.cons - (Atom "source_pos" : W.t) - (List.cons - (string_to_sexp pkg : W.t) - (List.cons - (string_to_sexp file : W.t) - (List.cons - (int_to_sexp line : W.t) - ([ int_to_sexp column ] : W.t list))))) - : W.t) - -let prepend_source_pos ~get_pos (loc : Loc.t option) (v : W.t list) = - if !Config.debug then - match loc with - | None -> v - | Some loc -> - let pos : Lexing.position = get_pos loc in - if pos.pos_cnum = -1 then v - else compile_source_pos ~pkg:(Loc.package loc) pos :: v - else v - -let prepend_start_source_pos (loc : Loc.t option) (v : W.t list) = - prepend_source_pos ~get_pos:Loc.get_start loc v - -let prepend_end_source_pos (loc : Loc.t option) (v : W.t list) = - prepend_source_pos ~get_pos:Loc.get_end loc v - -let compile_source_name (source_name : string) = - if !Config.debug then - ([ - List - (List.cons - (Atom "source_name" : W.t) - ([ str_to_sexp source_name ] : W.t list)); - ] - : W.t list) - else [] - -let compile_fn_source_name (fn_addr : Fn_address.t) = - if !Config.debug then - let name = Fn_address.source_name fn_addr in - ([ - List - (List.cons - (Atom "source_name" : W.t) - ([ str_to_sexp name ] : W.t list)); - ] - : W.t list) - else [] - -let compile_source_type (typ : string) = - if !Config.debug then - ([ List (List.cons (Atom "source_type" : W.t) ([ Atom typ ] : W.t list)) ] - : W.t list) - else [] - -let compile_prologue_end () = - if !Config.debug then - ([ List ([ Atom "prologue_end" ] : W.t list) ] : W.t list) - else [] diff --git a/src/wasmgc_constr.ml b/src/wasmgc_constr.ml new file mode 100644 index 0000000..5ee361b --- /dev/null +++ b/src/wasmgc_constr.ml @@ -0,0 +1,310 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Config = Basic_config +module Itype = Dwarfsm_itype +module Lst = Basic_lst +module Ast = Dwarfsm_ast +module Tid = Basic_ty_ident +module Ident = Clam_ident +module Ltype = Ltype_gc +module Ltype_util = Ltype_gc_util + +type instr = Ast.instr + +let binder = Wasmlinear_constr.binder +and empty_binder = Wasmlinear_constr.empty_binder +and externref = Wasmlinear_constr.externref +and ( @: ) = Wasmlinear_constr.( @: ) + +let anyref = Ast.Reftype (Ref (Nullable, Absheaptype Any)) +let funcref = Ast.Reftype (Ref (Nullable, Absheaptype Func)) +let ref_extern_ = Ast.Reftype (Ref (NonNull, Absheaptype Extern)) +let null = Ast.Nullable +let typeidx s = ({ var = Unresolve s } : Ast.typeidx) +let dataidx s = ({ var = Unresolve s } : Ast.dataidx) +let localidx s = ({ var = Unresolve s } : Ast.localidx) +let globalidx s = ({ var = Unresolve s } : Ast.globalidx) + +let ref_ ?(null = Ast.NonNull) ?id ?(id_ = "") () = + let id = + match id with + | None -> if id_ = "" then assert false else typeidx id_ + | Some id -> typeidx (Tid.to_wasm_name id) + in + Ast.Reftype (Ref (null, Type id)) + +let field_immut (type_ : Ast.valtype) = + ({ mut = Const; type_ = Ast.Valtype type_ } : Ast.fieldtype) + +let field_mut (type_ : Ast.valtype) = + ({ mut = Var; type_ = Ast.Valtype type_ } : Ast.fieldtype) + +let final = () + +let sub ?final ?(super = []) (subtype : Ast.subtype) = + (let final = match final with None -> false | Some () -> true in + let super = Lst.map super (fun tid -> typeidx (Tid.to_wasm_name tid)) in + { subtype with final; super } + : Ast.subtype) + +let typedef ?id subtype = + (let id = + match id with + | None -> empty_binder () + | Some id -> binder (Tid.to_wasm_name id) + in + (id, subtype) + : Ast.typedef) + +let field ?id (fieldtype : Ast.fieldtype) = + (let id = + match id with + | None -> empty_binder () + | Some id -> binder (Tid.to_wasm_name id) + in + { id; fieldtype } + : Ast.field) + +let comp_struct (fields : Ast.field list) = + ({ final = true; super = []; type_ = Structtype (Struct fields) } + : Ast.subtype) + +let comp_func params results = + ({ + final = true; + super = []; + type_ = Wasmlinear_constr.mk_functype params results; + } + : Ast.subtype) + +let comp_array (fieldtype : Ast.fieldtype) = + ({ final = true; super = []; type_ = Arraytype (Array fieldtype) } + : Ast.subtype) + +let global ?id ?id_ (type_ : Ast.globaltype) (init : instr list) = + (let id = + match id with + | None -> ( match id_ with None -> assert false | Some s -> binder s) + | Some id -> binder (Ident.to_wasm_name id) + in + Global { id; type_; init } + : Ast.modulefield) + +let import_global ~id_ ~mod_ ~s (type_ : Ast.globaltype) = + (let id = binder id_ in + let module_ = mod_ in + let name = s in + Ast.Import { module_; name; desc = Global (id, type_) } + : Ast.modulefield) + +let data ~(name : string) data_str = + [ Ast.Data { id = binder name; mode = Ast.DMPassive; data_str } ] + +let elem_declare_func (fns : Basic_fn_address.t list) = + [ + Ast.Elem + { + id = empty_binder (); + mode = Ast.EMDeclarative; + type_ = Ref (NonNull, Absheaptype Func); + list = Lst.map fns (fun name -> [ Wasmlinear_constr.ref_func name ]); + }; + ] + +let source_type_ (typ : Ltype.t) = + (if !Config.debug then + match typ with + | I32 { kind = I32_Int } -> Some Int + | I32 { kind = I32_Char } -> Some Char + | I32 { kind = I32_Bool } -> Some Bool + | I32 { kind = I32_Unit } -> Some Unit + | I32 { kind = I32_Byte } -> Some Byte + | I32 { kind = I32_Int16 } -> Some Int16 + | I32 { kind = I32_UInt16 } -> Some UInt16 + | I64 -> Some Int64 + | F64 -> Some Double + | F32 -> Some Float + | _ -> None + else None + : Itype.t option) + +let source_name_ (source_name : string) = + if !Config.debug then Some source_name else None + +let ltype_to_valtype (typ : Ltype.t) = + (match typ with + | Ref_extern -> externref + | F32 -> Numtype F32 + | F64 -> Numtype F64 + | I64 -> Numtype I64 + | I32 _ -> Numtype I32 + | Ref_bytes -> ref_ ~id_:"$moonbit.bytes" () + | Ref_string -> + if !Basic_config.use_js_builtin_string then ref_extern_ + else ref_ ~id_:"$moonbit.string" () + | Ref { tid } -> ref_ ~id:tid () + | Ref_nullable { tid } -> + if !Basic_config.use_js_builtin_string && Tid.equal tid Ltype.tid_string + then externref + else ref_ ~null ~id:tid () + | Ref_lazy_init { tid } -> ref_ ~null ~id:tid () + | Ref_func -> funcref + | Ref_any -> anyref + : Ast.valtype) + +let result = ltype_to_valtype + +let param ?id ?id_ (ltype : Ltype.t) = + (let source_name = + match id with + | None -> None + | Some id -> source_name_ (Ident.source_name id) + in + let id = + match id with + | None -> ( match id_ with None -> empty_binder () | Some s -> binder s) + | Some s -> binder (Ident.to_wasm_name s) + in + let source_type = source_type_ ltype in + let type_ = result ltype in + { id; source_name; source_type; type_ } + : Ast.param) + +let param_ ?id (valtype : Ast.valtype) = + (let source_name = None in + let id = match id with None -> empty_binder () | Some s -> binder s in + let source_type = None in + let type_ = valtype in + { id; source_name; source_type; type_ } + : Ast.param) + +let local = param + +let array_new_data ?id ?id_ data = + let data = dataidx data in + let id = + match id with + | None -> ( match id_ with None -> assert false | Some s -> typeidx s) + | Some tid -> typeidx (Tid.to_wasm_name tid) + in + Ast.Array_new_data (id, data) + +let array_new_default ?id ?id_ () = + let id = + match id with + | None -> ( match id_ with None -> assert false | Some s -> typeidx s) + | Some id -> typeidx (Tid.to_wasm_name id) + in + Ast.Array_new_default id + +let array_new_fixed ~id ~size = + let size = Int32.of_int size in + let id = typeidx (Tid.to_wasm_name id) in + Ast.Array_new_fixed (id, size) + +let struct_new tid = + let tid = typeidx (Tid.to_wasm_name tid) in + Ast.Struct_new tid + +let ref_null str = + let ht : Ast.heaptype = + match str with + | "any" -> Absheaptype Any + | "eq" -> Absheaptype Eq + | "i31" -> Absheaptype I31 + | "struct" -> Absheaptype Struct + | "array" -> Absheaptype Array + | "none" -> Absheaptype None + | "func" -> Absheaptype Func + | "nofunc" -> Absheaptype NoFunc + | "extern" -> Absheaptype Extern + | "noextern" -> Absheaptype NoExtern + | "" -> assert false + | s when s.[0] = '$' -> Type (typeidx s) + | _ -> assert false + in + Ast.Ref_null ht + +let local_get (id : Ident.t) = + (Local_get (localidx (Ident.to_wasm_name id)) : Ast.instr) + +let local_get_ (id : string) = (Local_get (localidx id) : Ast.instr) + +let local_set (id : Ident.t) = + (Local_set (localidx (Ident.to_wasm_name id)) : Ast.instr) + +let global_get (id : Ident.t) = + (Global_get (globalidx (Ident.to_wasm_name id)) : Ast.instr) + +let global_get_ (id : string) = (Global_get (globalidx id) : Ast.instr) + +let global_set (id : Ident.t) = + (Global_set (globalidx (Ident.to_wasm_name id)) : Ast.instr) + +let generic_get (id : Ident.t) = + (match id with + | Pident _ | Pmutable_ident _ -> [ local_get id ] + | Pdot { ty; _ } -> + if Ltype_util.is_non_nullable_ref_type ty then + global_get id @: [ Ast.Ref_as_non_null ] + else [ global_get id ] + : Ast.instr list) + +let ref_cast valtype = + match valtype with + | Ast.Reftype reftype -> Ast.Ref_cast reftype + | _ -> assert false + +let ref_cast_ (tid : Tid.t) = + let tid = Tid.to_wasm_name tid in + Ast.Ref_cast (Ref (NonNull, Type (typeidx tid))) + +let array_new tid = (Array_new (typeidx (Tid.to_wasm_name tid)) : Ast.instr) +let array_new_ id = (Array_new (typeidx id) : Ast.instr) +let memory_init id = Ast.Memory_init { var = Unresolve id } + +let struct_get tid index = + Ast.Struct_get + ( typeidx (Tid.to_wasm_name tid), + { var = Ast.Resolved { var_name = ""; index } } ) + +let struct_set tid index = + Ast.Struct_set + ( typeidx (Tid.to_wasm_name tid), + { var = Ast.Resolved { var_name = ""; index } } ) + +let struct_new_default tid = + Ast.Struct_new_default (typeidx (Tid.to_wasm_name tid)) + +let ref_func addr = + (Ast.Ref_func { var = Unresolve (Basic_fn_address.to_wasm_name addr) } + : Ast.instr) + +let array_set tid = Ast.Array_set (typeidx (Tid.to_wasm_name tid)) +let array_set_ id = Ast.Array_set (typeidx id) +let array_get tid = Ast.Array_get (typeidx (Tid.to_wasm_name tid)) +let array_get_u tid = Ast.Array_get_u (typeidx (Tid.to_wasm_name tid)) +let array_get_u_ id = Ast.Array_get_u (typeidx id) +let array_get_s tid = Ast.Array_get_s (typeidx (Tid.to_wasm_name tid)) +let call_ref tid = Ast.Call_ref (typeidx (Tid.to_wasm_name tid)) + +let array_copy ~dst_tid ~src_tid = + (Array_copy + (typeidx (Tid.to_wasm_name dst_tid), typeidx (Tid.to_wasm_name src_tid)) + : instr) + +let array_fill tid = (Array_fill (typeidx (Tid.to_wasm_name tid)) : instr) +let br_if (id : string) = (Br_if { var = Unresolve id } : instr) diff --git a/src/wasmir_util.ml b/src/wasmir_util.ml new file mode 100644 index 0000000..f722ffd --- /dev/null +++ b/src/wasmir_util.ml @@ -0,0 +1,419 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Config = Basic_config +module Ast = Dwarfsm_ast +module Lst = Basic_lst +module Hash_int = Basic_hash_int +module Fn_address = Basic_fn_address + +type instr = Ast.instr + +let i32_const = Wasmlinear_constr.i32_const +and int_const = Wasmlinear_constr.int_const +and if_ = Wasmlinear_constr.if_ +and block = Wasmlinear_constr.block +and br_ = Wasmlinear_constr.br_ +and br_table = Wasmlinear_constr.br_table +and ( @: ) = Wasmlinear_constr.( @: ) +and ( @> ) = Wasmlinear_constr.( @> ) + +let add_cst i (rest : instr list) = + match (i, rest) with + | _, Drop :: rest -> rest + | _, _ -> i32_const (Int32.of_int i) @: rest + +let compile_arith (ty : Primitive.operand_type) (op : Primitive.arith_operator) + = + (match ty with + | I32 -> ( + match op with + | Add -> I32_add + | Sub -> I32_sub + | Mul -> I32_mul + | Div -> I32_div_s + | Mod -> I32_rem_s + | Neg | Sqrt | Abs -> assert false) + | I64 -> ( + match op with + | Add -> I64_add + | Sub -> I64_sub + | Mul -> I64_mul + | Div -> I64_div_s + | Mod -> I64_rem_s + | Neg | Sqrt | Abs -> assert false) + | U32 -> ( + match op with + | Div -> I32_div_u + | Mod -> I32_rem_u + | Add -> I32_add + | Sub -> I32_sub + | Mul -> I32_mul + | Neg | Sqrt | Abs -> assert false) + | U64 -> ( + match op with + | Div -> I64_div_u + | Mod -> I64_rem_u + | Add -> I64_add + | Sub -> I64_sub + | Mul -> I64_mul + | Neg | Sqrt | Abs -> assert false) + | F32 -> ( + match op with + | Add -> F32_add + | Sub -> F32_sub + | Mul -> F32_mul + | Div -> F32_div + | Mod -> assert false + | Sqrt -> F32_sqrt + | Neg -> F32_neg + | Abs -> F32_abs) + | F64 -> ( + match op with + | Add -> F64_add + | Sub -> F64_sub + | Mul -> F64_mul + | Div -> F64_div + | Mod -> assert false + | Sqrt -> F64_sqrt + | Neg -> F64_neg + | Abs -> F64_abs) + | U16 -> assert false + | U8 -> assert false + | I16 -> assert false + : instr) + +let compile_convert (kind : Primitive.convert_kind) + (from : Primitive.operand_type) (to_ : Primitive.operand_type) + (rest : instr list) = + match kind with + | Convert -> ( + match from with + | I32 -> ( + match to_ with + | I32 -> assert false + | I64 -> I64_extend_i32_s @: rest + | F32 -> F32_convert_i32_s @: rest + | F64 -> F64_convert_i32_s @: rest + | U8 -> I32_const 255l @: I32_and @: rest + | U16 | I16 -> I32_const 65535l @: I32_and @: rest + | U64 | U32 -> assert false) + | I64 -> ( + match to_ with + | I32 -> I32_wrap_i64 @: rest + | I64 -> assert false + | F32 -> F32_convert_i64_s @: rest + | F64 -> F64_convert_i64_s @: rest + | U8 -> I32_wrap_i64 @: I32_const 255l @: I32_and @: rest + | U16 | I16 -> I32_wrap_i64 @: I32_const 65535l @: I32_and @: rest + | U64 | U32 -> assert false) + | F32 -> ( + match to_ with + | I32 -> I32_trunc_f32_s @: rest + | I64 -> I64_trunc_f32_s @: rest + | U32 -> I32_trunc_f32_u @: rest + | U64 -> I64_trunc_f32_u @: rest + | F32 -> assert false + | F64 -> F64_promote_f32 @: rest + | U8 -> I32_trunc_f32_s @: I32_const 255l @: I32_and @: rest + | U16 | I16 -> assert false) + | F64 -> ( + match to_ with + | I32 -> I32_trunc_f64_s @: rest + | I64 -> I64_trunc_f64_s @: rest + | U32 -> I32_trunc_f64_u @: rest + | U64 -> I64_trunc_f64_u @: rest + | F32 -> F32_demote_f64 @: rest + | F64 -> assert false + | U8 -> I32_trunc_f64_s @: I32_const 255l @: I32_and @: rest + | U16 | I16 -> assert false) + | U8 -> ( + match to_ with + | I32 | U16 | I16 -> rest + | I64 -> I64_extend_i32_s @: rest + | F64 -> F64_convert_i32_s @: rest + | F32 -> F32_convert_i32_s @: rest + | U64 | U32 | U8 -> assert false) + | U16 -> ( + match to_ with + | I32 -> rest + | I64 -> I64_extend_i32_s @: rest + | F64 -> assert false + | F32 -> assert false + | U8 -> I32_const 255l @: I32_and @: rest + | U64 | U32 | U16 | I16 -> assert false) + | I16 -> ( + match to_ with + | I32 -> I32_extend_16_s @: rest + | I64 -> I32_extend_16_s @: I64_extend_i32_s @: rest + | F64 -> assert false + | F32 -> assert false + | U8 -> I32_const 255l @: I32_and @: rest + | U64 | U32 | U16 | I16 -> assert false) + | U32 -> ( + match to_ with + | U32 -> assert false + | F32 -> F32_convert_i32_u @: rest + | F64 -> F64_convert_i32_u @: rest + | U64 | I64 -> I64_extend_i32_u @: rest + | I32 | U8 | U16 | I16 -> assert false) + | U64 -> ( + match to_ with + | F32 -> F32_convert_i64_u @: rest + | F64 -> F64_convert_i64_u @: rest + | U32 | I32 -> I32_wrap_i64 @: rest + | U64 | I64 | U8 | U16 | I16 -> assert false)) + | Saturate -> ( + match from with + | F32 -> ( + match to_ with + | I32 -> I32_trunc_sat_f32_s @: rest + | U32 -> I32_trunc_sat_f32_u @: rest + | I64 -> I64_trunc_sat_f32_s @: rest + | U64 -> I64_trunc_sat_f32_u @: rest + | U8 -> I32_trunc_sat_f32_u @: I32_const 255l @: I32_and @: rest + | F32 | F64 | U16 | I16 -> assert false) + | F64 -> ( + match to_ with + | I64 -> I64_trunc_sat_f64_s @: rest + | U64 -> I64_trunc_sat_f64_u @: rest + | I32 -> I32_trunc_sat_f64_s @: rest + | U32 -> I32_trunc_sat_f64_u @: rest + | U8 -> I32_trunc_sat_f64_u @: I32_const 255l @: I32_and @: rest + | F32 | F64 | U16 | I16 -> assert false) + | I32 | U32 | I64 | U64 | U8 | I16 | U16 -> assert false) + | Reinterpret -> ( + match from with + | F32 -> ( + match to_ with + | I32 -> I32_reinterpret_f32 @: rest + | I64 | F32 | F64 | U64 | U32 | U8 | U16 | I16 -> assert false) + | F64 -> ( + match to_ with + | I64 -> I64_reinterpret_f64 @: rest + | I32 | F32 | F64 | U64 | U32 | U8 | U16 | I16 -> assert false) + | I64 -> ( + match to_ with + | F64 -> F64_reinterpret_i64 @: rest + | U64 -> rest + | I32 | I64 | F32 | U32 | U8 | U16 | I16 -> assert false) + | U64 -> ( + match to_ with + | I64 -> rest + | I32 | F32 | F64 | U64 | U32 | U8 | U16 | I16 -> assert false) + | I32 -> ( + match to_ with + | F32 -> F32_reinterpret_i32 @: rest + | U32 -> rest + | I32 | I64 | U8 | F64 | U64 | U16 | I16 -> assert false) + | U32 -> ( + match to_ with + | I32 -> rest + | U32 | I64 | U8 | F32 | F64 | U64 | U16 | I16 -> assert false) + | U8 | U16 | I16 -> assert false) + +let compile_bitwise (ty : Primitive.operand_type) + (op : Primitive.bitwise_operator) (rest : instr list) = + match ty with + | I32 -> ( + match op with + | Not -> int_const (-1) @: I32_xor @: rest + | And -> I32_and @: rest + | Or -> I32_or @: rest + | Xor -> I32_xor @: rest + | Shl -> I32_shl @: rest + | Shr -> I32_shr_s @: rest + | Clz -> I32_clz @: rest + | Ctz -> I32_ctz @: rest + | Popcnt -> I32_popcnt @: rest) + | I64 -> ( + match op with + | Not -> I64_const (Int64.of_int (-1)) @: I64_xor @: rest + | And -> I64_and @: rest + | Or -> I64_or @: rest + | Xor -> I64_xor @: rest + | Shl -> I64_extend_i32_s @: I64_shl @: rest + | Shr -> I64_extend_i32_s @: I64_shr_s @: rest + | Clz -> I64_clz @: I32_wrap_i64 @: rest + | Ctz -> I64_ctz @: I32_wrap_i64 @: rest + | Popcnt -> I64_popcnt @: I32_wrap_i64 @: rest) + | F32 -> assert false + | F64 -> assert false + | U16 -> assert false + | U8 -> assert false + | I16 -> assert false + | U32 -> ( + match op with + | Not -> int_const (-1) @: I32_xor @: rest + | And -> I32_and @: rest + | Or -> I32_or @: rest + | Xor -> I32_xor @: rest + | Shl -> I32_shl @: rest + | Shr -> I32_shr_u @: rest + | Clz -> I32_clz @: rest + | Ctz -> I32_ctz @: rest + | Popcnt -> I32_popcnt @: rest) + | U64 -> ( + match op with + | Not -> I64_const (Int64.of_int (-1)) @: I64_xor @: rest + | And -> I64_and @: rest + | Or -> I64_or @: rest + | Xor -> I64_xor @: rest + | Shl -> I64_extend_i32_s @: I64_shl @: rest + | Shr -> I64_extend_i32_s @: I64_shr_u @: rest + | Clz -> I64_clz @: I32_wrap_i64 @: rest + | Ctz -> I64_ctz @: I32_wrap_i64 @: rest + | Popcnt -> I64_popcnt @: I32_wrap_i64 @: rest) + +let compile_comparison (ty : Primitive.operand_type) (op : Primitive.comparison) + = + (match ty with + | I32 -> ( + match op with + | Lt -> I32_lt_s + | Le -> I32_le_s + | Gt -> I32_gt_s + | Ge -> I32_ge_s + | Eq -> I32_eq + | Ne -> I32_ne) + | I64 -> ( + match op with + | Lt -> I64_lt_s + | Le -> I64_le_s + | Gt -> I64_gt_s + | Ge -> I64_ge_s + | Eq -> I64_eq + | Ne -> I64_ne) + | F32 -> ( + match op with + | Lt -> F32_lt + | Le -> F32_le + | Gt -> F32_gt + | Ge -> F32_ge + | Eq -> F32_eq + | Ne -> F32_ne) + | F64 -> ( + match op with + | Lt -> F64_lt + | Le -> F64_le + | Gt -> F64_gt + | Ge -> F64_ge + | Eq -> F64_eq + | Ne -> F64_ne) + | U8 -> ( + match op with + | Lt -> I32_lt_s + | Le -> I32_le_s + | Gt -> I32_gt_s + | Ge -> I32_ge_s + | Eq -> I32_eq + | Ne -> I32_ne) + | U32 -> ( + match op with + | Lt -> I32_lt_u + | Le -> I32_le_u + | Gt -> I32_gt_u + | Ge -> I32_ge_u + | Eq -> I32_eq + | Ne -> I32_ne) + | U64 -> ( + match op with + | Lt -> I64_lt_u + | Le -> I64_le_u + | Gt -> I64_gt_u + | Ge -> I64_ge_u + | Eq -> I64_eq + | Ne -> I64_ne) + | U16 -> assert false + | I16 -> assert false + : instr) + +let compile_int_switch ~(result_ty : Ast.valtype list) ~(obj : instr) + ~(cases : (int * instr list) list) ~(default : instr list) + (rest : instr list) = + let cases_len = List.length cases in + let min_index, max_index = + Lst.fold_left cases (Int.max_int, Int.min_int) (fun (min, max) -> + fun (tag, _) -> (Int.min min tag, Int.max max tag)) + in + if cases_len >= 3 && max_index - min_index + 1 = cases_len then + let exit_label = Label.fresh "switch_int" in + let default_label = Label.fresh "switch_default" in + let label_table = Hash_int.create 17 in + let labels = + List.init cases_len (fun i -> + let label = + Label.fresh ("switch_int_" ^ Int.to_string i : Stdlib.String.t) + in + Hash_int.add label_table i label; + label) + in + let br_table = + let br_table = br_table labels default_label in + if min_index = 0 then obj @: [ br_table ] + else + let min_index = Int32.of_int min_index in + obj @: i32_const min_index @: I32_sub @: [ br_table ] + in + let blocks = + Lst.fold_left cases br_table (fun acc -> + fun (lhs, act) -> + let label = Hash_int.find_exn label_table (lhs - min_index) in + block ~label acc @: act @> [ br_ exit_label ]) + in + let blocks_with_default = + block ~label:default_label blocks @: default @> [ br_ exit_label ] + in + block ~label:exit_label ~result_ty blocks_with_default @: rest + else + let switches = + Lst.fold_right cases default (fun (lhs, act) -> + fun acc -> + let lhs = Int32.of_int lhs in + if_ ~result_ty + ~condition:(obj @: i32_const lhs @: [ I32_eq ]) + ~then_:act ~else_:acc ()) + in + switches @> rest + +let compile_source_pos ~pkg (pos : Lexing.position) = + let file = pos.pos_fname in + let line = pos.pos_lnum in + let col = pos.pos_cnum - pos.pos_bol in + Ast.Source_pos { pkg; file; line; col } + +let prepend_source_pos ~get_pos (loc : Loc.t option) (v : instr list) = + if !Config.debug then + match loc with + | None -> v + | Some loc -> + let pos : Lexing.position = get_pos loc in + if pos.pos_cnum = -1 then v + else compile_source_pos ~pkg:(Loc.package loc) pos :: v + else v + +let prepend_start_source_pos (loc : Loc.t option) (v : instr list) = + prepend_source_pos ~get_pos:Loc.get_start loc v + +let prepend_end_source_pos (loc : Loc.t option) (v : instr list) = + prepend_source_pos ~get_pos:Loc.get_end loc v + +let compile_fn_source_name (fn_addr : Fn_address.t) = + if !Config.debug then + let name = Fn_address.source_name fn_addr in + Some name + else None + +let compile_prologue_end () = if !Config.debug then [ Ast.Prologue_end ] else [] diff --git a/src/wasmlinear_constr.ml b/src/wasmlinear_constr.ml new file mode 100644 index 0000000..c41b274 --- /dev/null +++ b/src/wasmlinear_constr.ml @@ -0,0 +1,438 @@ +(* + Copyright (C) 2024 International Digital Economy Academy. + This program is licensed under the MoonBit Public Source + License as published by the International Digital Economy Academy, + either version 1 of the License, or (at your option) any later + version. This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MoonBit + Public Source License for more details. You should have received a + copy of the MoonBit Public Source License along with this program. If + not, see + . +*) + + +module Config = Basic_config +module Itype = Dwarfsm_itype +module Ident = Clam1_ident +module Ast = Dwarfsm_ast +module Lst = Basic_lst + +type instr = Ast.instr + +let empty_binder () = ({ id = None; index = -1 } : Dwarfsm_ast.binder) + +let comp_to_sub (comp : Ast.comptype) = + ({ final = true; super = []; type_ = comp } : Ast.subtype) + +let mk_functype (params : Ast.param list) (results : Ast.valtype list) = + (Functype (Func (params, results)) : Ast.comptype) + +let esc_then_decode s = + let s = String.escaped s in + let b = Buffer.create (String.length s) in + let i = ref 0 in + while !i < String.length s do + (try + let c = + if s.[!i] <> '\\' then s.[!i] + else + match + incr i; + s.[!i] + with + | 'n' -> '\n' + | 'r' -> '\r' + | 't' -> '\t' + | '\\' -> '\\' + | '\'' -> '\'' + | '"' -> '"' + | 'u' -> + let j = !i + 2 in + i := String.index_from s j '}'; + let n = int_of_string ("0x" ^ String.sub s j (!i - j)) in + Buffer.add_utf_8_uchar b (Uchar.of_int n); + raise Exit + | h -> + incr i; + Char.chr + (int_of_string ("0x" ^ String.make 1 h ^ String.make 1 s.[!i])) + in + Buffer.add_char b c + with Exit -> ()); + incr i + done; + Buffer.contents b + +let localidx s = ({ var = Unresolve s } : Ast.localidx) +let labelidx s = ({ var = Unresolve s } : Ast.labelidx) +let binder s = ({ id = Some s; index = -1 } : Dwarfsm_ast.binder) + +let global (id : Ident.t) (type_ : Ast.globaltype) (init : instr list) = + (let id = binder (Ident.to_wasm_name id) in + Global { id; type_; init } + : Ast.modulefield) + +let immut (type_ : Ast.valtype) = ({ mut = Const; type_ } : Ast.globaltype) +let mut (type_ : Ast.valtype) = ({ mut = Var; type_ } : Ast.globaltype) +let i32 = Ast.Numtype I32 +let i64 = Ast.Numtype I64 +let f32 = Ast.Numtype F32 +let f64 = Ast.Numtype F64 +let funcref = Ast.Reftype (Ref (Nullable, Absheaptype Func)) +let externref = Ast.Reftype (Ref (Nullable, Absheaptype Extern)) + +let data ~(offset : int32) data_str = + [ + Ast.Data + { + id = empty_binder (); + mode = + Ast.DMActive + ( { var = Unresolve Ast.default_memory_name }, + [ Ast.I32_const offset ] ); + data_str; + }; + ] + +let table ~id ~type_ ~fn_names () = + let n = Int32.of_int (List.length fn_names) in + let name = id in + let id = binder id in + [ + Ast.Table + { + id; + type_ = { limits = { min = n; max = Some n }; element_type = type_ }; + init = []; + }; + Ast.Elem + { + id = { id = None; index = -1 }; + type_; + mode = Ast.EMActive ({ var = Unresolve name }, [ I32_const 0l ]); + list = fn_names; + }; + ] + +let import ~module_ ~name desc = [ Ast.Import { module_; name; desc } ] + +let import_tag ?(params = []) ?(results = []) name = + (Ast.Tag (binder name, Inline (params, results)) : Ast.importdesc) + +let import_func ?(params = []) ?(results = []) name = + (Ast.Func (binder name, Inline (params, results)) : Ast.importdesc) + +let export ~name ?func ?(func_ = "") () = + let funcname : Ast.funcidx = + match func with + | None -> if func_ = "" then assert false else { var = Unresolve func_ } + | Some addr -> { var = Unresolve (Basic_fn_address.to_wasm_name addr) } + in + [ Ast.Export { name; desc = Func funcname } ] + +let memory ~name ~export ~import ~shared limits = + let id = binder name in + let esc_then_decode = esc_then_decode in + let export = + match export with + | None -> [] + | Some mem_name -> ( + let s = esc_then_decode mem_name in + match[@warning "-fragile-match"] id.id with + | Some var_name -> + [ + Ast.Export + { name = s; desc = Memory { var = Unresolve var_name } }; + ] + | _ -> assert false) + in + let memory = + match import with + | None -> Ast.Mem { id; type_ = { limits; shared } } + | Some (module_name, mem_name) -> + let s1 = esc_then_decode module_name in + let s2 = esc_then_decode mem_name in + Ast.Import + { module_ = s1; name = s2; desc = Memory (id, { limits; shared }) } + in + memory :: export + +let source_type_ (typ : Ltype.t) = + (if !Config.debug then + match typ with + | I32 { kind = I32_Int } -> Some Int + | I32 { kind = I32_Char } -> Some Char + | I32 { kind = I32_Bool } -> Some Bool + | I32 { kind = I32_Unit } -> Some Unit + | I32 { kind = I32_Byte } -> Some Byte + | I32 { kind = I32_Int16 } -> Some Int16 + | I32 { kind = I32_UInt16 } -> Some UInt16 + | I64 -> Some Int64 + | F64 -> Some Double + | F32 -> Some Float + | U32 -> Some Uint + | U64 -> Some UInt64 + | _ -> None + else None + : Itype.t option) + +let source_name_ (source_name : string) = + if !Config.debug then Some source_name else None + +let result (typ : Ltype.t) = + (match typ with + | Ref_any -> Numtype I32 + | Ref _ -> Numtype I32 + | Ref_lazy_init _ -> Numtype I32 + | Ref_nullable _ -> Numtype I32 + | Ref_string -> Numtype I32 + | Ref_bytes -> Numtype I32 + | I32 { kind = I32_Option_Char } -> Numtype I32 + | I32 { kind = I32_Tag } -> Numtype I32 + | I32 { kind = I32_Int } -> Numtype I32 + | I32 { kind = I32_Char } -> Numtype I32 + | I32 { kind = I32_Bool } -> Numtype I32 + | I32 { kind = I32_Unit } -> Numtype I32 + | I32 { kind = I32_Byte } -> Numtype I32 + | I32 { kind = I32_Int16 } -> Numtype I32 + | I32 { kind = I32_UInt16 } -> Numtype I32 + | I64 -> Numtype I64 + | F64 -> Numtype F64 + | F32 -> Numtype F32 + | Ref_extern -> Reftype (Ref (Nullable, Absheaptype Extern)) + | Ref_func -> Reftype (Ref (Nullable, Absheaptype Func)) + | Raw_func _ -> Numtype I32 + | U32 -> Numtype I32 + | U64 -> Numtype I64 + : Ast.valtype) + +let param ?id ?id_ (ltype : Ltype.t) = + (let source_name = + match id with + | None -> None + | Some id -> source_name_ (Ident.source_name id) + in + let id = + match id with + | None -> ( match id_ with None -> empty_binder () | Some s -> binder s) + | Some s -> binder (Ident.to_wasm_name s) + in + let source_type = source_type_ ltype in + let type_ = result ltype in + { id; source_name; source_type; type_ } + : Ast.param) + +let local = param + +let func ?name ?(name_ = "") ?(source_name = None) ?(export = "") + ?(type_ = None) ?(params = []) ?(results = []) ?(locals = []) + (body : instr list) = + (let id = + match name with + | None -> if name_ = "" then empty_binder () else binder name_ + | Some addr -> binder (Basic_fn_address.to_wasm_name addr) + in + let export = + if export = "" then [] + else + match[@warning "-fragile-match"] id.id with + | Some name -> + [ + Ast.Export + { + name = esc_then_decode export; + desc = Func { var = Unresolve name }; + }; + ] + | _ -> assert false + in + let type_ : Ast.typeuse = + match type_ with + | None -> Inline (params, results) + | Some id -> Use ({ var = Unresolve id }, params, results) + in + [ + Ast.Func + ({ + id; + source_name; + type_; + locals; + code = body; + aux = { low_pc = 0; high_pc = 0 }; + } + : Ast.func); + ] + @ export + : Ast.modulefield list) + +let start ~(init : Basic_fn_address.t) = + [ Ast.Start { var = Unresolve (Basic_fn_address.to_wasm_name init) } ] + +let ( @: ) (instr : instr) (rest : instr list) = + match (instr, rest) with + | (F32_const _ | I64_const _ | I32_const _ | Local_get _), Drop :: rest -> + rest + | ( Local_set ({ var = Unresolve id1 } as localidx), + Local_get { var = Unresolve id2 } :: rest ) + when String.equal id1 id2 -> + Local_tee localidx :: rest + | Br _, _ -> [ instr ] + | _ -> instr :: rest + +let rec ( @> ) (instrs1 : instr list) (instrs2 : instr list) = + match instrs1 with + | [] -> instrs2 + | instr :: [] -> instr @: instrs2 + | instr :: rest -> instr @: rest @> instrs2 + +let local_get (id : string) = + let id = localidx id in + Ast.Local_get id + +let local_set (id : string) = + let id = localidx id in + Ast.Local_set id + +let global_get (id : string) = + let id : Ast.globalidx = { var = Unresolve id } in + Ast.Global_get id + +let generic_get (id : Ident.t) = + match id with + | Pident _ | Pmutable_ident _ -> local_get (Ident.to_wasm_name id) + | Pdot _ -> global_get (Ident.to_wasm_name id) + +let global_set (id : string) = + let id : Ast.globalidx = { var = Unresolve id } in + Ast.Global_set id + +let local_tee (id : string) = + let id = localidx id in + Ast.Local_tee id + +let call fnname = + let fnname : Ast.funcidx = { var = Unresolve fnname } in + Ast.Call fnname + +let call_indirect (typ : string) = + let tableidx : Ast.tableidx = { var = Unresolve Ast.default_table_name } in + let typ = Ast.Use ({ var = Unresolve typ }, [], []) in + Ast.Call_indirect (tableidx, typ) + +let int_const (i : int) = Ast.I32_const (Int32.of_int i) +let i32_const (i : int32) = Ast.I32_const i +let i64_const (i : int64) = Ast.I64_const i + +let float_to_string f = + let str = Printf.sprintf "%h" f in + match str with "-infinity" -> "-inf" | "infinity" -> "inf" | s -> s + +let f32_const (i : float) = Ast.F32_const (float_to_string i, i) +let f64_const (i : float) = Ast.F64_const (float_to_string i, i) + +let mk_memarg ?(offset = 0) ?(align = 0) () = + ({ offset = Int32.of_int offset; align = Int32.of_int align } : Ast.memarg) + +let i32_load ?(offset = 0) ?(align = 0) () = + Ast.I32_load (mk_memarg ~offset ~align ()) + +let i32_load8_u ?(offset = 0) ?(align = 0) () = + Ast.I32_load8_u (mk_memarg ~offset ~align ()) +[@@dead "+i32_load8_u"] + +let i32_load16_u ?(offset = 0) ?(align = 0) () = + Ast.I32_load16_u (mk_memarg ~offset ~align ()) +[@@dead "+i32_load16_u"] + +let i32_load16_s ?(offset = 0) ?(align = 0) () = + Ast.I32_load16_s (mk_memarg ~offset ~align ()) +[@@dead "+i32_load16_u"] + +let i32_store ?(offset = 0) ?(align = 0) () = + Ast.I32_store (mk_memarg ~offset ~align ()) + +let i32_store8 ?(offset = 0) ?(align = 0) () = + Ast.I32_store8 (mk_memarg ~offset ~align ()) +[@@dead "+i32_store8"] + +let i32_store16 ?(offset = 0) ?(align = 0) () = + Ast.I32_store16 (mk_memarg ~offset ~align ()) +[@@dead "+i32_store16"] + +let i64_load ?(offset = 0) ?(align = 0) () = + Ast.I64_load (mk_memarg ~offset ~align ()) + +let i64_store ?(offset = 0) ?(align = 0) () = + Ast.I64_store (mk_memarg ~offset ~align ()) + +let f32_load ?(offset = 0) ?(align = 0) () = + Ast.F32_load (mk_memarg ~offset ~align ()) + +let f32_store ?(offset = 0) ?(align = 0) () = + Ast.F32_store (mk_memarg ~offset ~align ()) + +let f64_load ?(offset = 0) ?(align = 0) () = + Ast.F64_load (mk_memarg ~offset ~align ()) + +let f64_store ?(offset = 0) ?(align = 0) () = + Ast.F64_store (mk_memarg ~offset ~align ()) + +let ref_null (t : Ast.valtype) = + match t with + | Reftype (Ref (Nullable, ht)) -> Ast.Ref_null ht + | _ -> assert false + +let ref_func addr = + let fnname : Ast.funcidx = + { var = Unresolve (Basic_fn_address.to_wasm_name addr) } + in + Ast.Ref_func fnname + +let if_ ?label ?(result_ty = []) ?condition ~then_ ~else_ () = + let condition = match condition with None -> [] | Some instrs -> instrs in + condition + @> [ Ast.If { label; typeuse = Inline ([], result_ty); then_; else_ } ] + +let block ?label ?label_ ?(result_ty = []) instrs = + let label = + match label with None -> label_ | Some l -> Some (Label.to_wasm_name l) + in + Ast.Block { label; typeuse = Inline ([], result_ty); instrs } + +let loop ?label ?label_ ?(params = []) ?(result_ty = []) instrs = + let label = + match label with None -> label_ | Some l -> Some (Label.to_wasm_name l) + in + Ast.Loop { label; typeuse = Inline (params, result_ty); instrs } + +let br label = + let idx = labelidx label in + Ast.Br idx + +let br_ label = br (Label.to_wasm_name label) + +let br_table labels label = + let label = labelidx (Label.to_wasm_name label) in + let labels = Lst.map labels (fun l -> labelidx (Label.to_wasm_name l)) in + Ast.Br_table (labels, label) + +let unreachable = Ast.Unreachable + +let table_get id = + let id : Ast.tableidx = { var = Unresolve id } in + Ast.Table_get id + +let catch ~(tag : string) ~(label : Label.t) = + let labelidx = labelidx (Label.to_wasm_name label) in + let tagidx : Ast.tagidx = { var = Unresolve tag } in + Ast.Catch (tagidx, labelidx) + +let try_table ?label ?result_ty ?(catchs = []) instrs = + let label = + match label with None -> None | Some l -> Some (Label.to_wasm_name l) + in + let result_ty = match result_ty with None -> [] | Some r -> r in + Ast.Try_table { label; typeuse = Inline ([], result_ty); catchs; instrs }